Classes
class	assns_node_iterator

struct	AssnsIterTraits
	Traits for a association iterator. More...

class	AssnsNode
	This type extends the interface of the art pointer to Assns right side. More...

class	AssociatedData
	Object to draft associated data interface. More...

struct	AssociatedDataProxyMakerWrapper

class	BoundaryList
	Builds and keeps track of internal boundaries in a sequence. More...

class	BoundaryListRange
	A `BoundaryListRangeBase` with a full container interface. More...

class	BoundaryListRangeBase

class	BoundaryListRangeIterator
	Iterator exposing elements of a boundary list as ranges. More...

struct	CollectionProxyImplFromTraitsImpl

struct	CollectionProxyImplFromTraitsImpl< Traits, std::enable_if_t< util::always_true_v < typename Traits::template collection_proxy_impl_t< Args... > > >, Args... >

class	IndexBasedIterator
	Iterator to random access collection storing a current index. More...

struct	isTrackProxy

struct	isTrackProxy< Track< TrackCollProxy > >

class	IteratorWrapperBase
	Simple iterator wrapper for manipulation of dereferenced result. More...

struct	MainCollectionProxy
	Wrapper for the main collection of a proxy. More...

class	OneTo01Data
	Object for one-to-zero/or/one associated data interface. More...

struct	OneTo01DataProxyMakerWrapper

class	ParallelData
	Object to draft parallel data interface. More...

struct	ParallelDataProxyMakerWrapper

struct	ParallelDataProxyMakerWrapper< Aux, AuxTag, void >

struct	ProxyAsParallelData
	Object presenting a proxy as parallel data for another one. More...

struct	StaticAsserts

struct	StaticAsserts< TrackPointWrapper< Data > >

struct	SubstituteWithAuxList

struct	SubstituteWithAuxList< std::tuple< T... > >

struct	TemplateAdaptorOnePlus

struct	TemplateAdaptorOnePlus< F, First, Others... >

struct	TrackPointIteratorBox
	Structure for range-for iteration. More...

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

class	WithProxyAsAuxStructBase
	Helper to create a proxy as auxiliary data for another proxy. More...

Typedefs
template<typename Traits , typename... Args>
using	CollectionProxyImplFromTraits_t = typename CollectionProxyImplFromTraitsImpl< Traits, void, Args... >::type

template<typename Aux , typename Metadata , typename ArgTuple , typename AuxTag = Aux>
using	WithAssociatedStruct = WithAssociatedStructBase< Aux, Metadata, ArgTuple, AssociatedDataProxyMakerWrapper< Aux, Metadata, AuxTag >::template maker_t, AuxTag >

template<typename Aux , typename ArgTuple , typename AuxTag = Aux>
using	WithParallelCollectionStruct = WithAssociatedStructBase< Aux, void, ArgTuple, ParallelDataProxyMakerWrapper< Aux, AuxTag >::template maker_t, AuxTag >

template<typename Aux , typename ArgTuple , typename AuxColl , typename AuxTag = Aux>
using	WithWrappedParallelCollectionStruct = WithAssociatedStructBase< Aux, void, ArgTuple, ParallelDataProxyMakerWrapper< Aux, AuxTag, AuxColl >::template maker_t, AuxTag >

template<typename Aux , typename Metadata , typename ArgTuple , typename AuxTag = Aux>
using	WithOneTo01AssociatedStruct = WithAssociatedStructBase< Aux, Metadata, ArgTuple, OneTo01DataProxyMakerWrapper< Aux, Metadata, AuxTag >::template maker_t, AuxTag >

Functions
template<typename ArtAssnsIterValue >
bool	operator== (AssnsNode< ArtAssnsIterValue > const &A, typename AssnsNode< ArtAssnsIterValue >::valueptr_t const &B)

template<typename ArtAssnsIterValue >
bool	operator== (typename AssnsNode< ArtAssnsIterValue >::valueptr_t const &A, AssnsNode< ArtAssnsIterValue > const &B)

template<typename ArtAssnsIterValue >
bool	operator!= (AssnsNode< ArtAssnsIterValue > const &A, typename AssnsNode< ArtAssnsIterValue >::valueptr_t const &B)

template<typename ArtAssnsIterValue >
bool	operator!= (typename AssnsNode< ArtAssnsIterValue >::valueptr_t const &A, AssnsNode< ArtAssnsIterValue > const &B)

template<typename ArtAssnsIterValue >
AssnsNode< ArtAssnsIterValue > const &	makeAssnsNode (ArtAssnsIterValue const &from)
	Reinterprets the specified association node as a `AssnsNode`. More...

template<typename BoundaryIter >
BoundaryListRange< BoundaryIter >	makeBoundaryListRange (BoundaryIter const &iBegin)
	Reinterprets a iterator to boundaries list as a range collection. More...

template<std::size_t GroupKey, typename Iter >
BoundaryList< Iter >::boundaries_t	associationRangesImpl (Iter begin, Iter end, std::size_t expectedSize)

template<std::size_t GroupKey, typename Iter >
auto	associationRangeBoundaries (Iter begin, Iter end)

template<std::size_t GroupKey, typename Iter >
auto	associationRangeBoundaries (Iter begin, Iter end, std::size_t n)

template<std::size_t GroupKey, typename Iter >
BoundaryList< Iter >	associationRanges (Iter begin, Iter end)
	Groups associations by the first key. More...

template<std::size_t GroupKey, typename Iter >
BoundaryList< Iter >	associationRanges (Iter begin, Iter end, std::size_t n)
	Groups associations by the first key. More...

template<template< typename... > class CollProxy, typename MainColl , typename... AuxColl>
auto	createCollectionProxy (MainColl const &main, AuxColl &&...aux)
	Creates a collection proxy of a specified type with the given arguments. More...

template<typename MainColl , typename... AuxColl>
auto	makeCollectionProxy (MainColl const &main, AuxColl &&...aux)
	Creates a `CollectionProxy` object with the given arguments. More...

template<typename ProxyElement , typename... AuxData>
auto	makeCollectionProxyElement (std::size_t index, typename ProxyElement::main_element_t const &main, AuxData &&...auxData)
	Creates a collection proxy element object from data structures. More...

template<typename Traits , typename... Args>
auto	createCollectionProxyFromTraits (Args &&...args)

template<typename T >
void	extendAndAssign (std::vector< T > &v, typename std::vector< T >::size_type index, typename std::vector< T >::value_type const &value)

template<typename T >
void	extendAndAssign (std::vector< T > &v, typename std::vector< T >::size_type index, typename std::vector< T >::value_type &&value)

template<std::size_t Key, std::size_t Data, typename Iter >
auto	associationOneToOneFullSequence (Iter begin, Iter end, std::size_t n)

Detailed Description

— END Infrastructure for proxies as auxiliary data ------------------—

Typedef Documentation

template<typename Traits , typename... Args>

using proxy::details::CollectionProxyImplFromTraits_t = typedef typename CollectionProxyImplFromTraitsImpl<Traits, void, Args...>::type

Traits::collection_proxy_impl_t if that (template) type exists, proxy::CollectionProxy otherwise.

Definition at line 258 of file CollectionProxyMaker.h.

template<typename Aux , typename Metadata , typename ArgTuple , typename AuxTag = Aux>

using proxy::details::WithAssociatedStruct = typedef WithAssociatedStructBase< Aux, Metadata, ArgTuple, AssociatedDataProxyMakerWrapper<Aux, Metadata, AuxTag>::template maker_t, AuxTag >

Definition at line 63 of file withAssociated.h.

template<typename Aux , typename Metadata , typename ArgTuple , typename AuxTag = Aux>

using proxy::details::WithOneTo01AssociatedStruct = typedef WithAssociatedStructBase< Aux, Metadata, ArgTuple, OneTo01DataProxyMakerWrapper<Aux, Metadata, AuxTag>::template maker_t, AuxTag >

Definition at line 37 of file withZeroOrOne.h.

template<typename Aux , typename ArgTuple , typename AuxTag = Aux>

using proxy::details::WithParallelCollectionStruct = typedef WithAssociatedStructBase< Aux, void, ArgTuple, ParallelDataProxyMakerWrapper<Aux, AuxTag>::template maker_t, AuxTag >

Definition at line 37 of file withParallelData.h.

template<typename Aux , typename ArgTuple , typename AuxColl , typename AuxTag = Aux>

using proxy::details::WithWrappedParallelCollectionStruct = typedef WithAssociatedStructBase< Aux, void, ArgTuple, ParallelDataProxyMakerWrapper<Aux, AuxTag, AuxColl>::template maker_t, AuxTag >

Definition at line 48 of file withParallelData.h.

Function Documentation

template<std::size_t Key, std::size_t Data, typename Iter >

auto proxy::details::associationOneToOneFullSequence	(	Iter	begin,
		Iter	end,
		std::size_t	n
	)

Definition at line 246 of file OneTo01Data.h.

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

                                                                             {
       //
       // Here we are actually not using the assumption that the keys are in
       // increasing order; which is just as good as long as we use a fast random
       // access container as STL vector.
       // We do assume the key side of the association to be valid, though.
       //
       using value_type = typename Iter::value_type;
       using data_t = std::tuple_element_t<Data, value_type>;
       std::vector<data_t> data(n); // all default-constructed
       for (auto it = begin; it != end; ++it) {
         auto const& keyPtr = std::get<Key>(*it);
         extendAndAssign(data, keyPtr.key(), std::get<Data>(*it));
       }
       return data;
     } // associationOneToOneFullSequence(Iter, Iter, std::size_t)

template<std::size_t GroupKey, typename Iter >

auto proxy::details::associationRangeBoundaries	(	Iter	begin,
		Iter	end
	)

Definition at line 960 of file AssociatedData.h.

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

961 { return associationRangesImpl<GroupKey, Iter>(begin, end); }

evd::details::begin

std::vector< evd::details::RawDigitInfo_t >::const_iterator begin(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:314

evd::details::end

std::vector< evd::details::RawDigitInfo_t >::const_iterator end(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:317

template<std::size_t GroupKey, typename Iter >

auto proxy::details::associationRangeBoundaries	(	Iter	begin,
		Iter	end,
		std::size_t	n
	)

Definition at line 966 of file AssociatedData.h.

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

                                                                        {
       auto boundaries = associationRangesImpl<GroupKey, Iter>(begin, end, n);
       if (boundaries.size() <= n) {
         boundaries.insert
           (boundaries.end(), n + 1 - boundaries.size(), boundaries.back()); 
         assert(boundaries.size() == (n + 1));
       }
       return boundaries;
     } // associationRangeBoundaries(Iter, Iter, std::size_t)

template<std::size_t GroupKey, typename Iter >

BoundaryList<Iter> proxy::details::associationRanges	(	Iter	begin,
		Iter	end
	)

Groups associations by the first key.

Template Parameters

GroupKey	index of the key in the tuple pointed by the iterator
Iter	type of iterators delimiting the data (same type required)

Parameters

begin	iterator to the first association in the list
end	iterator past the last association in the list

Returns: a list of range boundaries marking the different groups.

Exceptions

std::runtime_error if input key is not monotonic

The input iterators are expected to point to a tuple-like structure whose key element can be accessed as std::get<GroupKey>() and is an art pointer of some sort.

The index of the grouping key is expected to be monotonically increasing. Gaps are supported except that at the end: if e.g. an association of 5 keys associates objects to only elements #0, #1 and #3, the resulting list will cover 4 ranges for elements #0 to #3 included, but excluding the end elements, the existence of which can't be inferred from the association list in input. In this example, the range #2 will exist and be empty. To enforce a minimum number of elements, use associationRanges(Iter, Iter, std::size_t).

Definition at line 1001 of file AssociatedData.h.

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

       {
         return BoundaryList<Iter>
           (associationRangeBoundaries<GroupKey>(begin, end));
       }

template<std::size_t GroupKey, typename Iter >

BoundaryList<Iter> proxy::details::associationRanges	(	Iter	begin,
		Iter	end,
		std::size_t	n
	)

Groups associations by the first key.

Template Parameters

GroupKey	index of the key in the tuple pointed by the iterator
Iter	type of iterators delimiting the data (same type required)

Parameters

begin	iterator to the first association in the list
end	iterator past the last association in the list
n	minimum number of ranges to be produced.

Returns: a list of range boundaries marking the different groups.

Exceptions

std::runtime_error if input key is not monotonic

See also: associationRanges(Iter, Iter)

This function operates almost like associationRanges(Iter, Iter). The only difference is that at least n ranges are guaranteed to be produced: if the input defines less than n, the missing ones will be added at the end, empty. This allows to work around the possibility of empty ranges at the end, which the associationRanges(Iter, Iter) algorithm does not support.

Definition at line 1026 of file AssociatedData.h.

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

       {
         return BoundaryList<Iter>
           (associationRangeBoundaries<GroupKey>(begin, end, n));
       }

template<std::size_t GroupKey, typename Iter >

BoundaryList<Iter>::boundaries_t proxy::details::associationRangesImpl	(	Iter	begin,
		Iter	end,
		std::size_t	expectedSize
	)

Definition at line 929 of file AssociatedData.h.

References evd::details::end(), proxy::details::BoundaryList< Iter >::end(), and util::flags::to_string().

Referenced by proxy::makeAssociatedData().

     {
       constexpr auto KeyIndex = GroupKey;
       
       auto extractKey
         = [](auto const& assn){ return std::get<KeyIndex>(assn).key(); };
       
       typename BoundaryList<Iter>::boundaries_t boundaries;
       boundaries.reserve(expectedSize + 1);
       boundaries.push_back(begin);
       std::size_t current = 0;
       for (auto it = begin; it != end; ++it) {
         auto const key = extractKey(*it);
         if (key == current) continue;
         if (key < current) {
           auto index = std::distance(begin, it);
           throw std::runtime_error("associationRanges() got input element #"
             + std::to_string(index - 1) + " with key " + std::to_string(current)
             + " and the next with key " + std::to_string(key) + "!"
             );
         }
         boundaries.insert(boundaries.end(), key - current, it);
         current = key;
       } // for
       boundaries.push_back(end);
       return boundaries;
     } // associationRangesImpl()

template<template< typename... > class CollProxy, typename MainColl , typename... AuxColl>

auto proxy::details::createCollectionProxy	(	MainColl const &	main,
		AuxColl &&...	aux
	)

Creates a collection proxy of a specified type with the given arguments.

Definition at line 320 of file CollectionProxy.h.

References main().

       {
         return CollProxy<MainColl, AuxColl...>
           (main, std::forward<AuxColl>(aux)...);
       }

template<typename Traits , typename... Args>

auto proxy::details::createCollectionProxyFromTraits ( Args &&... args )

Definition at line 263 of file CollectionProxyMaker.h.

References proxy::CollectionProxyMakerBase< CollProxy >::make().

                                                          {
       using collection_proxy_impl_t
         = CollectionProxyImplFromTraits_t<Traits, std::decay_t<Args>...>;
       return collection_proxy_impl_t(std::forward<Args>(args)...);
     } // createCollectionProxyFromTraits()

template<typename T >

void proxy::details::extendAndAssign	(	std::vector< T > &	v,
		typename std::vector< T >::size_type	index,
		typename std::vector< T >::value_type const &	value
	)

Definition at line 214 of file OneTo01Data.h.

References fhicl::detail::atom::value().

Referenced by associationOneToOneFullSequence().

       {
       if (index >= v.size()) {
         v.reserve(index + 1);
         v.resize(index);
         v.push_back(value);
       }
       else v[index] = value;
     } // extendAndAssign()

template<typename T >

void proxy::details::extendAndAssign	(	std::vector< T > &	v,
		typename std::vector< T >::size_type	index,
		typename std::vector< T >::value_type &&	value
	)

Definition at line 230 of file OneTo01Data.h.

References fhicl::detail::atom::value().

       {
       if (index >= v.size()) {
         v.reserve(index + 1);
         v.resize(index);
         v.push_back(std::move(value));
       }
       else v[index] = std::move(value);
     } // extendAndAssign()

template<typename ArtAssnsIterValue >

AssnsNode<ArtAssnsIterValue> const& proxy::details::makeAssnsNode ( ArtAssnsIterValue const & from )

Reinterprets the specified association node as a AssnsNode.

Definition at line 360 of file AssociatedData.h.

References proxy::details::AssnsNode< ArtAssnsIterValue >::makeFrom().

Referenced by proxy::details::assns_node_iterator< ArtAssnsIter >::transform().

361 { return AssnsNode<ArtAssnsIterValue>::makeFrom(from); }

template<typename BoundaryIter >

BoundaryListRange<BoundaryIter> proxy::details::makeBoundaryListRange ( BoundaryIter const & iBegin )

Reinterprets a iterator to boundaries list as a range collection.

Template Parameters

BoundaryIter type of iterator to boundary collection

Parameters

iBegin iterator to the begin iterator of a range

Returns: a collection view (lar::CollectionView) of the range

A range is conceptually defined as a sequence of data between a begin and and end iterator. The argument of this function is an iterator to the begin iterator of the range. The begin iterator itself is obtained by dereferencing the argument: *iBegin. The end iterator of the range is required to be immediately after the begin iterator (

*std::next(iBegin)

). This pair of iterators is exposed via the lar::CollectionView view, that presents a vector-like interface. For this to fully work, the data iterators (e.g., *iBegin) must comply with the random-access iterator requirements.

An example of BoundaryIter is the iterator to the list of boundaries in BoundaryList: BoundaryList::boundaries_t::const_iterator.

Definition at line 575 of file AssociatedData.h.

Referenced by proxy::details::BoundaryListRange< BoundaryIter >::BoundaryListRange(), and proxy::details::BoundaryListRangeIterator< BoundaryIter >::transform().

576 { return { iBegin }; }

template<typename MainColl , typename... AuxColl>

auto proxy::details::makeCollectionProxy	(	MainColl const &	main,
		AuxColl &&...	aux
	)

Creates a CollectionProxy object with the given arguments.

Definition at line 329 of file CollectionProxy.h.

References main().

       {
         return createCollectionProxy<CollectionProxy>
           (main, std::forward<AuxColl>(aux)...);
       }

template<typename ProxyElement , typename... AuxData>

auto proxy::details::makeCollectionProxyElement	(	std::size_t	index,
		typename ProxyElement::main_element_t const &	main,
		AuxData &&...	auxData
	)

Creates a collection proxy element object from data structures.

Template Parameters

ProxyElement	type of proxy element to be created
AuxData	types of auxiliary data structures being included

Parameters

index	index in main collection of the element being represented
main	main collection proxy data
auxData	auxiliary data collections

Returns: a ProxyElement object bound to the specified data element

Definition at line 307 of file CollectionProxyElement.h.

       {
       return ProxyElement(
         index, main,
         typename ProxyElement::aux_elements_t(std::forward<AuxData>(auxData)...)
         );
     } // makeCollectionProxyElement()