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

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

inlinestaticprotected

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

template<typename derived_t, typename ... T_Container>

template<typename container_t, std::size_t N = std::variant_size_v< measurement_container_variant_t >>

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

inlinestaticconstexprprotected

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

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.

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

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.

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

template<typename derived_t, typename ... T_Container>

template<std::size_t N = std::variant_size_v< measurement_container_variant_t >>

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

inlinestatic

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

template<typename derived_t, typename ... T_Container>

template<typename container_t, std::size_t = std::variant_size_v< measurement_container_variant_t >>

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

inlinestaticprotected

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

template<typename derived_t, typename ... T_Container>

template<typename container_t, bool check_dimension, std::size_t N>

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.

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

template<typename derived_t, typename ... T_Container>

template<typename container_t, std::size_t N>

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

inlinestaticprotected

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);
      }
   }

isSameContainer()

template<typename derived_t, typename ... T_Container>

template<typename container_t, std::size_t N>

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

inlinestaticconstexprprotected

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

template<typename derived_t, typename ... T_Container>

template<typename T>

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

inlinestaticconstexprprotected

Definition at line 50 of file MeasurementContainerWithDimension.h.

{ return a;}

throwContainerNotInVariant()

template<typename derived_t, typename ... T_Container>

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

inlinestaticprotected

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

---

The documentation for this class was generated from the following file:

• MeasurementContainerWithDimension.h