Container for a list of pointers to providers. More...

#include <ProviderPack.h>

Public Member Functions
	ProviderPack ()=default
	Default constructor: a null provider pointer for each type. More...

	ProviderPack (Providers const *...provider_ptrs)
	Constructor: stores a provider pointer for each type. More...

template<typename... OtherProviders>
	ProviderPack (ProviderPack< OtherProviders...> const &from)
	Constructor: extracts the providers from another parameter pack. More...

template<typename... OtherProviders>
	ProviderPack (OtherProviders const *...providers)
	Constructor: picks the providers from the specified ones. More...

template<typename... PackProviders, typename... OtherProviders>
	ProviderPack (ProviderPack< PackProviders...> const &fromPack, OtherProviders const *...providers)
	Constructor: picks the providers from a pack plus specified ones. More...

template<typename Provider >
Provider const *	get () const
	Returns the provider with the specified type. More...

template<typename Provider >
void	set (Provider const *provider_ptr)
	Sets the provider with the specified type. More...

template<typename... OtherProviders>
bool	operator== (ProviderPack< OtherProviders...> const &other) const
	Returns whether other provider pack has all the same providers as this. More...

template<typename... OtherProviders>
bool	operator!= (ProviderPack< OtherProviders...> const &other) const
	Returns whether other provider pack and this have different providers. More...

Static Public Member Functions
template<typename Provider >
static constexpr bool	has ()
	Returns whether there is a provider with the specified type. More...

template<typename... OtherProviders>
static constexpr bool	containsProviders ()
	Returns whether all our providers are in the OfferedProviders list. More...

Private Types
using	this_type = ProviderPack< Providers...>
	alias of this class More...

using	tuple_type = std::tuple< Providers const *...>
	type used for storage of the pointers More...

Private Attributes
tuple_type	providers
	container of the pointers, type-safe More...

Detailed Description

template<typename... Providers>
class lar::ProviderPack< Providers >

Container for a list of pointers to providers.

Template Parameters

Providers types of the providers in the parameter pack

The pointers are stored as constant. Note that this container can host any type of objects, and it has "provider" in the name because the reason it was written was to provide a fast way to specify a set of LArSoft service providers. The only limitation is that there should be only one object per type. Pointed objects are not owned by this class.

A a;
B1 b; // derived from B
C c;
D d;
ProviderPack<A, B, C> pack(&a, &b, &c);
// obtain a constant pointer to b from pack:
B const* b_ptr = pack.get<B>();
if constexpr (pack.has<D>()) std::cerr << "Unexpected!" << std::endl;

(note that in the latter check constexpr is supported only since C++17).

Definition at line 114 of file ProviderPack.h.

Member Typedef Documentation

template<typename... Providers>

using lar::ProviderPack< Providers >::this_type = ProviderPack<Providers...>

private

alias of this class

Definition at line 118 of file ProviderPack.h.

template<typename... Providers>

using lar::ProviderPack< Providers >::tuple_type = std::tuple<Providers const*...>

private

type used for storage of the pointers

Definition at line 121 of file ProviderPack.h.

Constructor & Destructor Documentation

template<typename... Providers>

lar::ProviderPack< Providers >::ProviderPack ( )

default

Default constructor: a null provider pointer for each type.

template<typename... Providers>

lar::ProviderPack< Providers >::ProviderPack ( Providers const *... provider_ptrs )

inline

Constructor: stores a provider pointer for each type.

Definition at line 129 of file ProviderPack.h.

129 : providers(provider_ptrs...)

130 {}

lar::ProviderPack::providers

tuple_type providers

container of the pointers, type-safe

Definition: ProviderPack.h:251

template<typename... Providers>

template<typename... OtherProviders>

lar::ProviderPack< Providers >::ProviderPack ( ProviderPack< OtherProviders...> const & from )

inline

Constructor: extracts the providers from another parameter pack.

Template Parameters

OtherProviders list of the providers of the source provider pack

Parameters

from	where to copy the information from

This constructor requires all the providers we need to be present in the source provider pack.

Definition at line 141 of file ProviderPack.h.

       {
         details::SetFrom
           <this_type, ProviderPack<OtherProviders...>, Providers...>
           (*this, from);
       }

template<typename... Providers>

template<typename... OtherProviders>

lar::ProviderPack< Providers >::ProviderPack ( OtherProviders const *... providers )

inline

Constructor: picks the providers from the specified ones.

Template Parameters

OtherProviders list of the type of providers offered

Parameters

providers all the providers needed (or more)

This constructor will pick, among the offered providers, the ones that are needed.

Definition at line 157 of file ProviderPack.h.

       {
         details::SetFrom
           <this_type, ProviderPack<OtherProviders...>, Providers...>
           (*this, ProviderPack<OtherProviders...>(providers...));
       }

template<typename... Providers>

template<typename... PackProviders, typename... OtherProviders>

lar::ProviderPack< Providers >::ProviderPack	(	ProviderPack< PackProviders...> const &	fromPack,
		OtherProviders const *...	providers
	)

Constructor: picks the providers from a pack plus specified ones.

Template Parameters

FromPack	parameter pack to start from
OtherProviders	list of the type of providers offered

Parameters

fromPack	providers to be picked
providers	all the remaining providers needed (or more)

See Also: expandProviderPack()

This constructor will pick all the providers from the specified pack, and the ones from the other providers. This constructor can be used to "expand" from another provider:

A a;
B b;
C c;
D d;
ProviderPack<A, D> pack(&a, &d);
ProviderPack<A, B, C, D> largerPack(pack, &c, &b);

Definition at line 687 of file ProviderPack.h.

   {
 
     // verify that the list of providers in argument is the exact one we need
     static_assert(
       details::are_same_types<Providers...>
         ::template as<PackProviders..., OtherProviders...>(),
       "The providers types in the arguments do not match the ones needed."
       );
 
     // copy all the providers from the provider pack
     details::SetFrom
       <this_type, ProviderPack<PackProviders...>, PackProviders...>
       (*this, fromPack);
 
     // put the other providers in a temporary parameter pack, and copy it
     // (this is convenience, a direct implementation would be probably better)
     details::SetFrom
       <this_type, ProviderPack<OtherProviders...>, OtherProviders...>
       (*this, makeProviderPack(providers...));
 
   } // ProviderPack<Providers...>::ProviderPack(ProviderPack, OtherProviders...)

Member Function Documentation

template<typename... Providers>

template<typename... OfferedProviders>

constexpr bool lar::ProviderPack< Providers >::containsProviders ( )

static

Returns whether all our providers are in the OfferedProviders list.

Template Parameters

OfferedProviders list of offered providers

This static function returns true if all the providers in this provider pack are included among the OfferedProviders list. That list can contain additional provider types, which will not affect the result.

Usage example:

using providers_t
  = lar::ProviderPack<geo::GeometryCore, detinfo::LArProperties>;
static_assert(
  providers_t::containsProviders
    <detinfo::LArProperties, detinfo::DetectorProperties>(),
  "Not all the required providers are present."
  );

In this example, the assertion will fail because of the absence of detinfo::DetectorProperties from providers_t.

Definition at line 736 of file ProviderPack.h.

                                                                {
     return details::are_types_contained<Providers...>
       ::template in<OfferedProviders...>();
   } // ProviderPack<>::containsProviders()

template<typename... Providers>

template<typename Provider >

Provider const* lar::ProviderPack< Providers >::get ( ) const

inline

Returns the provider with the specified type.

Definition at line 193 of file ProviderPack.h.

       {
         constexpr auto providerIndex
           = details::findDerivedFrom<Provider, Providers...>();
         return std::get<providerIndex>(providers);
       } // get<>()

template<typename... Providers>

template<typename Provider >

static constexpr bool lar::ProviderPack< Providers >::has ( )

inlinestatic

Returns whether there is a provider with the specified type.

Definition at line 212 of file ProviderPack.h.

213 { return details::hasDerivedFrom<Provider, Providers...>(); }

lar::details::hasDerivedFrom

constexpr std::size_t hasDerivedFrom()

Definition: ProviderPack.h:77

template<typename... Providers>

template<typename... OtherProviders>

bool lar::ProviderPack< Providers >::operator!= ( ProviderPack< OtherProviders...> const & other ) const

Returns whether other provider pack and this have different providers.

Definition at line 729 of file ProviderPack.h.

730 { return !(*this == other); }

template<typename... Providers>

template<typename... OtherProviders>

bool lar::ProviderPack< Providers >::operator== ( ProviderPack< OtherProviders...> const & other ) const

Returns whether other provider pack has all the same providers as this.

Definition at line 718 of file ProviderPack.h.

   {
     return details::ProviderPackComparer<
       ProviderPack<Providers...>, ProviderPack<OtherProviders...>, Providers...
       >::compare(*this, other);
   }

template<typename... Providers>

template<typename Provider >

void lar::ProviderPack< Providers >::set ( Provider const * provider_ptr )

inline

Sets the provider with the specified type.

Definition at line 203 of file ProviderPack.h.

       {
         constexpr auto providerIndex
           = details::findDerivedFrom<Provider, Providers...>();
         std::get<providerIndex>(providers) = provider_ptr;
       } // set<>()