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

  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)
    : 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)
  : index_(rhs.index_)
{
  visit(Detail::VariantMover{&data_}, std::move(rhs));
  rhs.delete_if_valid();
}

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
{
  if(!valueless_by_exception())
  {
    visit(Detail::VariantDestructor{}, *this);
    index_ = variant_npos;
  }
}

#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)...);
  index_ = I;

  return *result;
}

#pragma endregion

} // namespace Shims

CVB_END_INLINE_NS

} // namespace Cvb

namespace std
{
  template <class... TS>
  void swap(Cvb::Shims::variant<TS...> &lhs, Cvb::Shims::variant<TS...> &rhs)
  {
    lhs.swap(rhs);
  }
}