variant_helper.hpp

#pragma once

 
#include <cassert>
#include <typeinfo>
#include <type_traits>
 
#include "../../namespace.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Shims
  {
    namespace Detail
    {

      template <bool V>
      using BoolT = std::integral_constant<bool, V>;

      template <size_t V>
      using SizeT = std::integral_constant<size_t, V>;
 
#pragma region Max
 
      namespace  // NOLINT(cert-dcl59-cpp)
      {

        template <size_t... VALUES>
        struct MaxImpl
        {
          static_assert(sizeof...(VALUES) == 0, "CVB: no empty alternative lists");
        };
 
        template <size_t VALUE>
        struct MaxImpl<VALUE> : SizeT<VALUE>
        {
        };
 
        template <size_t VALUE0, size_t VALUE1, size_t... REST>
        struct MaxImpl<VALUE0, VALUE1, REST...>
        {
          static const constexpr size_t value =
              VALUE1 < VALUE0 ? MaxImpl<VALUE0, REST...>::value : MaxImpl<VALUE1, REST...>::value;
        };
 
      }  // namespace

      template <size_t... VALUES>
      static const constexpr size_t Max = MaxImpl<VALUES...>::value;
 
#pragma endregion
 
#pragma region NoneIs
 
      namespace  // NOLINT(cert-dcl59-cpp)
      {

        template <bool... VALUES>
        struct NoneIsImpl;
 
        template <>
        struct NoneIsImpl<> : BoolT<true>
        {
        };
 
        template <bool VALUE>
        struct NoneIsImpl<VALUE> : BoolT<!VALUE>
        {
        };
 
        template <bool VALUE, bool... REST>
        struct NoneIsImpl<VALUE, REST...> : BoolT<!VALUE && NoneIsImpl<REST...>::value>
        {
        };
 
      }  // namespace
 
      template <bool... VALUES>
      static const constexpr bool NoneIs = NoneIsImpl<VALUES...>::value;
 
#pragma endregion
 
#pragma region IndexOf
 
      namespace  // NOLINT(cert-dcl59-cpp)
      {
        template <size_t V>
        struct CappedIncrement : SizeT<V + 1>
        {
        };
 
        template <>
        struct CappedIncrement<size_t(-1)> : SizeT<size_t(-1)>
        {
        };

        template <class T, class... REST>
        struct IndexOfImpl;
 
        template <class T>
        struct IndexOfImpl<T> : SizeT<size_t(-1)>
        {
        };
 
        template <class T, class... REST>
        struct IndexOfImpl<T, T, REST...> : SizeT<0>
        {
        };
 
        template <class T, class U, class... REST>
        struct IndexOfImpl<T, U, REST...> : SizeT<CappedIncrement<IndexOfImpl<T, REST...>::value>::value>
        {
        };
 
      }  // namespace

      template <class T, class... TS>
      static const constexpr size_t IndexOf =
          IndexOfImpl<typename std::remove_cv<typename std::remove_reference<T>::type>::type, TS...>::value;

      template <class T, class... TS>
      static const constexpr bool Contains = BoolT<IndexOf<T, TS...> != size_t(-1)>::value;
 
#pragma endregion
 
#pragma region IndexOfAssignable
 
      namespace  // NOLINT(cert-dcl59-cpp)
      {

        template <class T, class... REST>
        struct IndexOfAssignableImpl;
 
        template <class T>
        struct IndexOfAssignableImpl<T> : SizeT<size_t(-1)>
        {
        };
 
        template <class T, class U, class... REST>
        struct IndexOfAssignableImpl<T, U, REST...>
        {
          static const constexpr size_t value =
              std::is_assignable<U, T>::value ? 0 : CappedIncrement<IndexOfAssignableImpl<T, REST...>::value>::value;
        };
 
      }  // namespace

      template <class T, class... TS>
      static const constexpr size_t IndexOfAssignable = IndexOfAssignableImpl<T, TS...>::value;
 
#pragma endregion
 
#pragma region TypeAt
 
      namespace  // NOLINT(cert-dcl59-cpp)
      {

        template <size_t I, class... TS>
        struct TypeAtImpl;
 
        template <class T, class... TS>
        struct TypeAtImpl<0, T, TS...>
        {
          using type = T;
        };
 
        template <size_t I, class T, class... TS>
        struct TypeAtImpl<I, T, TS...>
        {
          using type = typename TypeAtImpl<I - 1, TS...>::type;
        };
 
      }  // namespace

      template <size_t I, class... TS>
      using TypeAt = typename TypeAtImpl<I, TS...>::type;
 
#pragma endregion
 
#pragma region VariantDestructor

      struct VariantDestructor
      {
#pragma warning(push)
#pragma warning(disable : 4100)  // unreference paramete warning if type does not implement dtor
        template <class T>
        void operator()(T &value) const noexcept
        {
          value.~T();
        }
#pragma warning(pop)
      };
 
#pragma endregion
 
#pragma region VariantCopier

      class VariantCopier
      {
        void *data_;
 
      public:
        explicit VariantCopier(void *data) noexcept
            : data_(data)
        {
          assert(data);  // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
        }

        template <class T>
        void operator()(const T &value) const
        {
          new (data_) T(value);
        }
      };
 
#pragma endregion
 
#pragma region VariantMover

      class VariantMover
      {
        void *data_;
 
      public:
        explicit VariantMover(void *data) noexcept
            : data_(data)
        {
          assert(data);  // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
        }

        template <class T>
        void operator()(T &&value) const
        {
          new (data_) T(std::forward<T>(value));
        }
      };
 
#pragma endregion
 
#pragma region VariantEqual

      class VariantEqual
      {
        const void *data_;
 
      public:
        explicit VariantEqual(const void *data) noexcept
            : data_(data)
        {
          assert(data);  // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
        }

        template <class T>
        bool operator()(const T &value) const noexcept
        {
          return *reinterpret_cast<const T *>(data_) == value;
        }
      };
 
#pragma endregion
 
#pragma region VariantLess

      class VariantLess
      {
        const void *lhs_;
 
      public:
        explicit VariantLess(const void *data) noexcept
            : lhs_(data)
        {
          assert(data);  // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
        }

        template <class T>
        bool operator()(const T &rhs) const noexcept
        {
          return *reinterpret_cast<const T *>(lhs_) < rhs;
        }
      };
 
#pragma endregion
 
    }  // namespace Detail
  }  // namespace Shims
  namespace Shims {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb