ATLAS Offline Software
Public Types | Static Public Member Functions | Protected Member Functions | Static Protected Member Functions | List of all members
MeasurementContainerWithDimension< derived_t, T_Container > Class Template Reference

#include <MeasurementContainerWithDimension.h>

Collaboration diagram for MeasurementContainerWithDimension< derived_t, T_Container >:

Public Types

using measurement_container_variant_t = std::variant< T_Container... >
 

Static Public Member Functions

template<std::size_t N = std::variant_size_v< measurement_container_variant_t >>
static void dumpVariantTypes (std::ostream &out)
 

Protected Member Functions

const derived_t & derived () const
 

Static Protected Member Functions

template<typename T >
static constexpr T lvalue (T &&a)
 
template<std::size_t N = std::variant_size_v< measurement_container_variant_t >>
static constexpr std::size_t dimMax (std::size_t max_dim=0ul)
 
template<typename container_t , std::size_t N>
static constexpr bool isSameContainer ()
 
template<typename container_t , std::size_t N = std::variant_size_v< measurement_container_variant_t >>
static constexpr unsigned int countVariants ()
 
template<typename container_t , std::size_t N = std::variant_size_v< measurement_container_variant_t >>
static unsigned int countDerivedVariants (const container_t &a)
 
static void throwContainerNotInVariant (const char *a)
 
template<typename container_t , bool check_dimension, std::size_t N>
static measurement_container_variant_t getContainerWithDimensionNoAmbiguities (const container_t &a, unsigned int dimension=0)
 
template<typename container_t , std::size_t N>
static unsigned int getDimensionOfDerivedVariantOption (const container_t &a)
 
template<typename container_t , std::size_t = std::variant_size_v< measurement_container_variant_t >>
static measurement_container_variant_t getContainerWithDimension (const container_t &a)
 

Detailed Description

template<typename derived_t, typename ... T_Container>
class MeasurementContainerWithDimension< derived_t, T_Container >

Definition at line 41 of file MeasurementContainerWithDimension.h.

Member Typedef Documentation

◆ measurement_container_variant_t

template<typename derived_t , typename ... T_Container>
using MeasurementContainerWithDimension< derived_t, T_Container >::measurement_container_variant_t = std::variant< T_Container...>

Definition at line 43 of file MeasurementContainerWithDimension.h.

Member Function Documentation

◆ countDerivedVariants()

template<typename derived_t , typename ... T_Container>
template<typename container_t , std::size_t N = std::variant_size_v< measurement_container_variant_t >>
static unsigned int MeasurementContainerWithDimension< derived_t, T_Container >::countDerivedVariants ( const container_t &  a)
inlinestaticprotected

Definition at line 78 of file MeasurementContainerWithDimension.h.

78  {
79  if constexpr(N==0) {
80  return 0;
81  }
82  else {
83  if constexpr(isSameContainer<container_t, N-1>()) {
84  return countDerivedVariants<container_t, N-1>(a)+1;
85  }
86  else {
87  using this_variant_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
88  using this_container_type = typename this_variant_type::container_type;
89  if constexpr(std::is_base_of_v<container_t, this_container_type>
90  && std::has_virtual_destructor_v<this_container_type> && std::has_virtual_destructor_v<container_t>) {
91  return countDerivedVariants<container_t, N-1>(a)+ ( dynamic_cast<const this_container_type *>(&a) != nullptr );
92  }
93  else {
94  return countDerivedVariants<container_t, N-1>(a);
95  }
96  }
97  }
98  }

◆ countVariants()

template<typename derived_t , typename ... T_Container>
template<typename container_t , std::size_t N = std::variant_size_v< measurement_container_variant_t >>
static constexpr unsigned int MeasurementContainerWithDimension< derived_t, T_Container >::countVariants ( )
inlinestaticconstexprprotected

Definition at line 69 of file MeasurementContainerWithDimension.h.

69  {
70  if constexpr(N==0) {
71  return 0;
72  }
73  else {
74  return countVariants<container_t, N-1>()+ isSameContainer<container_t, N-1>();
75  }
76  }

◆ derived()

template<typename derived_t , typename ... T_Container>
const derived_t& MeasurementContainerWithDimension< derived_t, T_Container >::derived ( ) const
inlineprotected

Definition at line 47 of file MeasurementContainerWithDimension.h.

47 { return *static_cast<const derived_t *>(this); }

◆ dimMax()

template<typename derived_t , typename ... T_Container>
template<std::size_t N = std::variant_size_v< measurement_container_variant_t >>
static constexpr std::size_t MeasurementContainerWithDimension< derived_t, T_Container >::dimMax ( std::size_t  max_dim = 0ul)
inlinestaticconstexprprotected

Definition at line 53 of file MeasurementContainerWithDimension.h.

53  {
54  if constexpr(N>0) {
55  using this_variant_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
56  return dimMax<N-1>(std::max( this_variant_type::dimension(), max_dim ) );
57  }
58  return max_dim;
59  }

◆ dumpVariantTypes()

template<typename derived_t , typename ... T_Container>
template<std::size_t N = std::variant_size_v< measurement_container_variant_t >>
static void MeasurementContainerWithDimension< derived_t, T_Container >::dumpVariantTypes ( std::ostream &  out)
inlinestatic

Definition at line 101 of file MeasurementContainerWithDimension.h.

101  {
102  if constexpr(N>0) {
103  using a_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
104  out << N-1 << ": " << typeid(a_type).name() << std::endl;
105  dumpVariantTypes<N-1>(out);
106  }
107  }

◆ getContainerWithDimension()

template<typename derived_t , typename ... T_Container>
template<typename container_t , std::size_t = std::variant_size_v< measurement_container_variant_t >>
static measurement_container_variant_t MeasurementContainerWithDimension< derived_t, T_Container >::getContainerWithDimension ( const container_t &  a)
inlinestaticprotected

Definition at line 239 of file MeasurementContainerWithDimension.h.

239  {
240  constexpr unsigned int variant_multiplicity = countVariants<container_t>();
241  // the container must by among the options of the measurement_container_variant_t
242  static constexpr std::size_t NVariants = std::variant_size_v< measurement_container_variant_t >;
243  if constexpr( variant_multiplicity == 1) {
244  return getContainerWithDimensionNoAmbiguities<container_t, false, NVariants>(a);
245  }
246  else {
247  if (variant_multiplicity==0) {
248  if (countDerivedVariants<container_t>(a) == 1) {
249  return getContainerWithDimensionNoAmbiguities<container_t, false, NVariants>(a);
250  }
251  }
252  DEBUG_TRACE( std::cout << "DEBUG need to search with dimension check for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
253  << " multiplicity : " << variant_multiplicity << " derived " << countDerivedVariants<container_t>(a)
254  << std:: endl );
255  return getContainerWithDimensionNoAmbiguities<container_t, true, NVariants>(a, getDimensionOfDerivedVariantOption<container_t,NVariants>(a));
256  }
257  }

◆ getContainerWithDimensionNoAmbiguities()

template<typename derived_t , typename ... T_Container>
template<typename container_t , bool check_dimension, std::size_t N>
static measurement_container_variant_t MeasurementContainerWithDimension< derived_t, T_Container >::getContainerWithDimensionNoAmbiguities ( const container_t &  a,
unsigned int  dimension = 0 
)
inlinestaticprotected

Definition at line 117 of file MeasurementContainerWithDimension.h.

117  {
118  if constexpr(N==0) {
119  // this measns that the container_t has not been found in the list of possible options of the variant
120  // reasons: the type is not in the list, a derived type was provided and compaibility was not understood
121  throwContainerNotInVariant(typeid(a).name());
122  using this_variant_type = decltype( lvalue(std::get<0>(measurement_container_variant_t{}) ) );
123  return this_variant_type();
124  }
125  else {
126  using this_variant_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
127  using this_container_type = typename this_variant_type::container_type ;
128  DEBUG_TRACE( std::cout << "DEBUG search option for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
129  << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
130  << " check dimension ? " << check_dimension << " desired dimension " << dimension
131  << std:: endl );
132  if constexpr(std::is_same_v<this_container_type, container_t>) {
133  // this option of the variant has perfect type match.
134  if constexpr(!check_dimension && countVariants<container_t>()==1) {
135  // if dimensions are not to be checked there must not be other options which also match the type
136  // the caller should have ensureed that this branch is impossible,
137  // but this can only be excluded at runtime, so a static_assert
138  // is impossible here
139  assert( (countVariants<this_container_type,N-1>()) == 0 );
140  DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
141  << " foumd unambiguous option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
142  << std:: endl );
144  }
145  else {
146  // otherwise check if the dimension of this option is identical to the
147  // expected dimension
148  if (this_variant_type::dimension() == dimension) {
149  DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
150  << " foumd dimension option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
151  << std:: endl );
153  }
154  }
155  }
156  else if constexpr(std::is_base_of_v<container_t, this_container_type>) {
157  // it is also possible that the container is a base of an option of the variant.
158  if constexpr(std::has_virtual_destructor_v<this_container_type> && std::has_virtual_destructor_v<container_t>) {
159  // casting can only be done safely if dynamic casts are possible, which requires
160  // a virtuaal destructor
161  const this_container_type *derived_container = dynamic_cast<const this_container_type *>(&a);
162  if (derived_container) {
163  // if the provided container can be casted to the type of this variant option
164  // then check the dimensions
165  if constexpr(!check_dimension) {
166  // Branch may be incorrectly chose and/or assert may fail
167  // if A is base of B and B is Base of C and both B and C are options of the variant
168  // the auto-detection will treat B
169  if constexpr(countVariants<container_t,N-1>() != 0) {
170  return getContainerWithDimensionNoAmbiguities<container_t, check_dimension, N-1>(a, dimension);
171  }
172  else {
173  DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(this_container_type).name() << " (aka " << typeid(a).name() << ")"
174  << " foumd derived option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
175  << std:: endl );
177  }
178  }
179  else {
180  if (this_variant_type::dimension() == dimension) {
181  DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(this_container_type).name() << " (aka " << typeid(a).name() << ")"
182  << " derived with dimension option: " << N << " " << typeid(this_container_type).name()
183  << " dim " << this_variant_type::dimension()
184  << std:: endl );
186  }
187  }
188  }
189  }
190  }
191  return getContainerWithDimensionNoAmbiguities<container_t, check_dimension, N-1>(a, dimension);
192  }
193  }

◆ getDimensionOfDerivedVariantOption()

template<typename derived_t , typename ... T_Container>
template<typename container_t , std::size_t N>
static unsigned int MeasurementContainerWithDimension< derived_t, T_Container >::getDimensionOfDerivedVariantOption ( const container_t &  a)
inlinestaticprotected

Definition at line 196 of file MeasurementContainerWithDimension.h.

196  {
197  if constexpr(N==0) {
198  // failure
199  return 0;
200  }
201  else {
202  using this_variant_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
203  using this_container_type = typename this_variant_type::container_type;
204 
205  DEBUG_TRACE( std::cout << "DEBUG determin dimension for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
206  << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
207  << std:: endl );
208 
210  DEBUG_TRACE( std::cout << "DEBUG get dimension for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
211  << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
212  << std:: endl );
213  return derived_t::getDimension(a);
214  }
215  else if constexpr(std::is_base_of_v<container_t, this_container_type>) {
216  DEBUG_TRACE( std::cout << "DEBUG try get dimension for derived " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
217  << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
218  << std:: endl );
219  // it is also possible that the container is a base of an option of the variant.
220  if constexpr(std::has_virtual_destructor_v<this_container_type> && std::has_virtual_destructor_v<container_t>) {
221  // if there is no ambiguity there is no point in determining the dimension
222  // @TODO but this does not guarantee that this option matches if the provided container
223  // can have multiple dimensions.
224  if constexpr(countVariants<this_container_type>() > 1) {
225  // casting can only be done safely if dynamic casts are possible, which requires
226  // a virtual destructor
227  const this_container_type *derived_container = dynamic_cast<const this_container_type *>(&a);
228  if (derived_container) {
229  return derived_t::getDimension(*derived_container);
230  }
231  }
232  }
233  }
234  return getDimensionOfDerivedVariantOption<container_t, N-1>(a);
235  }
236  }

◆ isSameContainer()

template<typename derived_t , typename ... T_Container>
template<typename container_t , std::size_t N>
static constexpr bool MeasurementContainerWithDimension< derived_t, T_Container >::isSameContainer ( )
inlinestaticconstexprprotected

Definition at line 62 of file MeasurementContainerWithDimension.h.

62  {
63  using this_variant_type = decltype( lvalue(std::get<N>(measurement_container_variant_t{}) ) );
65  }

◆ lvalue()

template<typename derived_t , typename ... T_Container>
template<typename T >
static constexpr T MeasurementContainerWithDimension< derived_t, T_Container >::lvalue ( T &&  a)
inlinestaticconstexprprotected

Definition at line 50 of file MeasurementContainerWithDimension.h.

50 { return a;}

◆ throwContainerNotInVariant()

template<typename derived_t , typename ... T_Container>
static void MeasurementContainerWithDimension< derived_t, T_Container >::throwContainerNotInVariant ( const char *  a)
inlinestaticprotected

Definition at line 109 of file MeasurementContainerWithDimension.h.

109  {
110  std::stringstream msg;
111  msg << "Container " << a << " not in variant:" << std::endl;
113  throw std::runtime_error(msg.str());
114  }

The documentation for this class was generated from the following file:
MeasurementContainerWithDimension::getDimensionOfDerivedVariantOption
static unsigned int getDimensionOfDerivedVariantOption(const container_t &a)
Definition: MeasurementContainerWithDimension.h:196
MeasurementContainerWithDimension::dumpVariantTypes
static void dumpVariantTypes(std::ostream &out)
Definition: MeasurementContainerWithDimension.h:101
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
MeasurementContainerWithDimension::measurement_container_variant_t
std::variant< T_Container... > measurement_container_variant_t
Definition: MeasurementContainerWithDimension.h:43
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
athena.value
value
Definition: athena.py:124
MeasurementContainerWithDimension::getContainerWithDimensionNoAmbiguities
static measurement_container_variant_t getContainerWithDimensionNoAmbiguities(const container_t &a, unsigned int dimension=0)
Definition: MeasurementContainerWithDimension.h:117
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
MeasurementContainerWithDimension::countVariants
static constexpr unsigned int countVariants()
Definition: MeasurementContainerWithDimension.h:69
MeasurementContainerWithDimension::lvalue
static constexpr T lvalue(T &&a)
Definition: MeasurementContainerWithDimension.h:50
ContainerRefWithDim
Definition: MeasurementContainerWithDimension.h:13
MeasurementContainerWithDimension::countDerivedVariants
static unsigned int countDerivedVariants(const container_t &a)
Definition: MeasurementContainerWithDimension.h:78
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
a
TList * a
Definition: liststreamerinfos.cxx:10
DEBUG_TRACE
#define DEBUG_TRACE(a)
Definition: MeasurementContainerWithDimension.h:32
MeasurementContainerWithDimension::throwContainerNotInVariant
static void throwContainerNotInVariant(const char *a)
Definition: MeasurementContainerWithDimension.h:109
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
MeasurementContainerWithDimension::dimMax
static constexpr std::size_t dimMax(std::size_t max_dim=0ul)
Definition: MeasurementContainerWithDimension.h:53