variant.hpp

#pragma once

 
#include <new>
#include <exception>
#include <utility>
#include "_detail/variant_helper.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Shims
  {

    class bad_variant_access : public std::exception
    {
    public:
      bad_variant_access() = default;
    };
    class bad_variant_access : public std::exception {…};

    static const constexpr size_t variant_npos = size_t(-1);

    template <size_t I, class T>
    struct variant_alternative;

    template <class... TS>
    class variant final
    {
      static_assert(Detail::NoneIs<std::is_void<TS>::value...>, "CVB: void types are not allowed");
      static_assert(Detail::NoneIs<std::is_reference<TS>::value...>, "CVB: reference types are not allowed");
      static_assert(Detail::NoneIs<std::is_const<TS>::value...>, "CVB: const types are not allowed");
      static_assert(Detail::NoneIs<std::is_volatile<TS>::value...>, "CVB: volatile types are not allowed");
 
#pragma region friend access
      template <size_t I, class... ETS>
      friend const typename variant_alternative<I, variant<ETS...>>::type &get(const variant<ETS...> &var);
      template <size_t I, class... ETS>
      friend typename variant_alternative<I, variant<ETS...>>::type &get(variant<ETS...> &var);
      template <size_t I, class... ETS>
      friend typename variant_alternative<I, variant<ETS...>>::type get(variant<ETS...> &&var);
      template <class... ETS>
      friend bool operator==(const variant<ETS...> &lhs, const variant<ETS...> &rhs);
      template <class... ETS>
      friend bool operator<(const variant<ETS...> &lhs, const variant<ETS...> &rhs);
#pragma endregion
 
      static const constexpr size_t StorageSize      = Detail::Max<sizeof(TS)...>;
      static const constexpr size_t StorageAlignment = Detail::Max<alignof(TS)...>;
 
      using Storage = typename std::aligned_storage<StorageSize, StorageAlignment>::type;

      size_t index_;
      Storage data_;
 
      void delete_if_valid() noexcept;
 
      template <class T>
      void set(T &&value)
      {
        const constexpr auto exactIndex = Detail::IndexOf<T, TS...>;  // exact type has precedence
        const constexpr auto newIndex   = exactIndex != variant_npos ? exactIndex : Detail::IndexOfAssignable<T, TS...>;
        static_assert(newIndex != variant_npos, "CVB: assigned type not compatible to alternatives list");
 
        using NewT = Detail::TypeAt<newIndex, TS...>;
 
        delete_if_valid();
        new (&data_) NewT(std::forward<T>(value));
        index_ = newIndex;
      }
 
    public:
      // template <typename std::enable_if<std::is_default_constructible<Detail::TypeAt<0, TS...>>::value, int>::type =
      // 0>
      variant() noexcept
          : index_(0)
      {
        new (&data_) Detail::TypeAt<0, TS...>{};
      }
      variant() noexcept {…}

      ~variant() noexcept
      {
        delete_if_valid();
      }
      ~variant() noexcept {…}

      variant(const variant &rhs);

      variant(variant &&rhs) noexcept;

      variant &operator=(const variant &rhs);

      variant &operator=(variant &&rhs);

      template <class T, typename std::enable_if<!std::is_same<T, variant &>::value, int>::type = 0>
      variant(T &&value)  // NOLINT
          : index_(variant_npos)
      {
        set(std::forward<T>(value));
      }
      variant(T &&value)  // NOLINT {…}

      template <class T, typename std::enable_if<!std::is_same<T, variant &>::value, int>::type = 0>
      variant &operator=(T &&value)
      {
        set(std::forward<T>(value));
 
        return *this;
      }
      variant &operator=(T &&value) {…}

      template <size_t I, class... ARGS>
      typename variant_alternative<I, variant<TS...>>::type &emplace(ARGS &&...args);

      template <class T, class... ARGS>
      T &emplace(ARGS &&...args)
      {
        const constexpr auto newIndex = Detail::IndexOf<T, TS...>;
        static_assert(newIndex != variant_npos, "CVB: assigned type not in alternatives list");
 
        return emplace<newIndex>(std::forward<ARGS>(args)...);
      }
      T &emplace(ARGS &&...args) {…}

      size_t index() const noexcept
      {
        return index_;
      }
      size_t index() const noexcept {…}

      void swap(variant &other);

      bool valueless_by_exception() const noexcept
      {
        return index_ == variant_npos;
      }
      bool valueless_by_exception() const noexcept {…}
    };
    class variant final {…};
 
#pragma region monostate

    struct monostate
    {
    };
    struct monostate {…};

    constexpr bool operator<(monostate, monostate) noexcept
    {
      return false;
    }
    constexpr bool operator<(monostate, monostate) noexcept {…}

    constexpr bool operator>(monostate, monostate) noexcept
    {
      return false;
    }
    constexpr bool operator>(monostate, monostate) noexcept {…}

    constexpr bool operator<=(monostate, monostate) noexcept
    {
      return true;
    }
    constexpr bool operator<=(monostate, monostate) noexcept {…}

    constexpr bool operator>=(monostate, monostate) noexcept
    {
      return true;
    }
    constexpr bool operator>=(monostate, monostate) noexcept {…}

    constexpr bool operator==(monostate, monostate) noexcept
    {
      return true;
    }
    constexpr bool operator==(monostate, monostate) noexcept {…}

    constexpr bool operator!=(monostate, monostate) noexcept
    {
      return false;
    }
    constexpr bool operator!=(monostate, monostate) noexcept {…}
 
#pragma endregion
 
#pragma region variant_alternative
 
    template <size_t I, class... TS>
    struct variant_alternative<I, variant<TS...>>
    {
      using type = Detail::TypeAt<I, TS...>;
    };
 
    template <size_t I, class T>
    struct variant_alternative<I, T &> : variant_alternative<I, T>
    {
    };
 
    template <size_t I, class T>
    struct variant_alternative<I, const T> : variant_alternative<I, typename std::remove_reference<T>::type>
    {
    };
 
    template <size_t I, class T>
    struct variant_alternative<I, volatile T> : variant_alternative<I, typename std::remove_reference<T>::type>
    {
    };
 
    template <size_t I, class T>
    struct variant_alternative<I, const volatile T> : variant_alternative<I, typename std::remove_reference<T>::type>
    {
    };

    template <size_t I, class T>
    using variant_alternative_t = typename variant_alternative<I, T>::type;
 
#pragma endregion
 
#pragma region variant_size

    template <class T>
    struct variant_size;
 
    template <class... TS>
    struct variant_size<variant<TS...>> : Detail::SizeT<sizeof...(TS)>
    {
    };
 
    template <class T>
    struct variant_size<T &> : variant_size<T>
    {
    };
 
    template <class T>
    struct variant_size<const T> : variant_size<typename std::remove_reference<T>::type>
    {
    };
 
    template <class T>
    struct variant_size<volatile T> : variant_size<typename std::remove_reference<T>::type>
    {
    };
 
    template <class T>
    struct variant_size<const volatile T> : variant_size<typename std::remove_reference<T>::type>
    {
    };

    template <class T>
    static const constexpr size_t variant_alternatives_size_v = variant_size<T>::value;
 
#pragma endregion
 
#pragma region get<I>


    template <size_t I, class... TS>
    const variant_alternative_t<I, variant<TS...>> &get(const variant<TS...> &var)
    {
      static_assert(I < sizeof...(TS), "CVB: alternative index out of range");
      if (I != var.index())
        throw bad_variant_access{};
 
      return reinterpret_cast<const variant_alternative_t<I, variant<TS...>> &>(var.data_);
    }
    const variant_alternative_t<I, variant<TS...>> &get(const variant<TS...> &var) {…}

    template <size_t I, class... TS>
    variant_alternative_t<I, variant<TS...>> &get(variant<TS...> &var)
    {
      static_assert(I < sizeof...(TS), "CVB: alternative index out of range");
      if (I != var.index())
        throw bad_variant_access{};
 
      return reinterpret_cast<variant_alternative_t<I, variant<TS...>> &>(var.data_);
    }
    variant_alternative_t<I, variant<TS...>> &get(variant<TS...> &var) {…}

    template <size_t I, class... TS>
    variant_alternative_t<I, variant<TS...>> get(variant<TS...> &&var)
    {
      static_assert(I < sizeof...(TS), "CVB: alternative index out of range");
      if (I != var.index())
        throw bad_variant_access{};
 
      return reinterpret_cast<variant_alternative_t<I, variant<TS...>> &&>(var.data_);
    }
    variant_alternative_t<I, variant<TS...>> get(variant<TS...> &&var) {…}
 
#pragma endregion
 
#pragma region get<T>


    template <class T, class... TS>
    const T &get(const variant<TS...> &var)
    {
      static const constexpr size_t index = Detail::IndexOf<T, TS...>;
      static_assert(index != variant_npos, "CVB: type not in alternatives list");
 
      return get<index>(var);
    }
    const T &get(const variant<TS...> &var) {…}

    template <class T, class... TS>
    T &get(variant<TS...> &var)
    {
      static const constexpr size_t index = Detail::IndexOf<T, TS...>;
      static_assert(index != variant_npos, "CVB: type not in alternatives list");
 
      return get<index>(var);
    }
    T &get(variant<TS...> &var) {…}

    template <class T, class... TS>
    T get(variant<TS...> &&var)
    {
      static const constexpr size_t index = Detail::IndexOf<T, TS...>;
      static_assert(index != variant_npos, "CVB: type not in alternatives list");
 
      return get<index>(std::move(var));
    }
    T get(variant<TS...> &&var) {…}
 
#pragma endregion
 
#pragma region get_if<I>

    template <size_t I, class... TS>
    typename std::add_pointer<const variant_alternative_t<I, variant<TS...>>>::type
    get_if(const variant<TS...> *pvar) noexcept
    {
      if (!pvar || pvar->index() != I)
        return nullptr;
 
      return &get<I>(*pvar);
    }

    template <size_t I, class... TS>
    typename std::add_pointer<variant_alternative_t<I, variant<TS...>>>::type get_if(variant<TS...> *pvar) noexcept
    {
      if (!pvar || pvar->index() != I)
        return nullptr;
 
      return &get<I>(*pvar);
    }
    typename std::add_pointer<variant_alternative_t<I, variant<TS...>>>::type get_if(variant<TS...> *pvar) noexcept {…}
 
#pragma endregion
 
#pragma region get_if<I>


    template <class T, class... TS>
    typename std::add_pointer<const T>::type get_if(const variant<TS...> *pvar) noexcept
    {
      static const constexpr size_t index = Detail::IndexOf<T, TS...>;
      static_assert(index != variant_npos, "CVB: type not in alternatives list");
 
      return get_if<index>(pvar);
    }
    typename std::add_pointer<const T>::type get_if(const variant<TS...> *pvar) noexcept {…}

    template <class T, class... TS>
    typename std::add_pointer<T>::type get_if(variant<TS...> *pvar) noexcept
    {
      static const constexpr size_t index = Detail::IndexOf<T, TS...>;
      static_assert(index != variant_npos, "CVB: type not in alternatives list");
 
      return get_if<index>(pvar);
    }
    typename std::add_pointer<T>::type get_if(variant<TS...> *pvar) noexcept {…}
 
#pragma endregion
 
#pragma region holds_alternative

    template <class T, class... TS>
    bool holds_alternative(const variant<TS...> &var) noexcept
    {
      static_assert(Detail::Contains<T, TS...>, "CVB: alternative is not contained in variant.");
      return var.index() == Detail::IndexOf<T, TS...>;
    }
    bool holds_alternative(const variant<TS...> &var) noexcept {…}
 
#pragma endregion
 
#pragma region visit
 
#pragma region VisitHelper
 
    namespace Detail
    {

      template <class T, size_t COUNT, size_t I = 0>
      struct VisitHelper1
      {
        template <class VISITOR, class VARIANT>
        T operator()(VISITOR &&visitor, VARIANT &&var) const
        {
          if (I == var.index())
            return visitor(get<I>(std::forward<VARIANT>(var)));
          else
            return VisitHelper1<T, COUNT, I + 1>{}(std::forward<VISITOR>(visitor), std::forward<VARIANT>(var));
        }
      };
 
      template <class T, size_t COUNT>
      struct VisitHelper1<T, COUNT, COUNT>
      {
        template <class VISITOR, class VARIANT>
        T operator()(VISITOR &&, VARIANT &&) const
        {
          throw bad_variant_access{};
        }
      };
 
    }  // namespace Detail
 
#pragma endregion

    template <class VISITOR, class VARIANT>
    auto visit(VISITOR &&visitor, VARIANT &&var) -> decltype(visitor(get<0>(var)))
    {
      using RESULT = decltype(visitor(get<0>(var)));
      using HELPER = Detail::VisitHelper1<RESULT, variant_alternatives_size_v<VARIANT>>;
 
      return HELPER{}(std::forward<VISITOR>(visitor), std::forward<VARIANT>(var));
    }
    auto visit(VISITOR &&visitor, VARIANT &&var) -> decltype(visitor(get<0>(var))) {…}
 
#pragma endregion
 
#pragma region comparison operators

    template <class... TS>
    bool operator==(const variant<TS...> &lhs, const variant<TS...> &rhs)
    {
      return lhs.index() == rhs.index()
             && (lhs.valueless_by_exception() || visit(Detail::VariantEqual{&lhs.data_}, rhs));
    }
    bool operator==(const variant<TS...> &lhs, const variant<TS...> &rhs) {…}

    template <class... TS>
    bool operator!=(const variant<TS...> &lhs, const variant<TS...> &rhs)
    {
      return !(lhs == rhs);
    }
    bool operator!=(const variant<TS...> &lhs, const variant<TS...> &rhs) {…}

    template <class... TS>
    bool operator<(const variant<TS...> &lhs, const variant<TS...> &rhs)
    {
      return !rhs.valueless_by_exception()
             && (lhs.valueless_by_exception() || lhs.index() < rhs.index()
                 || (lhs.index() == rhs.index() && visit(Detail::VariantLess{&lhs.data_}, rhs)));
    }
    bool operator<(const variant<TS...> &lhs, const variant<TS...> &rhs) {…}

    template <class... TS>
    bool operator<=(const variant<TS...> &lhs, const variant<TS...> &rhs)
    {
      return !(rhs < lhs);
    }
    bool operator<=(const variant<TS...> &lhs, const variant<TS...> &rhs) {…}

    template <class... TS>
    bool operator>(const variant<TS...> &lhs, const variant<TS...> &rhs)
    {
      return rhs < lhs;
    }
    bool operator>(const variant<TS...> &lhs, const variant<TS...> &rhs) {…}

    template <class... TS>
    bool operator>=(const variant<TS...> &lhs, const variant<TS...> &rhs)
    {
      return !(lhs < rhs);
    }
    bool operator>=(const variant<TS...> &lhs, const variant<TS...> &rhs) {…}
 
#pragma endregion
 
#pragma region variant copy
 
    template <class... TS>
    variant<TS...>::variant(const variant &rhs)
        : index_(rhs.index_)
    {
      visit(Detail::VariantCopier{&data_}, rhs);
    }
    variant<TS...>::variant(const variant &rhs) {…}
 
    template <class... TS>
    variant<TS...> &variant<TS...>::operator=(const variant &rhs)
    {
      if (this != &rhs)
      {
        delete_if_valid();
        visit(Detail::VariantCopier{&data_}, rhs);
        index_ = rhs.index_;
      }
 
      return *this;
    }
    variant<TS...> &variant<TS...>::operator=(const variant &rhs) {…}
 
#pragma endregion
 
#pragma region variant move
 
    template <class... TS>
    variant<TS...>::variant(variant &&rhs) noexcept
        : index_(rhs.index_)
    {
      try
      {
        visit(Detail::VariantMover{&data_}, std::move(rhs));
        rhs.delete_if_valid();  // NOLINT(bugprone-use-after-move)
      }
      catch (...)
      {
        // will never throw, but visit is capable of thowing so we must satisfy the compiler.
      }
    }
    variant<TS...>::variant(variant &&rhs) noexcept {…}
 
    template <class... TS>
    variant<TS...> &variant<TS...>::operator=(variant &&rhs)
    {
      if (this != &rhs)
      {
        delete_if_valid();
        visit(Detail::VariantMover{&data_}, std::move(rhs));
        index_ = rhs.index_;
        rhs.delete_if_valid();
      }
 
      return *this;
    }
    variant<TS...> &variant<TS...>::operator=(variant &&rhs) {…}
 
#pragma endregion
 
#pragma region variant swap
 
    template <class... TS>
    void variant<TS...>::swap(variant<TS...> &other)
    {
      // TODO: this can be made more efficient when we have the possibility to visit
      //       multiple variants.
      auto old = std::move(*this);
      *this    = std::move(other);
      other    = std::move(old);
    }
    void variant<TS...>::swap(variant<TS...> &other) {…}
 
#pragma endregion
 
#pragma region variant::delete_if_valid

    template <class... TS>
    void variant<TS...>::delete_if_valid() noexcept
    {
      try
      {
        if (!valueless_by_exception())
        {
          visit(Detail::VariantDestructor{}, *this);
          index_ = variant_npos;
        }
      }
      catch (...)
      {
        // will never throw, but visit is capable of thowing so we must satisfy the compiler.
      }
    }
 
#pragma endregion
 
#pragma region variant::emplace<I>
 
    template <class... TS>
    template <size_t I, class... ARGS>
    typename variant_alternative<I, variant<TS...>>::type &variant<TS...>::emplace(ARGS &&...args)
    {
      using NewT = Detail::TypeAt<I, TS...>;
 
      delete_if_valid();
      auto result = new (&data_) NewT(std::forward<ARGS>(args)...);  // NOLINT(cppcoreguidelines-owning-memory)
      index_      = I;
 
      return *result;
    }
    typename variant_alternative<I, variant<TS...>>::type &variant<TS...>::emplace(ARGS &&...args) {…}
 
#pragma endregion
 
  }  // namespace Shims
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb
 
namespace std  // NOLINT(cert-dcl58-cpp)
{
  template <class... TS>
  void swap(Cvb::Shims::variant<TS...> &lhs, Cvb::Shims::variant<TS...> &rhs)  // NOLINT(cert-dcl58-cpp)
  {
    lhs.swap(rhs);
  }
}  // namespace std