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

#include <MeasurementContainerWithDimension.h>

Inheritance diagram for MeasurementContainerListWithDimension< derived_t, T_Container >:
Collaboration diagram for MeasurementContainerListWithDimension< derived_t, T_Container >:

Public Types

using Base = MeasurementContainerWithDimension< derived_t, T_Container... >
 
using measurement_container_variant_t = Base::measurement_container_variant_t
 

Public Member Functions

std::size_t size () const
 
const measurement_container_variant_tat (std::size_t container_index) const
 
const std::vector< measurement_container_variant_t > & containerList () const
 
template<typename container_t >
void setContainer (std::size_t container_index, const container_t &container)
 

Static Public Member Functions

static constexpr std::size_t getMeasurementDimMax ()
 
static void dumpVariantTypes ()
 

Protected Member Functions

const derived_t & derived () const
 

Static Protected Member Functions

static constexpr T lvalue (T &&a)
 
static constexpr std::size_t dimMax (std::size_t max_dim=0ul)
 
static constexpr bool isSameContainer ()
 
static constexpr unsigned int countVariants ()
 
static unsigned int countDerivedVariants (const container_t &a)
 
static void dumpVariantTypes (std::ostream &out)
 
static void throwContainerNotInVariant (const char *a)
 
static measurement_container_variant_t getContainerWithDimensionNoAmbiguities (const container_t &a, unsigned int dimension=0)
 
static unsigned int getDimensionOfDerivedVariantOption (const container_t &a)
 
static measurement_container_variant_t getContainerWithDimension (const container_t &a)
 

Private Attributes

std::vector< measurement_container_variant_tm_containerList
 

Detailed Description

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

Definition at line 261 of file MeasurementContainerWithDimension.h.

Member Typedef Documentation

◆ Base

template<typename derived_t , typename... T_Container>
using MeasurementContainerListWithDimension< derived_t, T_Container >::Base = MeasurementContainerWithDimension<derived_t,T_Container...>

Definition at line 263 of file MeasurementContainerWithDimension.h.

◆ measurement_container_variant_t

template<typename derived_t , typename... T_Container>
using MeasurementContainerListWithDimension< derived_t, T_Container >::measurement_container_variant_t = Base::measurement_container_variant_t

Definition at line 264 of file MeasurementContainerWithDimension.h.

Member Function Documentation

◆ at()

template<typename derived_t , typename... T_Container>
const measurement_container_variant_t& MeasurementContainerListWithDimension< derived_t, T_Container >::at ( std::size_t  container_index) const
inline

Definition at line 280 of file MeasurementContainerWithDimension.h.

280  {
281  return m_containerList.at(container_index);
282  }

◆ containerList()

template<typename derived_t , typename... T_Container>
const std::vector< measurement_container_variant_t >& MeasurementContainerListWithDimension< derived_t, T_Container >::containerList ( ) const
inline

Definition at line 283 of file MeasurementContainerWithDimension.h.

283 { return m_containerList;}

◆ countDerivedVariants()

static unsigned int MeasurementContainerWithDimension< derived_t, T_Container >::countDerivedVariants ( const container_t &  a)
inlinestaticprotectedinherited

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()

static constexpr unsigned int MeasurementContainerWithDimension< derived_t, T_Container >::countVariants
inlinestaticconstexprprotectedinherited

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()

const derived_t& MeasurementContainerWithDimension< derived_t, T_Container >::derived
inlineprotectedinherited

Definition at line 47 of file MeasurementContainerWithDimension.h.

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

◆ dimMax()

static constexpr std::size_t MeasurementContainerWithDimension< derived_t, T_Container >::dimMax ( std::size_t  max_dim = 0ul)
inlinestaticconstexprprotectedinherited

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() [1/2]

template<typename derived_t , typename... T_Container>
static void MeasurementContainerListWithDimension< derived_t, T_Container >::dumpVariantTypes ( )
inlinestatic

Definition at line 272 of file MeasurementContainerWithDimension.h.

272  {
274  }

◆ dumpVariantTypes() [2/2]

static void MeasurementContainerWithDimension< derived_t, T_Container >::dumpVariantTypes ( std::ostream &  out)
inlinestaticinherited

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()

static measurement_container_variant_t MeasurementContainerWithDimension< derived_t, T_Container >::getContainerWithDimension ( const container_t &  a)
inlinestaticprotectedinherited

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()

static measurement_container_variant_t MeasurementContainerWithDimension< derived_t, T_Container >::getContainerWithDimensionNoAmbiguities ( const container_t &  a,
unsigned int  dimension = 0 
)
inlinestaticprotectedinherited

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()

static unsigned int MeasurementContainerWithDimension< derived_t, T_Container >::getDimensionOfDerivedVariantOption ( const container_t &  a)
inlinestaticprotectedinherited

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  }

◆ getMeasurementDimMax()

template<typename derived_t , typename... T_Container>
static constexpr std::size_t MeasurementContainerListWithDimension< derived_t, T_Container >::getMeasurementDimMax ( )
inlinestaticconstexpr

Definition at line 269 of file MeasurementContainerWithDimension.h.

269  {
270  return Base::dimMax();
271  }

◆ isSameContainer()

static constexpr bool MeasurementContainerWithDimension< derived_t, T_Container >::isSameContainer
inlinestaticconstexprprotectedinherited

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()

static constexpr T MeasurementContainerWithDimension< derived_t, T_Container >::lvalue ( T &&  a)
inlinestaticconstexprprotectedinherited

Definition at line 50 of file MeasurementContainerWithDimension.h.

50 { return a;}

◆ setContainer()

template<typename derived_t , typename... T_Container>
template<typename container_t >
void MeasurementContainerListWithDimension< derived_t, T_Container >::setContainer ( std::size_t  container_index,
const container_t &  container 
)
inline

Definition at line 286 of file MeasurementContainerWithDimension.h.

286  {
287  if (container_index>=m_containerList.size()) {
288  m_containerList.resize(container_index+1);
289  }
290  m_containerList[container_index] = this->getContainerWithDimension(container);
291  if ( std::holds_alternative< decltype(this->lvalue(get<0>(measurement_container_variant_t{}))) >( m_containerList[container_index])
292  && std::get<0>(m_containerList[container_index]).containerPtr() == nullptr) {
293  // @TODO should never happen
294  std::runtime_error("Unhandled measurement type");
295  }
296 
297  }

◆ size()

template<typename derived_t , typename... T_Container>
std::size_t MeasurementContainerListWithDimension< derived_t, T_Container >::size ( ) const
inline

Definition at line 276 of file MeasurementContainerWithDimension.h.

276  {
277  return m_containerList.size();
278  }

◆ throwContainerNotInVariant()

static void MeasurementContainerWithDimension< derived_t, T_Container >::throwContainerNotInVariant ( const char *  a)
inlinestaticprotectedinherited

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  }

Member Data Documentation

◆ m_containerList

template<typename derived_t , typename... T_Container>
std::vector< measurement_container_variant_t > MeasurementContainerListWithDimension< derived_t, T_Container >::m_containerList
private

Definition at line 266 of file MeasurementContainerWithDimension.h.


The documentation for this class was generated from the following file:
MeasurementContainerListWithDimension::measurement_container_variant_t
Base::measurement_container_variant_t measurement_container_variant_t
Definition: MeasurementContainerWithDimension.h:264
MeasurementContainerListWithDimension::m_containerList
std::vector< measurement_container_variant_t > m_containerList
Definition: MeasurementContainerWithDimension.h:266
MeasurementContainerWithDimension< derived_t, T_Container... >::getDimensionOfDerivedVariantOption
static unsigned int getDimensionOfDerivedVariantOption(const container_t &a)
Definition: MeasurementContainerWithDimension.h:196
MeasurementContainerWithDimension< derived_t, T_Container... >::dumpVariantTypes
static void dumpVariantTypes(std::ostream &out)
Definition: MeasurementContainerWithDimension.h:101
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
MeasurementContainerWithDimension< derived_t, T_Container... >::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< derived_t, T_Container... >::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< derived_t, T_Container... >::countVariants
static constexpr unsigned int countVariants()
Definition: MeasurementContainerWithDimension.h:69
MeasurementContainerWithDimension< derived_t, T_Container... >::lvalue
static constexpr T lvalue(T &&a)
Definition: MeasurementContainerWithDimension.h:50
ContainerRefWithDim
Definition: MeasurementContainerWithDimension.h:13
MeasurementContainerWithDimension< derived_t, T_Container... >::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< derived_t, T_Container... >::throwContainerNotInVariant
static void throwContainerNotInVariant(const char *a)
Definition: MeasurementContainerWithDimension.h:109
MeasurementContainerWithDimension< derived_t, T_Container... >::getContainerWithDimension
static measurement_container_variant_t getContainerWithDimension(const container_t &a)
Definition: MeasurementContainerWithDimension.h:239
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
MeasurementContainerWithDimension< derived_t, T_Container... >::dimMax
static constexpr std::size_t dimMax(std::size_t max_dim=0ul)
Definition: MeasurementContainerWithDimension.h:53