variant.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_VARIANT_HPP__
#define NEFORCE_CORE_UTILITY_VARIANT_HPP__

 
#include "NeForce/core/algorithm/compare.hpp"
#include "NeForce/core/exception/exception.hpp"
#include "NeForce/core/functional/invoke.hpp"
#include "NeForce/core/utility/none.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename Variant, typename T>
struct variant_index;
 
#ifdef NEFORCE_STANDARD_14
template <typename Variant, typename T>
NEFORCE_INLINE17 constexpr size_t variant_index_v = variant_index<Variant, T>::value;
#endif

template <typename Variant, size_t Idx>
struct variant_alternative;

template <typename Variant, size_t Idx>
using variant_alternative_t = typename variant_alternative<Variant, Idx>::type;
 

template <typename... Types>
struct variant : icommon<variant<Types...>> {
    static_assert(sizeof...(Types) > 0, "variant must have at least one type");
 
    static_assert(!is_any_of<none_t, Types...>::value ||
                          (is_any_of<none_t, Types...>::value && is_same<get_first_para_t<Types...>, none_t>::value),
                  "if variant holds none, it should be in the first place");
 
private:
    size_t index_ = 0; 

    alignas(_NEFORCE max({alignof(Types)...})) byte_t union_[_NEFORCE max({sizeof(Types)...})]{};
 
    using destruct_function = void (*)(byte_t*); 

    static destruct_function* destructors_table() noexcept {
        static destruct_function function_ptrs[sizeof...(Types)] = {
                // NOLINTNEXTLINE(readability-non-const-parameter)
                [](byte_t* const union_p) noexcept { reinterpret_cast<Types*>(union_p)->~Types(); }...};
        return function_ptrs;
    }
 
    using copy_construct_function = void (*)(byte_t*, byte_t const*); 

    static copy_construct_function* copy_constructors_table() noexcept {
        static copy_construct_function function_ptrs[sizeof...(Types)] = {
                // NOLINTNEXTLINE(readability-non-const-parameter)
                [](byte_t* const union_dst, byte_t const* union_src) noexcept {
                    new (union_dst) Types(*reinterpret_cast<Types const*>(union_src));
                }...};
        return function_ptrs;
    }
 
    using copy_assignment_function = void (*)(byte_t*, byte_t const*); 

    static copy_assignment_function* copy_assigment_functions_table() noexcept {
        static copy_assignment_function function_ptrs[sizeof...(Types)] = {
                [](byte_t* union_dst, byte_t const* union_src) noexcept {
                    *reinterpret_cast<Types*>(union_dst) = *reinterpret_cast<Types const*>(union_src);
                }...};
        return function_ptrs;
    }
 
    using move_construct_function = void (*)(byte_t*, const byte_t*); 

    static move_construct_function* move_constructors_table() noexcept {
        static move_construct_function function_ptrs[sizeof...(Types)] = {
                // NOLINTNEXTLINE(readability-non-const-parameter)
                [](byte_t* const union_dst, const byte_t* union_src) noexcept {
                    new (union_dst) Types(_NEFORCE move(*reinterpret_cast<const Types*>(union_src)));
                }...};
        return function_ptrs;
    }
 
    using move_assignment_function = void (*)(byte_t*, byte_t*); 

    static move_assignment_function* move_assigment_functions_table() noexcept {
        static move_assignment_function function_ptrs[sizeof...(Types)] = {
                // NOLINTNEXTLINE(readability-non-const-parameter)
                [](byte_t* union_dst, byte_t* const union_src) noexcept {
                    *reinterpret_cast<Types*>(union_dst) = _NEFORCE move(*reinterpret_cast<Types*>(union_src));
                }...};
        return function_ptrs;
    }
 
    template <typename Lambda>
    using const_visitor_function = common_type_t<_NEFORCE invoke_result_t<Lambda, Types const&>...> (*)(
            byte_t const*, Lambda&&); 

    template <typename Lambda>
    static const_visitor_function<Lambda>* const_visitors_table() noexcept {
        static const_visitor_function<Lambda> function_ptrs[sizeof...(Types)] = {
                [](byte_t const* union_p, Lambda&& lambda) -> _NEFORCE invoke_result_t<Lambda, Types const&> {
                    return _NEFORCE invoke(_NEFORCE forward<Lambda>(lambda), *reinterpret_cast<Types const*>(union_p));
                }...};
        return function_ptrs;
    }
 
    template <typename Lambda>
    using visitor_function =
            common_type_t<_NEFORCE invoke_result_t<Lambda, Types&>...> (*)(byte_t*, Lambda&&); 

    template <typename Lambda>
    static visitor_function<Lambda>* visitors_table() noexcept {
        static visitor_function<Lambda> function_ptrs[sizeof...(Types)] = {
                // NOLINTNEXTLINE(readability-non-const-parameter)
                [](byte_t* const union_p,
                   Lambda&& lambda) -> common_type_t<_NEFORCE invoke_result_t<Lambda, Types&>...> {
                    return _NEFORCE invoke(_NEFORCE forward<Lambda>(lambda), *reinterpret_cast<Types*>(union_p));
                }...};
        return function_ptrs;
    }
 
    template <size_t I, typename... Args,
              enable_if_t<is_constructible_v<variant_alternative_t<variant, I>, Args...>, int> = 0>
    constexpr bool try_construct_impl_aux_aux(Args&&... args) {
        index_ = I;
        new (union_) variant_alternative_t<variant, I>(_NEFORCE forward<Args>(args)...);
        return true;
    }
 
    template <size_t I, typename... Args,
              enable_if_t<!is_constructible_v<variant_alternative_t<variant, I>, Args...>, int> = 0>
    constexpr bool try_construct_impl_aux_aux(Args&&... args) {
        return variant::try_construct_impl<I + 1>(_NEFORCE forward<Args>(args)...);
    }
 
    template <size_t I, typename... Args, enable_if_t<(I < sizeof...(Types)), int> = 0>
    constexpr bool try_construct_impl_aux(Args&&... args) {
        return variant::try_construct_impl_aux_aux<I>(_NEFORCE forward<Args>(args)...);
    }
 
    template <size_t I, typename... Args, enable_if_t<(I >= sizeof...(Types)), int> = 0>
    constexpr bool try_construct_impl_aux(Args&&... /*unused*/) {
        return false;
    }
 
    template <size_t I, typename... Args>
    constexpr bool try_construct_impl(Args&&... args) {
        return variant::try_construct_impl_aux<I>(_NEFORCE forward<Args>(args)...);
    }
 
    template <size_t I = 0, typename... Args>
    constexpr bool try_construct(Args&&... args) {
        return variant::try_construct_impl<I>(_NEFORCE forward<Args>(args)...);
    }
 
    template <typename T, typename U>
    static NEFORCE_CONSTEXPR20 enable_if_t<is_same_v<T, U>, bool> equal_to_impl(const T& lhs, const U& rhs) {
        return lhs == rhs;
    }
    template <typename T, typename U>
    static NEFORCE_CONSTEXPR20 enable_if_t<!is_same_v<T, U>, bool> equal_to_impl(const T& /*unused*/,
                                                                                 const U& /*unused*/) {
        return false;
    }
 
    template <typename T, typename U>
    static NEFORCE_CONSTEXPR20 enable_if_t<is_same_v<T, U>, bool> less_than_impl(const T& lhs, const U& rhs) {
        return lhs < rhs;
    }
    template <typename T, typename U>
    static NEFORCE_CONSTEXPR20 enable_if_t<!is_same_v<T, U>, bool> less_than_impl(const T& /*unused*/,
                                                                                  const U& /*unused*/) {
        return false;
    }
 
public:
    NEFORCE_CONSTEXPR20 variant() noexcept(is_nothrow_default_constructible_v<variant_alternative_t<variant, 0>>) {
        new (union_) variant_alternative_t<variant, 0>();
    }

    template <typename T, enable_if_t<disjunction_v<is_same<T, Types>...>, int> = 0>
    NEFORCE_CONSTEXPR20 explicit variant(T&& value) noexcept(is_nothrow_move_constructible_v<T>) :
    index_(variant_index_v<variant, T>) {
        T* p = reinterpret_cast<T*>(union_);
        new (p) T(_NEFORCE forward<T>(value));
    }

    NEFORCE_CONSTEXPR20 variant(const variant& other) :
    index_(other.index_) {
        copy_constructors_table()[index()](union_, other.union_);
    }

    NEFORCE_CONSTEXPR20 variant& operator=(const variant& other) {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        index_ = other.index_;
        copy_assigment_functions_table()[index()](union_, other.union_);
        return *this;
    }

    NEFORCE_CONSTEXPR20 variant(variant&& other) noexcept :
    index_(other.index_) {
        move_constructors_table()[index()](union_, other.union_);
    }

    NEFORCE_CONSTEXPR20 variant& operator=(variant&& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        index_ = other.index_;
        move_assigment_functions_table()[index()](union_, other.union_);
        return *this;
    }

    template <size_t Idx, typename... Args,
              enable_if_t<is_constructible_v<variant_alternative_t<variant, Idx>, Args...>, int> = 0>
    NEFORCE_CONSTEXPR20 explicit variant(pass_size_construct_tag<Idx> /*unused*/, Args&&... args) noexcept(
            is_nothrow_constructible_v<variant_alternative_t<variant, Idx>, Args...>) :
    index_(Idx) {
        new (union_) variant_alternative_t<variant, Idx>(_NEFORCE forward<Args>(args)...);
    }

    template <size_t Idx, typename U, typename... Args,
              enable_if_t<is_constructible_v<variant_alternative_t<variant, Idx>, std::initializer_list<U>&, Args...>,
                          int> = 0>
    NEFORCE_CONSTEXPR20 explicit variant(
            pass_size_construct_tag<Idx> /*unused*/, std::initializer_list<U> ilist,
            Args&&... args) noexcept(is_nothrow_constructible_v<variant_alternative_t<variant, Idx>,
                                                                std::initializer_list<U>&, Args...>) :
    index_(Idx) {
        new (union_) variant_alternative_t<variant, Idx>(ilist, _NEFORCE forward<Args>(args)...);
    }

    template <typename... Args, enable_if_t<disjunction_v<is_constructible<Types, Args...>...>, int> = 0>
    variant(Args&&... args) {
        if (!variant::try_construct(_NEFORCE forward<Args>(args)...)) {
            index_ = 0;
            new (union_) variant_alternative_t<variant, 0>();
        }
    }

    NEFORCE_CONSTEXPR20 ~variant() noexcept { destructors_table()[index()](union_); }

    template <typename Lambda, enable_if_t<conjunction_v<is_invocable<Lambda, Types&>...>, int> = 0>
    NEFORCE_CONSTEXPR20 common_type_t<invoke_result_t<Lambda, Types&>...>
    visit(Lambda&& lambda) noexcept(conjunction_v<is_nothrow_invocable<Lambda, Types&>...>) {
        return visitors_table<Lambda>()[index()](union_, _NEFORCE forward<Lambda>(lambda));
    }

    template <typename Lambda, enable_if_t<conjunction_v<is_invocable<Lambda, const Types&>...>, int> = 0>
    NEFORCE_CONSTEXPR20 common_type_t<invoke_result_t<Lambda, const Types&>...> visit(Lambda&& lambda) const
            noexcept(conjunction_v<is_nothrow_invocable<Lambda, const Types&>...>) {
        return const_visitors_table<Lambda>()[index()](union_, _NEFORCE forward<Lambda>(lambda));
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 size_t index() const noexcept { return index_; }

    template <typename T, enable_if_t<is_any_of_v<T, Types...>, int> = 0>
    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool holds_alternative() const noexcept {
        return variant_index_v<variant, T> == index_;
    }

    template <size_t Idx, enable_if_t<(Idx < sizeof...(Types)), int> = 0>
    NEFORCE_CONSTEXPR20 variant_alternative_t<variant, Idx>& get() {
        if (index_ != Idx) {
            NEFORCE_THROW_EXCEPTION(value_exception("Template index not match."));
        }
        return *reinterpret_cast<variant_alternative_t<variant, Idx>*>(union_);
    }

    template <typename T>
    NEFORCE_CONSTEXPR20 T& get() {
        return variant::get<variant_index_v<variant, T>>();
    }

    template <size_t Idx, enable_if_t<(Idx < sizeof...(Types)), int> = 0>
    NEFORCE_CONSTEXPR20 variant_alternative_t<variant, Idx> const& get() const {
        if (index_ != Idx) {
            NEFORCE_THROW_EXCEPTION(value_exception("Template index not match."));
        }
        return *reinterpret_cast<variant_alternative_t<variant, Idx> const*>(union_);
    }

    template <typename T>
    NEFORCE_CONSTEXPR20 T const& get() const {
        return get<variant_index_v<variant, T>>();
    }

    template <size_t Idx, enable_if_t<(Idx < sizeof...(Types)), int> = 0>
    NEFORCE_CONSTEXPR20 variant_alternative_t<variant, Idx>* get_if() noexcept {
        if (index_ != Idx) {
            return nullptr;
        }
        return reinterpret_cast<variant_alternative_t<variant, Idx>*>(union_);
    }

    template <typename T>
    NEFORCE_CONSTEXPR20 T* get_if() noexcept {
        return get_if<variant_index_v<variant, T>>();
    }

    template <size_t Idx, enable_if_t<(Idx < sizeof...(Types)), int> = 0>
    NEFORCE_CONSTEXPR20 variant_alternative_t<variant, Idx> const* get_if() const noexcept {
        if (index_ != Idx) {
            return nullptr;
        }
        return reinterpret_cast<variant_alternative_t<variant, Idx> const*>(union_);
    }

    template <typename T>
    NEFORCE_CONSTEXPR20 T const* get_if() const noexcept {
        return get_if<variant_index_v<variant, T>>();
    }

    template <size_t Idx, typename... Args,
              enable_if_t<(Idx < sizeof...(Types)) && is_constructible_v<variant_alternative_t<variant, Idx>, Args...>,
                          int> = 0>
    NEFORCE_CONSTEXPR20 void
    emplace(Args&&... args) noexcept(is_nothrow_constructible_v<variant_alternative_t<variant, Idx>, Args...>) {
        destructors_table()[index()](union_);
        index_ = Idx;
        new (union_) variant_alternative_t<variant, Idx>(_NEFORCE forward<Args>(args)...);
    }

    template <typename T, typename... Args, enable_if_t<is_constructible_v<T, Args...>, int> = 0>
    NEFORCE_CONSTEXPR20 void emplace(Args&&... args) noexcept(is_nothrow_constructible_v<T, Args...>) {
        variant::emplace<variant_index_v<variant, T>>(_NEFORCE forward<Args>(args)...);
    }

    NEFORCE_CONSTEXPR20 void swap(variant& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return;
        }
 
        size_t this_index = index_;
        const size_t other_index = other.index_;
        alignas(_NEFORCE max({alignof(Types)...})) byte_t temp_union[_NEFORCE max({sizeof(Types)...})];
        move_constructors_table()[this_index](reinterpret_cast<byte_t*>(temp_union), union_);
        destructors_table()[this_index](union_);
 
        move_constructors_table()[other_index](union_, other.union_);
        destructors_table()[other_index](other.union_);
        move_constructors_table()[this_index](other.union_, reinterpret_cast<byte_t*>(temp_union));
        destructors_table()[this_index](reinterpret_cast<byte_t*>(temp_union));
 
        index_ = other_index;
        other.index_ = this_index;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool equal_to(const variant& rhs) const {
        if (index_ != rhs.index_) {
            return false;
        }
        return this->visit([&](const auto& value) {
            return rhs.visit([&](const auto& other_value) { return variant::equal_to_impl(value, other_value); });
        });
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool less_than(const variant& rhs) const {
        if (index_ != rhs.index_) {
            return false;
        }
        return this->visit([&](const auto& value) {
            return rhs.visit([&](const auto& other_value) { return variant::less_than_impl(value, other_value); });
        });
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 size_t to_hash() const;
};
 
#ifdef NEFORCE_STANDARD_17
template <typename... Args>
variant(Args...) -> variant<Args...>;
#endif

template <typename T, typename... Types>
struct variant_alternative<variant<T, Types...>, 0> {
    using type = T;
};
template <typename T, typename... Types, size_t Idx>
struct variant_alternative<variant<T, Types...>, Idx> {
    using type = typename variant_alternative<variant<Types...>, Idx - 1>::type;
};
 
template <typename T, typename... Types>
struct variant_index<variant<T, Types...>, T> {
    static constexpr size_t value = 0;
};
template <typename T0, typename T, typename... Types>
struct variant_index<variant<T0, Types...>, T> {
    static constexpr size_t value = variant_index<variant<Types...>, T>::value + 1;
};

template <size_t Idx, typename... Types>
NEFORCE_CONSTEXPR20 variant_alternative_t<variant<Types...>, Idx>& get(variant<Types...>& v) {
    using T = variant_alternative_t<variant<Types...>, Idx>;
    using variant_type = variant<Types...>;
    return static_cast<T&>(static_cast<variant_type&>(v).template get<Idx>());
}

template <size_t Idx, typename... Types>
NEFORCE_CONSTEXPR20 const variant_alternative_t<variant<Types...>, Idx>& get(const variant<Types...>& v) {
    using T = variant_alternative_t<variant<Types...>, Idx>;
    using variant_type = variant<Types...>;
    return static_cast<const T&>(static_cast<const variant_type&>(v).template get<Idx>());
}

template <size_t Idx, typename... Types>
NEFORCE_CONSTEXPR20 variant_alternative_t<variant<Types...>, Idx>&& get(variant<Types...>&& v) {
    using T = variant_alternative_t<variant<Types...>, Idx>;
    using variant_type = variant<Types...>;
    return static_cast<T&&>(static_cast<variant_type&&>(v).template get<Idx>());
}

template <size_t Idx, typename... Types>
NEFORCE_CONSTEXPR20 const variant_alternative_t<variant<Types...>, Idx>&& get(const variant<Types...>&& v) {
    using T = variant_alternative_t<variant<Types...>, Idx>;
    using variant_type = variant<Types...>;
    return static_cast<const T&&>(static_cast<const variant_type&&>(v).template get<Idx>());
}
 

 
NEFORCE_BEGIN_INNER__
struct __variant_elem_hasher {
    template <typename T>
    constexpr size_t operator()(const T& value) const {
        return hash<decay_t<T>>{}(value);
    }
};
NEFORCE_END_INNER__
 
template <typename... Types>
NEFORCE_CONSTEXPR20 size_t variant<Types...>::to_hash() const {
    constexpr inner::__variant_elem_hasher hasher{};
    return variant::visit(hasher);
}

 // Variant
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_UTILITY_VARIANT_HPP__