Infrastructure for support of associated data. More...

Namespaces
	proxy::details

Classes
struct	proxy::AssociatedDataProxyMakerBase< Main, Aux, Metadata, AuxTag >
	Creates an associated data wrapper for the specified types. More...

class	proxy::AssociatedDataProxyMaker< Main, Aux, Metadata, CollProxy, Tag >
	Creates an associated data wrapper for the specified types. More...

struct	proxy::OneTo01DataProxyMakerBase< Main, Aux, Metadata, AuxTag >
	Creates an one-to-(zero-or-one) wrapper for the specified types. More...

class	proxy::OneTo01DataProxyMaker< Main, Aux, Metadata, CollProxy, Tag >
	Creates an one-to-(zero-or-one) wrapper for the specified types. More...

class	WithAssociatedStruct
	Helper to create associated data proxy. More...

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

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

template<typename Main , typename Aux , typename Metadata , typename Tag , typename Event >
auto	proxy::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	proxy::makeAssociatedDataFrom (Event const &event, art::InputTag const &tag, std::size_t minSize=0)

template<typename Main , typename Aux , typename Event >
auto	proxy::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	proxy::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	proxy::makeAssociatedDataFrom (Handle &&handle, Event const &event, art::InputTag const &tag)

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

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

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

template<typename Tag , typename Assns >
auto	proxy::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	proxy::makeOneTo01dataFrom (Assns const &assns, std::size_t minSize=0)

template<typename Main , typename Aux , typename Metadata , typename Tag , typename Event >
auto	proxy::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	proxy::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	proxy::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	proxy::makeOneTo01dataFrom (Handle &&handle, Event const &event, art::InputTag const &tag)

template<typename Tag , typename MainColl , typename Assns >
auto	proxy::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	proxy::makeOneTo01dataFrom (MainColl const &mainColl, Assns const &assns)

Detailed Description

Infrastructure for support of associated data.

Associated data is auxiliary data connected to the main data via art associations. The following associated data are currently supported:

one-to-many sequential association implicitly supporting also one-to-any (one-to-one, one-to-zero/or/one) in a non-optimized way
one-to-(zero-or-one) sequential association
parallel data product, implicit one-to-one associations

Function Documentation

template<typename Tag , typename Assns >

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

Definition at line 33 of file makeAssociatedDataFrom.h.

Referenced by proxy::makeAssociatedDataFrom().

   {
     return proxy::makeAssociatedData<Tag>(assns, minSize);
   }

template<typename Assns >

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

Definition at line 39 of file makeAssociatedDataFrom.h.

References proxy::makeAssociatedDataFrom().

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

template<typename Main , typename Aux , typename Metadata , typename Tag , typename Event >

auto proxy::makeAssociatedDataFrom	(	Event const &	event,
		art::InputTag const &	tag,
		std::size_t	minSize = `0`
	)

Creates and returns an associated data object.

Template Parameters

Main	type of main object to be associated
Aux	type of data to be associated to the main objects
Metadata	type of metadata in the association (if omitted: `void`)
Tag	the tag labelling this associated data (if omitted: `Aux`)
Event	type of event to read associations from

Parameters

event	event to read associations from
tag	input tag of the association object
minSize	minimum number of entries in the produced association data

Returns: a new AssociatedData filled with associations from tag

The association being retrieved must fulfill the requirements of one-to-many sequential association.

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.

Two template types must be explicitly specified, e.g.

auto assData = makeAssociatedDataFrom<recob::Track, recob::Hit>(event, tag);

Definition at line 170 of file makeAssociatedDataFrom.h.

   {
     using Main_t = Main;
     using Aux_t = Aux;
     using Metadata_t = Metadata;
     using AssociatedData_t = details::AssociatedData<Main_t, Aux_t, Metadata_t, Tag>;
     using Assns_t = typename AssociatedData_t::assns_t;
 
     return makeAssociatedDataFrom<Tag>(*(event.template getValidHandle<Assns_t>(tag)));
 
   } // makeAssociatedDataFrom(tag)

template<typename Main , typename Aux , typename Metadata , typename Event >

auto proxy::makeAssociatedDataFrom	(	Event const &	event,
		art::InputTag const &	tag,
		std::size_t	minSize = `0`
	)

Definition at line 75 of file makeAssociatedDataFrom.h.

   {
     return makeAssociatedDataFrom<Main, Aux, Metadata, Aux, Event>(event, tag, minSize);
   }

template<typename Main , typename Aux , typename Event >

auto proxy::makeAssociatedDataFrom	(	Event const &	event,
		art::InputTag const &	tag,
		std::size_t	minSize = `0`
	)

Definition at line 81 of file makeAssociatedDataFrom.h.

References proxy::makeAssociatedDataFrom().

   {
     return makeAssociatedDataFrom<Main, Aux, void, Aux, Event>(event, tag, minSize);
   }

template<typename Aux , typename Metadata , typename Tag , typename Handle , typename Event >

auto proxy::makeAssociatedDataFrom	(	Handle &&	handle,
		Event const &	event,
		art::InputTag const &	tag
	)

Creates and returns an associated data object.

Template Parameters

Aux	type of data to be associated to the main objects
Metadata	type of metadata in the association (if omitted: `void`)
Tag	the tag labelling this associated data (if omitted: `Aux`)
Handle	type of handle to the main collection object
Event	type of event to read associations from

Parameters

handle	handle to the main collection object
event	event to read associations from
tag	input tag of the association object

Returns: a new AssociatedData filled with associations from tag

See also: makeAssociatedDataFrom(Event const&, art::InputTag, std::size_t)

This function operates like makeAssociatedDataFrom(Event const&, art::InputTag, std::size_t), but it extracts the information about the type of main object and the minimum number of them from a handle. The handle object is expected to behave as a smart pointer to a collection of elements of the associated type.

One template type must be explicitly specified, e.g.

auto assData = makeAssociatedDataFrom<recob::Hit>(handle, event, tag);

Definition at line 187 of file makeAssociatedDataFrom.h.

   {
     // Handle::value_type is the main data product type (a collection)
     using Main_t = util::collection_value_t<typename Handle::value_type>;
     using Aux_t = Aux;
     using Metadata_t = Metadata;
     return makeAssociatedDataFrom<Main_t, Aux_t, Metadata_t, Tag>(event, tag, handle->size());
   } // makeAssociatedDataFrom(handle)

template<typename Aux , typename Metadata , typename Handle , typename Event >

auto proxy::makeAssociatedDataFrom	(	Handle &&	handle,
		Event const &	event,
		art::InputTag const &	tag
	)

Definition at line 115 of file makeAssociatedDataFrom.h.

   {
     return makeAssociatedDataFrom<Aux, Metadata, Aux, Handle, Event>(
       std::forward<Handle>(handle), event, tag);
   }

template<typename Aux , typename Handle , typename Event >

auto proxy::makeAssociatedDataFrom	(	Handle &&	handle,
		Event const &	event,
		art::InputTag const &	tag
	)

Definition at line 122 of file makeAssociatedDataFrom.h.

   {
     return makeAssociatedDataFrom<Aux, void, Aux, Handle, Event>(
       std::forward<Handle>(handle), event, tag);
   }

template<typename Tag , typename MainColl , typename Assns >

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

Creates and returns an associated data object.

Template Parameters

Tag	the tag labelling this associated data (if omitted: `Aux`)
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: makeAssociatedDataFrom(Assns const&, std::size_t)

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

Definition at line 143 of file makeAssociatedDataFrom.h.

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

template<typename MainColl , typename Assns >

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

Definition at line 149 of file makeAssociatedDataFrom.h.

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

template<typename Tag , typename Assns >

auto proxy::makeOneTo01dataFrom	(	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 = makeOneTo01dataFrom(assns);

will have assData tagged as recob::Vertex.

Definition at line 66 of file makeOneTo01dataFrom.h.

Referenced by proxy::makeOneTo01dataFrom().

   {
     return proxy::makeOneTo01data<Tag>(assns, minSize);
   }

template<typename Assns >

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

Definition at line 72 of file makeOneTo01dataFrom.h.

References proxy::makeOneTo01data(), and proxy::makeOneTo01dataFrom().

   {
     return proxy::makeOneTo01data(assns, minSize);
   }

template<typename Main , typename Aux , typename Metadata , typename Tag , typename Event >

auto proxy::makeOneTo01dataFrom	(	Event const &	event,
		art::InputTag const &	tag,
		std::size_t	minSize = `0`
	)

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

Template Parameters

Main	type of main object to be associated
Aux	type of data to be associated to the main objects
Metadata	type of metadata in the association
Tag	the tag labelling this associated data (if omitted: `Aux`)
Event	type of event to read associations from

Parameters

event	event to read associations from
tag	input tag of the association object
minSize	minimum number of entries in the produced association data

Returns: a new OneTo01Data filled with associations from tag

See also: makeOneTo01dataFrom(Assns, std::size_t)

The association being retrieved must fulfill the requirements of one-to-(zero or one) sequential association.

Two template types must be explicitly specified, e.g.

auto assData = makeOneTo01dataFrom<recob::Track, recob::Vertex>(event, tag);

Definition at line 181 of file makeOneTo01dataFrom.h.

   {
     using Main_t = Main;
     using Aux_t = Aux;
     using Metadata_t = Metadata;
     using AssociatedData_t = details::OneTo01Data<Main_t, Aux_t, Metadata_t, Tag>;
     using Assns_t = typename AssociatedData_t::assns_t;
 
     return makeOneTo01dataFrom<Tag>(*(event.template getValidHandle<Assns_t>(tag)), minSize);
 
   } // makeOneTo01dataFrom(tag)

template<typename Main , typename Aux , typename Metadata , typename Event >

auto proxy::makeOneTo01dataFrom	(	Event const &	event,
		art::InputTag const &	tag,
		std::size_t	minSize = `0`
	)

Definition at line 102 of file makeOneTo01dataFrom.h.

References proxy::makeOneTo01dataFrom().

   {
     return makeOneTo01dataFrom<Main, Aux, Metadata, Aux, Event>(event, tag, minSize);
   }

template<typename Aux , typename Metadata , typename Tag , typename Handle , typename Event >

auto proxy::makeOneTo01dataFrom	(	Handle &&	handle,
		Event const &	event,
		art::InputTag const &	tag
	)

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

Template Parameters

Aux	type of data to be associated to the main objects
Tag	the tag labelling this associated data (if omitted: `Aux`)
Handle	type of handle to the main collection object
Event	type of event to read associations from

Parameters

handle	handle to the main collection object
event	event to read associations from
tag	input tag of the association object

Returns: a new OneTo01Data wrapping the information in assns

See also: makeAssociatedDataFrom(Event const&, art::InputTag, std::size_t)

This function operates like makeOneTo01dataFrom(Event const&, art::InputTag, std::size_t), but it extracts the information about the type of main object and the minimum number of them from a handle. The handle object is expected to behave as a smart pointer to a collection of elements of the associated type.

One template type must be explicitly specified, e.g.

auto assData = makeOneTo01dataFrom<recob::Vertex>(handle, event, tag);

Definition at line 198 of file makeOneTo01dataFrom.h.

   {
     // Handle::value_type is the main data product type (a collection)
     using Main_t = util::collection_value_t<typename Handle::value_type>;
     using Aux_t = Aux;
     using Metadata_t = Metadata;
     return makeOneTo01dataFrom<Main_t, Aux_t, Metadata_t, Tag>(event, tag, handle->size());
   } // makeOneTo01dataFrom(handle)

template<typename Aux , typename Metadata , typename Handle , typename Event >

auto proxy::makeOneTo01dataFrom	(	Handle &&	handle,
		Event const &	event,
		art::InputTag const &	tag
	)

Definition at line 135 of file makeOneTo01dataFrom.h.

   {
     return makeOneTo01dataFrom<Aux, Metadata, Aux, Handle, Event>(
       std::forward<Handle>(handle), event, tag);
   }

template<typename Tag , typename MainColl , typename Assns >

auto proxy::makeOneTo01dataFrom	(	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: `Aux`)
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: makeOneTo01dataFrom(Assns const&, std::size_t)

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

Definition at line 156 of file makeOneTo01dataFrom.h.

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

template<typename MainColl , typename Assns >

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

Definition at line 162 of file makeOneTo01dataFrom.h.

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

Namespaces

Classes

Functions

Detailed Description

Function Documentation