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_t &	at (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_t >	m_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.

                                                                              {
      return m_containerList.at(container_index);
   }

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.

{ return m_containerList;}

countDerivedVariants()

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

inlinestaticprotectedinherited

Definition at line 78 of file MeasurementContainerWithDimension.h.

                                                                   {
      if constexpr(N==0) {
         return 0;
      }
      else {
         if constexpr(isSameContainer<container_t, N-1>()) {
            return countDerivedVariants<container_t, N-1>(a)+1;
         }
         else {
            using this_variant_type  = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
            using this_container_type = typename this_variant_type::container_type;
            if constexpr(std::is_base_of_v<container_t, this_container_type>
                         && std::has_virtual_destructor_v<this_container_type> && std::has_virtual_destructor_v<container_t>) {
               return countDerivedVariants<container_t, N-1>(a)+ ( dynamic_cast<const this_container_type *>(&a) != nullptr );
            }
            else {
               return countDerivedVariants<container_t, N-1>(a);
            }
         }
      }
   }

countVariants()

constexpr unsigned int MeasurementContainerWithDimension< derived_t, T_Container >::countVariants ( )

inlinestaticconstexprprotectedinherited

Definition at line 69 of file MeasurementContainerWithDimension.h.

                                                  {
      if constexpr(N==0) {
         return 0;
      }
      else {
         return countVariants<container_t, N-1>()+ isSameContainer<container_t, N-1>();
      }
   }

derived()

const derived_t & MeasurementContainerWithDimension< derived_t, T_Container >::derived ( ) const

inlineprotectedinherited

Definition at line 47 of file MeasurementContainerWithDimension.h.

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

dimMax()

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.

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

dumpVariantTypes() [1/2]

template<typename derived_t, typename... T_Container>

void MeasurementContainerListWithDimension< derived_t, T_Container >::dumpVariantTypes ( )

inlinestatic

Definition at line 272 of file MeasurementContainerWithDimension.h.

                                  {
      Base::dumpVariantTypes();
   }

dumpVariantTypes() [2/2]

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

inlinestaticinherited

Definition at line 101 of file MeasurementContainerWithDimension.h.

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

getContainerWithDimension()

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

inlinestaticprotectedinherited

Definition at line 239 of file MeasurementContainerWithDimension.h.

                                                                                          {
      constexpr unsigned int variant_multiplicity = countVariants<container_t>();
      // the container must by among the options of the  measurement_container_variant_t
      static constexpr std::size_t NVariants = std::variant_size_v< measurement_container_variant_t >;
      if constexpr( variant_multiplicity == 1) {
         return getContainerWithDimensionNoAmbiguities<container_t, false, NVariants>(a);
      }
      else {
         if (variant_multiplicity==0) {
            if (countDerivedVariants<container_t>(a) == 1) {
               return getContainerWithDimensionNoAmbiguities<container_t, false, NVariants>(a);
            }
         }
         DEBUG_TRACE( std::cout << "DEBUG need to search with dimension check for " << typeid(container_t).name() << " (aka " <<  typeid(a).name() << ")"
                      << " multiplicity : " << variant_multiplicity << " derived " << countDerivedVariants<container_t>(a)
                      << std:: endl );
         return getContainerWithDimensionNoAmbiguities<container_t, true, NVariants>(a, getDimensionOfDerivedVariantOption<container_t,NVariants>(a));
      }
   }

getContainerWithDimensionNoAmbiguities()

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.

                                                                                                                                 {
      if constexpr(N==0) {
         // this measns that the container_t has not been found in the list of possible options of the variant
         // reasons: the type is not in the list, a derived type was provided and compaibility was not understood
         throwContainerNotInVariant(typeid(a).name());
         using this_variant_type  = decltype( lvalue(std::get<0>(measurement_container_variant_t{}) ) );
         return this_variant_type();
      }
      else {
         using this_variant_type  = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
         using this_container_type = typename this_variant_type::container_type ;
         DEBUG_TRACE( std::cout << "DEBUG search option for " << typeid(container_t).name() << " (aka " <<  typeid(a).name() << ")"
                                << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
                                << " check dimension ? " << check_dimension << " desired dimension " << dimension
                                << std:: endl );
         if constexpr(std::is_same_v<this_container_type, container_t>) {
            // this option of the variant has perfect type match.
            if constexpr(!check_dimension && countVariants<container_t>()==1) {
               // if dimensions are not to be checked there must not be other options which also match the type
               // the caller should have ensureed that this branch is impossible,
               // but this can only be excluded at runtime, so a static_assert
               // is impossible here
               assert( (countVariants<this_container_type,N-1>()) == 0 );
               DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(container_t).name() << " (aka " <<  typeid(a).name() << ")"
                                      << " foumd unambiguous option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
                                      << std:: endl );
               return ContainerRefWithDim<container_t, this_variant_type::dimension()>(a);
            }
            else {
               // otherwise check if the dimension of this option is identical to the
               // expected dimension
               if (this_variant_type::dimension() == dimension) {
                  DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(container_t).name() << " (aka " <<  typeid(a).name() << ")"
                                         << " foumd dimension option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
                                         << std:: endl );
                  return ContainerRefWithDim<container_t, this_variant_type::dimension()>(a);
               }
            }
         }
         else if constexpr(std::is_base_of_v<container_t, this_container_type>) {
            // it is also possible that the container is a base of an option of the variant.
            if constexpr(std::has_virtual_destructor_v<this_container_type> && std::has_virtual_destructor_v<container_t>) {
               // casting can only be done safely if dynamic casts are possible, which requires
               // a virtuaal destructor
               const this_container_type *derived_container = dynamic_cast<const this_container_type *>(&a);
               if (derived_container) {
                  // if the provided container can be casted to the type of this variant option
                  // then check the dimensions
                  if constexpr(!check_dimension) {
                     // Branch may be incorrectly chose and/or assert may fail
                     // if A is base of B and B is Base of C and both B and C are options of the variant
                     // the auto-detection will treat B
                     if constexpr(countVariants<container_t,N-1>() != 0) {
                        return getContainerWithDimensionNoAmbiguities<container_t, check_dimension, N-1>(a, dimension);
                     }
                     else {
                     DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(this_container_type).name() << " (aka " <<  typeid(a).name() << ")"
                                            << " foumd derived option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
                                            << std:: endl );
                     return ContainerRefWithDim<this_container_type, this_variant_type::dimension()>(*derived_container);
                     }
                  }
                  else {
                     if (this_variant_type::dimension() == dimension) {
                        DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(this_container_type).name() << " (aka " <<  typeid(a).name() << ")"
                                               << " derived with dimension option: " << N << " " << typeid(this_container_type).name()
                                               << " dim " << this_variant_type::dimension()
                                               << std:: endl );
                        return ContainerRefWithDim<this_container_type, this_variant_type::dimension()>(*derived_container);
                     }
                  }
               }
            }
         }
         return getContainerWithDimensionNoAmbiguities<container_t, check_dimension, N-1>(a, dimension);
      }
   }

getDimensionOfDerivedVariantOption()

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

inlinestaticprotectedinherited

Definition at line 196 of file MeasurementContainerWithDimension.h.

                                                                                {
      if constexpr(N==0) {
         // failure
         return 0;
      }
      else {
         using this_variant_type  = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
         using this_container_type = typename this_variant_type::container_type;
 
         DEBUG_TRACE( std::cout << "DEBUG determin dimension for " << typeid(container_t).name() << " (aka " <<  typeid(a).name() << ")"
                                << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
                                << std:: endl );
 
         if constexpr(std::is_same<container_t, this_container_type>::value) {
            DEBUG_TRACE( std::cout << "DEBUG get dimension for " << typeid(container_t).name() << " (aka " <<  typeid(a).name() << ")"
                                   << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
                                   << std:: endl );
            return derived_t::getDimension(a);
         }
         else if constexpr(std::is_base_of_v<container_t, this_container_type>) {
            DEBUG_TRACE( std::cout << "DEBUG try get dimension for derived  " << typeid(container_t).name() << " (aka " <<  typeid(a).name() << ")"
                                   << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
                                   << std:: endl );
            // it is also possible that the container is a base of an option of the variant.
            if constexpr(std::has_virtual_destructor_v<this_container_type> && std::has_virtual_destructor_v<container_t>) {
               // if there is no ambiguity there is no point in determining the dimension
               // @TODO but this does not guarantee that this option matches if the provided container
               //       can have multiple dimensions.
               if constexpr(countVariants<this_container_type>() > 1) {
                  // casting can only be done safely if dynamic casts are possible, which requires
                  // a virtual destructor
                  const this_container_type *derived_container = dynamic_cast<const this_container_type *>(&a);
                  if (derived_container) {
                     return derived_t::getDimension(*derived_container);
                  }
               }
            }
         }
         return getDimensionOfDerivedVariantOption<container_t, N-1>(a);
      }
   }

getMeasurementDimMax()

template<typename derived_t, typename... T_Container>

constexpr std::size_t MeasurementContainerListWithDimension< derived_t, T_Container >::getMeasurementDimMax ( )

inlinestaticconstexpr

Definition at line 269 of file MeasurementContainerWithDimension.h.

                                                     {
      return Base::dimMax();
   }

isSameContainer()

constexpr bool MeasurementContainerWithDimension< derived_t, T_Container >::isSameContainer ( )

inlinestaticconstexprprotectedinherited

Definition at line 62 of file MeasurementContainerWithDimension.h.

                                           {
      using this_variant_type  = decltype( lvalue(std::get<N>(measurement_container_variant_t{}) ) );
      return std::is_same<container_t, typename this_variant_type::container_type>::value;
   }

lvalue()

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

inlinestaticconstexprprotectedinherited

Definition at line 50 of file MeasurementContainerWithDimension.h.

{ 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.

                                                                              {
      if (container_index>=m_containerList.size()) {
         m_containerList.resize(container_index+1);
      }
      m_containerList[container_index] = this->getContainerWithDimension(container);
      if ( std::holds_alternative<  decltype(this->lvalue(get<0>(measurement_container_variant_t{}))) >( m_containerList[container_index])
           && std::get<0>(m_containerList[container_index]).containerPtr() == nullptr) {
         // @TODO should never happen
         std::runtime_error("Unhandled measurement type");
      }
 
   }

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.

                          {
      return m_containerList.size();
   }

throwContainerNotInVariant()

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

inlinestaticprotectedinherited

Definition at line 109 of file MeasurementContainerWithDimension.h.

                                                         {
      std::stringstream msg;
      msg << "Container "  << a << " not in variant:" << std::endl;
      dumpVariantTypes(msg);
      throw std::runtime_error(msg.str());
   }

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:

• MeasurementContainerWithDimension.h