Encloses LArSoft data product proxy objects and utilities.See this doxygen module for an introduction to data proxies in LArSoft. More...

Namespaces
	details

Classes
class	AssociatedDataProxyMaker
	Creates an associated data wrapper for the specified types. More...

struct	AssociatedDataProxyMakerBase
	Creates an associated data wrapper for the specified types. More...

struct	ChargedSpacePoints
	Proxy tag for a `recob::SpacePoint` collection with charge. More...

class	ChargedSpacePointsCollectionProxy
	Proxy collection class for space points associated to charge. More...

class	CollectionProxyBase
	Base representation of a collection of proxied objects. More...

struct	CollectionProxyElement
	An element of a collection proxy. More...

struct	CollectionProxyMaker
	Class to assemble the required proxy. More...

struct	CollectionProxyMaker< Tracks >
	Specialization to create a proxy for `recob::Track` collection. More...

struct	CollectionProxyMakerBase
	Class to assemble the required proxy. More...

struct	CollectionProxyMakerTraits
	Collection of data type definitions for collection proxies. More...

struct	CollectionProxyMakerTraits< ChargedSpacePoints >
	Traits of `proxy::ChargedSpacePoints` proxy. More...

struct	CollectionProxyMakerTraits< CollectionProxy< MainColl > >

struct	CollectionProxyMakerTraits< std::vector< T > >

struct	CollectionProxyMakerTraits< Tracks >
	Define the traits of `proxy::Tracks` proxy. More...

class	OneTo01DataProxyMaker
	Creates an one-to-(zero-or-one) wrapper for the specified types. More...

struct	OneTo01DataProxyMakerBase
	Creates an one-to-(zero-or-one) wrapper for the specified types. More...

class	ParallelDataProxyMaker
	Creates an associated data wrapper for the specified types. More...

struct	ParallelDataProxyMakerBase
	Creates an parallel data wrapper for the specified types. More...

class	ProxyAsAuxProxyMaker
	Creates an auxiliary proxy wrapper for the specified proxy. More...

struct	ProxyAsAuxProxyMakerBase
	Creates a proxy wrapper for merging into another proxy ("main"). More...

struct	SpacePointWithCharge
	Proxy class for charged space point proxy elements. More...

struct	TrackCollectionProxyElement
	Class for track proxy elements. More...

struct	TrackPoint
	Type of track point information. More...

class	TrackPointIterator

class	TrackPointWrapper
	Wrapper for a track data proxy. More...

struct	Tracks
	Proxy tag for a `recob::Track` collection proxy. More...

Typedefs
template<typename MainColl , typename... AuxColls>
using	CollectionProxy = CollectionProxyBase< CollectionProxyElement, MainColl, AuxColls... >
	Base representation of a collection of proxied objects. More...

template<typename... Args>
using	CollectionProxyFromArgs = typename details::TemplateAdaptorOnePlus< CollectionProxy, Args... >::type

using	TrackPointData = std::tuple< recob::Track const , art::Ptr< recob::Hit >, recob::TrackFitHitInfo const , std::size_t >
	Container of track point information. More...

template<typename TrackCollProxy >
using	Track = TrackCollectionProxyElement< TrackCollProxy >
	Proxy to an element of a proxy collection of `recob::Track` objects. More...

Functions
template<typename Tag = proxy::ChargedSpacePoints::ChargeTag>
auto	withCharge (art::InputTag inputTag)
	Adds additional `recob::PointCharge` information to the proxy. More...

template<typename Event , typename... Args>
auto	getChargedSpacePoints (Event const &event, art::InputTag inputTag, Args &&...withArgs)
	Creates and returns a proxy to space points with associated charge. More...

template<typename CollProxy , typename Event , typename... OptionalArgs>
auto	getCollection (Event const &event, OptionalArgs &&...optionalArgs)
	Creates a proxy to a data product collection. More...

template<typename Tag , typename Assns >
auto	makeAssociatedDataFrom (Assns const &assns, std::size_t minSize=0)

template<typename Assns >
auto	makeAssociatedDataFrom (Assns const &assns, std::size_t minSize=0)

template<typename Main , typename Aux , typename Metadata , typename Tag , typename Event >
auto	makeAssociatedDataFrom (Event const &event, art::InputTag const &tag, std::size_t minSize=0)
	Creates and returns an associated data object. More...

template<typename Main , typename Aux , typename Metadata , typename Event >
auto	makeAssociatedDataFrom (Event const &event, art::InputTag const &tag, std::size_t minSize=0)

template<typename Main , typename Aux , typename Event >
auto	makeAssociatedDataFrom (Event const &event, art::InputTag const &tag, std::size_t minSize=0)

template<typename Aux , typename Metadata , typename Tag , typename Handle , typename Event >
auto	makeAssociatedDataFrom (Handle &&handle, Event const &event, art::InputTag const &tag)
	Creates and returns an associated data object. More...

template<typename Aux , typename Metadata , typename Handle , typename Event >
auto	makeAssociatedDataFrom (Handle &&handle, Event const &event, art::InputTag const &tag)

template<typename Aux , typename Handle , typename Event >
auto	makeAssociatedDataFrom (Handle &&handle, Event const &event, art::InputTag const &tag)

template<typename Tag , typename MainColl , typename Assns >
auto	makeAssociatedDataFrom (MainColl const &mainColl, Assns const &assns)
	Creates and returns an associated data object. More...

template<typename MainColl , typename Assns >
auto	makeAssociatedDataFrom (MainColl const &mainColl, Assns const &assns)

template<typename Tag , typename Assns >
auto	makeOneTo01dataFrom (Assns const &assns, std::size_t minSize=0)
	Processes and returns an one-to-(zero/one) associated data object. More...

template<typename Assns >
auto	makeOneTo01dataFrom (Assns const &assns, std::size_t minSize=0)

template<typename Main , typename Aux , typename Metadata , typename Tag , typename Event >
auto	makeOneTo01dataFrom (Event const &event, art::InputTag const &tag, std::size_t minSize=0)
	Creates and returns an one-to-(zero/one) associated data object. More...

template<typename Main , typename Aux , typename Metadata , typename Event >
auto	makeOneTo01dataFrom (Event const &event, art::InputTag const &tag, std::size_t minSize=0)

template<typename Aux , typename Metadata , typename Tag , typename Handle , typename Event >
auto	makeOneTo01dataFrom (Handle &&handle, Event const &event, art::InputTag const &tag)
	Creates and returns an one-to-(zero/one) associated data object. More...

template<typename Aux , typename Metadata , typename Handle , typename Event >
auto	makeOneTo01dataFrom (Handle &&handle, Event const &event, art::InputTag const &tag)

template<typename Tag , typename MainColl , typename Assns >
auto	makeOneTo01dataFrom (MainColl const &mainColl, Assns const &assns)
	Creates and returns an one-to-(zero/one) associated data object. More...

template<typename MainColl , typename Assns >
auto	makeOneTo01dataFrom (MainColl const &mainColl, Assns const &assns)

template<typename AuxColl , typename Aux = util::collection_value_t<AuxColl>, typename Tag = Aux>
auto	makeParallelDataFrom (AuxColl const &data)
	Wraps a collection into a parallel data collection object. More...

template<typename AuxColl , typename Aux , typename Tag , typename Event >
auto	makeParallelDataFrom (Event const &event, art::InputTag const &tag)
	Creates and returns a parallel data collection object. More...

template<typename AuxColl , typename Aux , typename Event >
auto	makeParallelDataFrom (Event const &event, art::InputTag const &tag)

template<typename AuxColl , typename Event >
auto	makeParallelDataFrom (Event const &event, art::InputTag const &tag)

template<typename AuxColl , typename Aux = util::collection_value_t<AuxColl>, typename Tag = Aux>
auto	makeParallelData (AuxColl const &data)
	Wraps a collection into a parallel data collection object. More...

template<typename Tag , typename Aux , typename AuxProxyColl >
auto	makeProxyAsParallelData (AuxProxyColl &&auxProxy)

template<typename AuxProxy , typename AuxTag , typename... Args>
auto	withCollectionProxyAs (Args &&...args)

template<typename AuxProxy , typename... Args>
auto	withCollectionProxy (Args &&...args)
	Helper function to merge an auxiliary proxy into the proxy. More...

template<typename TrackProxy >
TrackPointData	makeTrackPointData (TrackProxy const &track, std::size_t index)
	Returns an object with information about the specified track point. More...

template<typename Data >
auto	wrapTrackPoint (Data const &wrappedData)
	"Converts" point data into a `proxy::TrackPointWrapper`. More...


template<typename Tag , typename Assns >
auto	makeAssociatedData (Assns const &assns, std::size_t minSize=0)
	Processes and returns an associated data object. More...

template<typename Assns >
auto	makeAssociatedData (Assns const &assns, std::size_t minSize=0)
	Processes and returns an associated data object. More...


template<typename Tag , typename MainColl , typename Assns >
auto	makeAssociatedData (MainColl const &mainColl, Assns const &assns)
	Creates and returns an associated data object. More...

template<typename MainColl , typename Assns >
auto	makeAssociatedData (MainColl const &mainColl, Assns const &assns)
	Creates and returns an associated data object. More...


template<typename Tag , typename Assns >
auto	makeOneTo01data (Assns const &assns, std::size_t minSize=0)
	Processes and returns an one-to-(zero/one) associated data object. More...

template<typename Assns >
auto	makeOneTo01data (Assns const &assns, std::size_t minSize=0)
	Processes and returns an one-to-(zero/one) associated data object. More...


template<typename Tag , typename MainColl , typename Assns >
auto	makeOneTo01data (MainColl const &mainColl, Assns const &assns)
	Creates and returns an one-to-(zero/one) associated data object. More...

template<typename MainColl , typename Assns >
auto	makeOneTo01data (MainColl const &mainColl, Assns const &assns)
	Creates and returns an one-to-(zero/one) associated data object. More...

One-to-many sequential associations
These functions allow to merge into a data collection proxy auxiliary data via an art association fulfilling the one-to-many sequential association requirement. Two categories of functions are available depending on the data source: `proxy::withAssociated()` reads the relevant association from an event `proxy::wrapAssociated()` uses an existing association objects Variants of `proxy::withAssociated()` called `proxy::withAssociatedMeta()` allow merging the metadata of an association too. The `proxy::wrapAssociated()` functions always merge the metadata if the wrapped association has it. Also, variants are available to customize the tag class. The implementation of this feature is documented in its own doxygen module.
template<typename Aux , typename Metadata , typename AuxTag , typename... Args>
auto	withAssociatedMetaAs (Args &&...args)
	Helper function to merge associated data with metadata. More...

template<typename Aux , typename AuxTag , typename... Args>
auto	withAssociatedAs (Args &&...args)
	Helper function to merge associated data with no metadata. More...

template<typename Aux , typename Metadata , typename... Args>
auto	withAssociatedMeta (Args &&...args)
	Helper function to merge associated data. More...

template<typename Aux , typename... Args>
auto	withAssociated (Args &&...args)
	Helper function to merge associated data with no metadata. More...

template<typename AuxTag , typename Assns >
auto	wrapAssociatedAs (Assns const &assns)
	Helper function to merge associated data from a given association. More...

template<typename Assns >
auto	wrapAssociated (Assns const &assns)
	Helper function to merge associated data from a given association. More...

template<typename AuxTag , typename Assns >
auto	wrapAssociated (Assns const &assns)
	Helper function to merge associated data from a given association. More...

Parallel data collections
These functions allow to merge into a data collection proxy some auxiliary data from other collections fulfilling the parallel data product requirement. Two categories of functions are available depending on the data source: `proxy::withParallelData()` reads the relevant data product from an event `proxy::wrapParallelData()` uses an existing collection Also, variants are available to customize the tag class. The implementation of this feature is documented in its own doxygen module.
template<typename Aux , typename AuxTag , typename... Args>
auto	withParallelDataAs (Args &&...args)
	Helper function to merge an auxiliary data product into the proxy. More...

template<typename Aux , typename... Args>
auto	withParallelData (Args &&...args)
	Helper function to merge an auxiliary data product into the proxy. More...

template<typename AuxTag , typename AuxColl >
auto	wrapParallelDataAs (AuxColl const &auxColl)
	Uses a collection as auxiliary data for a collection proxy. More...

template<typename AuxColl >
auto	wrapParallelData (AuxColl const &auxColl)
	Uses a collection as auxiliary data for a collection proxy. More...

One-to-one (optional) associations
These functions allow to merge into a data collection proxy some auxiliary data via an art association fulfilling the one-to-(zero-or-one) sequential association requirement. One category of functions is currently available: `proxy::withZeroOrOne()` reads the relevant association from an event Variants of `proxy::withZeroOrOne()` called `proxy::withZeroOrOneMeta()` will allow merging the metadata of an association too. This feature is not supported yet, though. Also, variants are available to customize the tag class. The implementation of this feature is documented in its own doxygen module.
template<typename Aux , typename Metadata , typename AuxTag , typename... Args>
auto	withZeroOrOneMetaAs (Args &&...args)

template<typename Aux , typename AuxTag , typename... Args>
auto	withZeroOrOneAs (Args &&...args)

template<typename Aux , typename Metadata , typename... Args>
auto	withZeroOrOneMeta (Args &&...args)
	Helper function to merge one-to-(zero-or-one) associated data. More...

template<typename Aux , typename... Args>
auto	withZeroOrOne (Args &&...args)

Auxiliary data
These functions may be used as arguments to `proxy::getCollection<proxy::Tracks>()` call to merge of some data associated to the tracks.
auto	withOriginalTrajectory (art::InputTag const &inputTag)
	Adds `recob::TrackTrajectory` information to the proxy. More...

auto	withOriginalTrajectory ()
	Adds `recob::TrackTrajectory` information to the proxy. More...

auto	withFitHitInfo (art::InputTag const &inputTag)
	Adds `recob::TrackFitHitInfo` information to the proxy. More...

auto	withFitHitInfo ()
	Adds `recob::TrackFitHitInfo` information to the proxy. More...

Detailed Description

Encloses LArSoft data product proxy objects and utilities.

See this doxygen module for an introduction to data proxies in LArSoft.

Function Documentation

template<typename Tag , typename Assns >

auto proxy::makeAssociatedData	(	Assns const &	assns,
		std::size_t	minSize = `0`
	)

Processes and returns an associated data object.

Template Parameters

Tag	the tag labelling this associated data (if omitted: second type of the association: `right_t`)
Assns	type of association to be processed

Parameters

assns	association object to be processed
minSize	minimum number of entries in the produced association data

Returns: a new AssociatedData filled with associations from tag

The content of the association object must fulfill the requirements of one-to-many sequential association. The Assns type is expected to be a art::Assns instance. At least, the Assns type is required to have left_t and right_t definitions representing respectively the main data type and the associated one, and to respond to begin() and end() functions. The iterated object must also respond to std::get<0>() with a art::Ptr<left_t> and to std::get<1>() with a art::Ptr<right_t>.

Elements in the main collection not associated with any object will be recorded as such. If there is information for less than minSize main objects, more records will be added to mark the missing objects as not associated to anything.

Example:

art::Assns<recob::Track, recob::Hit> trackHitAssns;
// ...
auto assData = proxy::makeAssociatedData(assns);

will have assData tagged as recob::Hit.

Definition at line 1040 of file AssociatedData.h.

References evd::details::begin(), and evd::details::end().

   {
     using Main_t = typename Assns::left_t;
     using Aux_t = typename Assns::right_t;
     using Metadata_t = lar::util::assns_metadata_t<Assns>;
     using AssociatedData_t
       = details::AssociatedData<Main_t, Aux_t, Metadata_t, Tag>;
     
     // associationRangeBoundaries() produces iterators to association elements,
     // (i.e. tuples)
     using std::begin;
     using std::end;
     auto ranges = details::associationRangeBoundaries<0U>
       (begin(assns), end(assns), minSize);
     // we convert those iterators into iterators to the right associated item
     // (it takes a few steps)
     using group_ranges_t = typename AssociatedData_t::group_ranges_t;
     return AssociatedData_t(
       group_ranges_t
         (typename group_ranges_t::boundaries_t(ranges.begin(), ranges.end()))
       );
   } // makeAssociatedDataFrom(assns)

template<typename Assns >

auto proxy::makeAssociatedData	(	Assns const &	assns,
		std::size_t	minSize = `0`
	)

Processes and returns an associated data object.

Template Parameters

Tag	the tag labelling this associated data (if omitted: second type of the association: `right_t`)
Assns	type of association to be processed

Parameters

assns	association object to be processed
minSize	minimum number of entries in the produced association data

Returns: a new AssociatedData filled with associations from tag

The content of the association object must fulfill the requirements of one-to-many sequential association. The Assns type is expected to be a art::Assns instance. At least, the Assns type is required to have left_t and right_t definitions representing respectively the main data type and the associated one, and to respond to begin() and end() functions. The iterated object must also respond to std::get<0>() with a art::Ptr<left_t> and to std::get<1>() with a art::Ptr<right_t>.

Elements in the main collection not associated with any object will be recorded as such. If there is information for less than minSize main objects, more records will be added to mark the missing objects as not associated to anything.

Example:

art::Assns<recob::Track, recob::Hit> trackHitAssns;
// ...
auto assData = proxy::makeAssociatedData(assns);

will have assData tagged as recob::Hit.

Definition at line 880 of file AssociatedData.h.

881 { return makeAssociatedData<typename Assns::right_t>(assns, minSize); }

template<typename Tag , typename MainColl , typename Assns >

auto proxy::makeAssociatedData	(	MainColl const &	mainColl,
		Assns const &	assns
	)

Creates and returns an associated data object.

Template Parameters

Tag	the tag labelling this associated data (if omitted: second type of the association: `right_t`)
MainColl	type of the main collection object
Assns	type of the association object

Parameters

mainColl	the main collection object
assns	association data object

Returns: a new AssociatedData wrapping the information in assns

See also: makeAssociatedData(Assns const&, std::size_t)

This function operates like makeAssociatedData(Assns const&, std::size_t), where the size is extracted from the main data collection.

Definition at line 902 of file AssociatedData.h.

903 { return makeAssociatedData<Tag>(assns, mainColl.size()); }

template<typename MainColl , typename Assns >

auto proxy::makeAssociatedData	(	MainColl const &	mainColl,
		Assns const &	assns
	)

Creates and returns an associated data object.

Template Parameters

Tag	the tag labelling this associated data (if omitted: second type of the association: `right_t`)
MainColl	type of the main collection object
Assns	type of the association object

Parameters

mainColl	the main collection object
assns	association data object

Returns: a new AssociatedData wrapping the information in assns

See also: makeAssociatedData(Assns const&, std::size_t)

This function operates like makeAssociatedData(Assns const&, std::size_t), where the size is extracted from the main data collection.

Definition at line 906 of file AssociatedData.h.

References proxy::details::associationRangesImpl().

907 { return makeAssociatedData<typename Assns::right_t>(mainColl, assns); }

template<typename Tag , typename Assns >

auto proxy::makeOneTo01data	(	Assns const &	assns,
		std::size_t	minSize = `0`
	)

Processes and returns an one-to-(zero/one) associated data object.

Template Parameters

Tag	the tag labelling this associated data (if omitted: second type of the association: `right_t`)
Assns	type of association to be processed

Parameters

assns	association object to be processed
minSize	minimum number of entries in the produced association data

Returns: a new OneTo01Data filled with associations from tag

The content of the association object must fulfill the requirements of one-to-(zero or one) sequential association. The Assns type is expected to be a art::Assns instance. At least, the Assns type is required to have left_t and right_t definitions representing respectively the main data type and the associated one, and to respond to begin() and end() functions. The iterated object must also respond to std::get<0>() with a art::Ptr<left_t> and to std::get<1>() with a art::Ptr<right_t>.

Elements in the main collection not associated with any object will present an invalid art pointer (isNull() true). If there is information for less than minSize main objects, more records will be added to mark the missing objects as not associated to anything.

Example:

art::Assns<recob::Track, recob::Vertex> trackVertexAssns;
// ...
auto assData = proxy::makeOneTo01data(assns);

will have assData tagged as recob::Vertex.

If Tag type is omitted, the class to the right side of the association is used as tag.

Definition at line 270 of file OneTo01Data.h.

Referenced by makeOneTo01dataFrom().

   {
     using Main_t = typename Assns::left_t;
     using Aux_t = typename Assns::right_t;
     using Metadata_t = lar::util::assns_metadata_t<Assns>;
     using AssociatedData_t
       = details::OneTo01Data<Main_t, Aux_t, Metadata_t, Tag>;
     
     using std::cbegin;
     using std::cend;
     return AssociatedData_t(
       details::associationOneToOneFullSequence<0U, 1U>
         (cbegin(assns), cend(assns), minSize)
       );
   } // makeOneTo01data(assns)

template<typename Assns >

auto proxy::makeOneTo01data	(	Assns const &	assns,
		std::size_t	minSize = `0`
	)

Processes and returns an one-to-(zero/one) associated data object.

Template Parameters

Tag	the tag labelling this associated data (if omitted: second type of the association: `right_t`)
Assns	type of association to be processed

Parameters

assns	association object to be processed
minSize	minimum number of entries in the produced association data

Returns: a new OneTo01Data filled with associations from tag

The content of the association object must fulfill the requirements of one-to-(zero or one) sequential association. The Assns type is expected to be a art::Assns instance. At least, the Assns type is required to have left_t and right_t definitions representing respectively the main data type and the associated one, and to respond to begin() and end() functions. The iterated object must also respond to std::get<0>() with a art::Ptr<left_t> and to std::get<1>() with a art::Ptr<right_t>.

Elements in the main collection not associated with any object will present an invalid art pointer (isNull() true). If there is information for less than minSize main objects, more records will be added to mark the missing objects as not associated to anything.

Example:

art::Assns<recob::Track, recob::Vertex> trackVertexAssns;
// ...
auto assData = proxy::makeOneTo01data(assns);

will have assData tagged as recob::Vertex.

If Tag type is omitted, the class to the right side of the association is used as tag.

Definition at line 168 of file OneTo01Data.h.

169 { return makeOneTo01data<typename Assns::right_t>(assns, minSize); }

template<typename Tag , typename MainColl , typename Assns >

auto proxy::makeOneTo01data	(	MainColl const &	mainColl,
		Assns const &	assns
	)

Creates and returns an one-to-(zero/one) associated data object.

Template Parameters

Tag	the tag labelling this associated data (if omitted: second type of the association: `right_t`)
MainColl	type of the main collection object
Assns	type of the association object

Parameters

mainColl	the main collection object
assns	association data object

Returns: a new OneTo01Data wrapping the information in assns

See also: makeOneTo01data(Assns const&, std::size_t)

This function operates like makeOneTo01data(Assns const&, std::size_t), where the size is extracted from the main data collection.

If Tag type is omitted, the class to the right side of the association is used as tag.

Definition at line 192 of file OneTo01Data.h.

193 { return makeOneTo01data<Tag>(assns, mainColl.size()); }

template<typename MainColl , typename Assns >

auto proxy::makeOneTo01data	(	MainColl const &	mainColl,
		Assns const &	assns
	)

Creates and returns an one-to-(zero/one) associated data object.

Template Parameters

Tag	the tag labelling this associated data (if omitted: second type of the association: `right_t`)
MainColl	type of the main collection object
Assns	type of the association object

Parameters

mainColl	the main collection object
assns	association data object

Returns: a new OneTo01Data wrapping the information in assns

See also: makeOneTo01data(Assns const&, std::size_t)

This function operates like makeOneTo01data(Assns const&, std::size_t), where the size is extracted from the main data collection.

If Tag type is omitted, the class to the right side of the association is used as tag.

Definition at line 196 of file OneTo01Data.h.

197 { return makeOneTo01data<typename Assns::right_t>(mainColl, assns); }

template<typename TrackProxy >

TrackPointData proxy::makeTrackPointData	(	TrackProxy const &	track,
		std::size_t	index
	)

Returns an object with information about the specified track point.

Template Parameters

TrackProxy an instance of proxy::Track template

Parameters

track	the track (proxy) the points belong to
index	the index of the point within the track

Returns: a TrackPointData object with information on that point

For an interface to the point information, see TrackPointWrapper.

Definition at line 708 of file Track.h.

Referenced by proxy::TrackPointIterator< TrackProxy >::operator*(), and proxy::TrackCollectionProxyElement< CollProxy >::point().

     {
       static_assert(details::isTrackProxy<TrackProxy>(), "Not a proxy::Track!");
       return {
         &(track.track()),
         track.hitAtPoint(index),
         track.fitInfoAtPoint(index),
         index
       };
     } // makeTrackPointData()

template<typename Data >

auto proxy::wrapTrackPoint ( Data const & wrappedData )

"Converts" point data into a proxy::TrackPointWrapper.

Definition at line 1262 of file Track.h.

     {
       (void) details::StaticAsserts<TrackPointWrapper<Data>>();
       return reinterpret_cast<TrackPointWrapper<Data> const&>(wrappedData); 
     }

Namespaces

Classes

Typedefs

Functions

Detailed Description

Function Documentation