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;
};
 
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 { delete_if_valid(); }
 
  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));
  }
 
  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;
  }
 
  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)...);
  }
 
  size_t index() const noexcept { return index_; }
 
  void swap(variant &other);
 
  bool valueless_by_exception() const noexcept { return index_ == variant_npos; }
};
 
#pragma region monostate
 
struct monostate {};
 
constexpr bool operator<(monostate, monostate) noexcept { return false; }
 
constexpr bool operator>(monostate, monostate) noexcept { return false; }
 
constexpr bool operator<=(monostate, monostate) noexcept { return true; }
 
constexpr bool operator>=(monostate, monostate) noexcept { return true; }
 
constexpr bool operator==(monostate, monostate) noexcept { return true; }
 
constexpr bool operator!=(monostate, monostate) noexcept { return false; }
 
#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_);
}
 
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_);
}
 
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_);
}
 
#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);
}
 
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);
}
 
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));
}
 
#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);
}
 
#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);
}
 
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);
}
 
#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...>;
}
 
#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));
}
 
#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));
}
 
template <class... TS>
bool operator !=(const variant<TS...> &lhs, const variant<TS...> &rhs)
{
  return !(lhs == 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))
    );
}
 
template <class... TS>
bool operator <=(const variant<TS...> &lhs, const variant<TS...> &rhs)
{
  return !(rhs < lhs);
}
 
 
template <class... TS>
bool operator >(const variant<TS...> &lhs, const variant<TS...> &rhs)
{
  return rhs < lhs;
}
 
 
template <class... TS>
bool operator >=(const variant<TS...> &lhs, const variant<TS...> &rhs)
{
  return !(lhs < rhs);
}
 
#pragma endregion
 
#pragma region variant copy
 
template <class... TS>
variant<TS...>::variant(const variant &rhs)
  : index_(rhs.index_)
{
  visit(Detail::VariantCopier{&data_}, 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;
}
 
#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.
  }
}
 
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;
}
 
#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);
}
 
#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;
}
 
#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);
  }
}