variant.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_UTILITY_VARIANT_HPP__
#define MSTL_CORE_UTILITY_VARIANT_HPP__

 
#include "MSTL/core/utility/none.hpp"
MSTL_BEGIN_NAMESPACE__


template <typename Variant, typename T>
struct variant_index;
 
#ifdef MSTL_STANDARD_14__
template <typename Variant, typename T>
MSTL_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;
 // VariantTypeTraits


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 non, it should be at the first place");
 
private:
    size_t index_ = 0;  

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

    static destruct_function* destructors_table() noexcept {
        static destruct_function function_ptrs[sizeof...(Types)] = {
            [](byte_t* 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)] = {
            [](byte_t* 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)] = {
            [](byte_t* union_dst, const byte_t* union_src) noexcept {
                new (union_dst) Types(_MSTL 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)] = {
            [](byte_t* union_dst, byte_t* union_src) noexcept {
                *reinterpret_cast<Types*>(union_dst) = _MSTL move(*reinterpret_cast<Types*>(union_src));
            }...
        };
        return function_ptrs;
    }
 
    template <typename Lambda>
    using const_visitor_function = common_type_t<
        _MSTL 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) -> _MSTL invoke_result_t<Lambda, Types const&> {
                return _MSTL invoke(_MSTL forward<Lambda>(lambda), *reinterpret_cast<Types const*>(union_p));
            }...
        };
        return function_ptrs;
    }
 
    template <typename Lambda>
    using visitor_function = common_type_t<
        _MSTL 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)] = {
            [](byte_t* union_p, Lambda&& lambda) -> common_type_t<_MSTL invoke_result_t<Lambda, Types&>...> {
                return _MSTL invoke(_MSTL 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>(_MSTL 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>(_MSTL 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>(_MSTL forward<Args>(args)...);
    }
 
    template <size_t I, typename... Args, enable_if_t<(I >= sizeof...(Types)), int> = 0>
    constexpr bool try_construct_impl_aux(Args&&...) {
        return false;
    }
 
    template <size_t I, typename... Args>
    constexpr bool try_construct_impl(Args&&... args) {
        return variant::try_construct_impl_aux<I>(_MSTL forward<Args>(args)...);
    }
 
    template <size_t I = 0, typename... Args>
    constexpr bool try_construct(Args&&... args) {
        return variant::try_construct_impl<I>(_MSTL forward<Args>(args)...);
    }
 
public:
    MSTL_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>
    MSTL_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(_MSTL forward<T>(value));
    }

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

    MSTL_CONSTEXPR20 variant& operator =(const variant& x) {
        if(_MSTL addressof(x) == this) return *this;
        index_ = x.index_;
        copy_assigment_functions_table()[index()](union_, x.union_);
        return *this;
    }

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

    MSTL_CONSTEXPR20 variant& operator =(variant&& x) noexcept {
        if(_MSTL addressof(x) == this) return *this;
        index_ = x.index_;
        move_assigment_functions_table()[index()](union_, x.union_);
        return *this;
    }

    template <size_t Idx, typename... Args,
        enable_if_t<is_constructible_v<variant_alternative_t<variant, Idx>, Args...>, int> = 0>
    MSTL_CONSTEXPR20 explicit variant(inplace_construct_tag, Args&&... args)
    noexcept(is_nothrow_constructible_v<variant_alternative_t<variant, Idx>, Args...>)
    : index_(Idx) {
        new (union_) variant_alternative_t<variant, Idx>(_MSTL 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>
    MSTL_CONSTEXPR20 explicit variant(inplace_construct_tag, 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, _MSTL forward<Args>(args)...);
    }

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

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

    template <typename Lambda, enable_if_t<conjunction_v<is_invocable<Lambda, Types&>...>, int> = 0>
    MSTL_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_, _MSTL forward<Lambda>(lambda));
    }

    template <typename Lambda, enable_if_t<conjunction_v<is_invocable<Lambda, const Types&>...>, int> = 0>
    MSTL_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_, _MSTL forward<Lambda>(lambda));
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 size_t index() const noexcept {
        return index_;
    }

    template <typename T, enable_if_t<is_any_of_v<T, Types...>, int> = 0>
    MSTL_NODISCARD MSTL_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>
    MSTL_CONSTEXPR20 variant_alternative_t<variant, Idx>& get() {
        if(index_ != Idx) {
            throw_exception(value_exception("Template index not match."));
        }
        return *reinterpret_cast<variant_alternative_t<variant, Idx>*>(union_);
    }

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

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

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

    template <size_t Idx, enable_if_t<(Idx < sizeof...(Types)), int> = 0>
    MSTL_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>
    MSTL_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>
    MSTL_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>
    MSTL_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>
    MSTL_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>(_MSTL forward<Args>(args)...);
    }

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

    MSTL_CONSTEXPR20 void swap(variant& x) noexcept {
        if (_MSTL addressof(x) == this) return;
 
        size_t this_index = index_;
        const size_t other_index = x.index_;
        alignas(_MSTL max({ alignof(Types)... })) byte_t temp_union[_MSTL 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_, x.union_);
        destructors_table()[other_index](x.union_);
        move_constructors_table()[this_index](x.union_, reinterpret_cast<byte_t*>(temp_union));
        destructors_table()[this_index](reinterpret_cast<byte_t*>(temp_union));
 
        index_ = other_index;
        x.index_ = this_index;
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 bool operator ==(const variant& rhs) const {
        if (index_ != rhs.index_) return false;
        return this->visit([&](const auto& value) {
            return rhs.visit([&](const auto& other_value) {
                return value == other_value;
            });
        });
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 bool operator <(const variant& rhs) const {
        if (index_ != rhs.index_) return false;
        return this->visit([&](const auto& value) {
            return rhs.visit([&](const auto& other_value) {
                return value < other_value;
            });
        });
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 size_t to_hash() const;
};
 
#ifdef MSTL_SUPPORT_DEDUCTION_GUIDES__
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>
MSTL_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>
MSTL_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>
MSTL_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>
MSTL_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>());
}

MSTL_BEGIN_INNER__
struct __variant_elem_hasher {
    template <typename T>
    constexpr size_t operator ()(const T& value) const {
        return hash<decay_t<T>>{}(value);
    }
};
MSTL_END_INNER__
 
template <typename... Types>
MSTL_CONSTEXPR20 size_t variant<Types...>::to_hash() const {
    constexpr _INNER __variant_elem_hasher hasher{};
    return variant::visit(hasher);
}
 // Variant
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_UTILITY_VARIANT_HPP__