variant.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_VARIANT_HPP
#define JOIN_CORE_VARIANT_HPP
 
// libjoin.
#include <join/traits.hpp>
#include <join/utils.hpp>
 
// C++.
#include <algorithm>
#include <typeinfo>
#include <compare>
#include <tuple>
 
// C.
#include <cstddef>
#include <cstdint>
 
namespace join
{
    namespace details
    {
        template <typename T>
        struct OrderingOf : std::compare_three_way_result<T>
        {
        };
 
        template <>
        struct OrderingOf<std::nullptr_t>
        {
            using type = std::strong_ordering;
        };
 
        template <typename... Ts>
        using VariantOrdering = std::common_comparison_category_t<typename OrderingOf<Ts>::type...>;
 
        template <typename... Ts>
        struct VariantHelper
        {
        public:
            static void copy (std::size_t which, const void* src, void* dst)
            {
                static const CopyFunc table[] = {&copyImpl<Ts>...};
                table[which](src, dst);
            }
 
            static void move (std::size_t which, void* src, void* dst)
            {
                static const MoveFunc table[] = {&moveImpl<Ts>...};
                table[which](src, dst);
            }
 
            static void destroy (std::size_t which, void* data)
            {
                static const DestroyFunc table[] = {&destroyImpl<Ts>...};
                table[which](data);
            }
 
            static bool equal (std::size_t which, const void* a, const void* b)
            {
                static const EqualFunc table[] = {&equalImpl<Ts>...};
                return table[which](a, b);
            }
 
            template <typename Ordering>
            static Ordering compare (std::size_t which, const void* a, const void* b)
            {
                static const CompareFunc<Ordering> table[] = {&compareImpl<Ordering, Ts>...};
                return table[which](a, b);
            }
 
        private:
            using CopyFunc = void (*) (const void*, void*);
 
            using MoveFunc = void (*) (void*, void*);
 
            using DestroyFunc = void (*) (void*);
 
            using EqualFunc = bool (*) (const void*, const void*);
 
            template <typename Ordering>
            using CompareFunc = Ordering (*) (const void*, const void*);
 
            template <typename T>
            static void copyImpl (const void* src, void* dst)
            {
                new (dst) T (*reinterpret_cast<const T*> (src));
            }
 
            template <typename T>
            static void moveImpl (void* src, void* dst)
            {
                new (dst) T (std::move (*reinterpret_cast<T*> (src)));
            }
 
            template <typename T>
            static void destroyImpl (void* data)
            {
                reinterpret_cast<T*> (data)->~T ();
            }
 
            template <typename T>
            static bool equalImpl (const void* a, const void* b)
            {
                return *reinterpret_cast<const T*> (a) == *reinterpret_cast<const T*> (b);
            }
 
            template <typename Ordering, typename T>
            static Ordering compareImpl (const void* a, const void* b)
            {
                if constexpr (std::is_null_pointer_v<T>)
                {
                    return std::strong_ordering::equivalent;
                }
                else
                {
                    return *reinterpret_cast<const T*> (a) <=> *reinterpret_cast<const T*> (b);
                }
            }
        };
    }
 
    template <typename... Ts>
    class Variant
    {
        static constexpr bool _trivial = (std::is_trivially_copyable_v<Ts> && ...);
 
        static constexpr bool _defaultConstructible =
            std::is_default_constructible_v<std::tuple_element_t<0, std::tuple<Ts...>>>;
 
        static constexpr bool _copyConstructible = (std::is_copy_constructible_v<Ts> && ...);
 
        static constexpr bool _moveConstructible = (std::is_move_constructible_v<Ts> && ...);
 
        static constexpr bool _copyAssignable =
            _copyConstructible && _moveConstructible && (std::is_copy_assignable_v<Ts> && ...);
 
        static constexpr bool _moveAssignable = _moveConstructible && (std::is_move_assignable_v<Ts> && ...);
 
    public:
        static_assert (0 < sizeof...(Ts), "Variant must have at least one alternative");
        static_assert ((!std::is_void_v<Ts> && ...), "Variant must have no void alternative");
        static_assert ((!std::is_array_v<Ts> && ...), "Variant must have no array alternative.");
        static_assert ((!std::is_reference_v<Ts> && ...), "Variant must have no reference alternative");
 
        constexpr Variant ()
            requires _defaultConstructible
        : Variant (std::in_place_index<0>)
        {
        }
 
        constexpr Variant (const Variant& other)
            requires (_trivial && _copyConstructible)
        = default;
 
        constexpr Variant (const Variant& other)
            requires (!_trivial && _copyConstructible)
        : _which (other._which)
        {
            details::VariantHelper<Ts...>::copy (other._which, other.storage (), storage ());
        }
 
        constexpr Variant (Variant&& other)
            requires (_trivial && _moveConstructible)
        = default;
 
        constexpr Variant (Variant&& other) noexcept
            requires (!_trivial && _moveConstructible)
        : _which (other._which)
        {
            details::VariantHelper<Ts...>::move (other._which, other.storage (), storage ());
        }
 
        template <typename T, typename Match = match_t<T&&, Ts...>>
        constexpr Variant (T&& t)
            requires is_unique_v<Match, Ts...> && std::is_constructible_v<Match, T&&>
        : Variant (std::in_place_index<find_index_v<Match, Ts...>>, std::forward<T> (t))
        {
        }
 
        template <typename T, typename... Args>
        constexpr explicit Variant (std::in_place_type_t<T>, Args&&... args)
            requires is_unique_v<T, Ts...> && std::is_constructible_v<T, Args&&...>
        : Variant (std::in_place_index<find_index_v<T, Ts...>>, std::forward<Args> (args)...)
        {
        }
 
        template <typename T, typename Up, typename... Args>
        constexpr explicit Variant (std::in_place_type_t<T>, std::initializer_list<Up> il, Args&&... args)
            requires is_unique_v<T, Ts...> && std::is_constructible_v<T, std::initializer_list<Up>&, Args&&...>
        : Variant (std::in_place_index<find_index_v<T, Ts...>>, il, std::forward<Args> (args)...)
        {
        }
 
        template <std::size_t I, typename... Args>
        constexpr explicit Variant (std::in_place_index_t<I>, Args&&... args)
            requires std::is_constructible_v<std::tuple_element_t<I, std::tuple<Ts...>>, Args&&...>
        : _which (I)
        {
            new (storage ()) std::tuple_element_t<I, std::tuple<Ts...>> (std::forward<Args> (args)...);
        }
 
        template <std::size_t I, typename Up, typename... Args>
        constexpr explicit Variant (std::in_place_index_t<I>, std::initializer_list<Up> il, Args&&... args)
            requires std::is_constructible_v<std::tuple_element_t<I, std::tuple<Ts...>>, std::initializer_list<Up>&,
                                             Args&&...>
        : _which (I)
        {
            new (storage ()) std::tuple_element_t<I, std::tuple<Ts...>> (il, std::forward<Args> (args)...);
        }
 
        ~Variant ()
            requires _trivial
        = default;
 
        ~Variant ()
            requires (!_trivial)
        {
            details::VariantHelper<Ts...>::destroy (_which, storage ());
        }
 
        constexpr Variant& operator= (const Variant& other)
            requires (_trivial && _copyAssignable)
        = default;
 
        constexpr Variant& operator= (const Variant& other)
            requires (!_trivial && _copyAssignable)
        {
            Variant tmp (other);
            swap (tmp);
            return *this;
        }
 
        constexpr Variant& operator= (Variant&& other)
            requires (_trivial && _moveAssignable)
        = default;
 
        constexpr Variant& operator= (Variant&& other) noexcept
            requires (!_trivial && _moveAssignable)
        {
            swap (other);
            return *this;
        }
 
        template <typename T, typename Match = match_t<T&&, Ts...>>
        constexpr Variant& operator= (T&& t)
            requires is_unique_v<Match, Ts...> && std::is_constructible_v<Match, T&&>
        {
            set<find_index_v<Match, Ts...>> (std::forward<T> (t));
            return *this;
        }
 
        template <typename T>
        constexpr bool is () const
            requires is_unique_v<T, Ts...>
        {
            return (index () == find_index_v<T, Ts...>);
        }
 
        template <std::size_t I>
        constexpr bool is () const
            requires (I < sizeof...(Ts))
        {
            return (index () == I);
        }
 
        template <typename T, typename... Args>
        constexpr T& set (Args&&... args)
            requires is_unique_v<T, Ts...> && std::is_constructible_v<T, Args&&...>
        {
            return set<find_index_v<T, Ts...>> (std::forward<Args> (args)...);
        }
 
        template <typename T, typename Up, typename... Args>
        constexpr T& set (std::initializer_list<Up> il, Args&&... args)
            requires is_unique_v<T, Ts...> && std::is_constructible_v<T, std::initializer_list<Up>&, Args&&...>
        {
            return set<find_index_v<T, Ts...>> (il, std::forward<Args> (args)...);
        }
 
        template <std::size_t I, typename... Args>
        constexpr std::tuple_element_t<I, std::tuple<Ts...>>& set (Args&&... args)
            requires std::is_constructible_v<std::tuple_element_t<I, std::tuple<Ts...>>, Args&&...>
        {
            Variant tmp (std::in_place_index<I>, std::forward<Args> (args)...);
            *this = std::move (tmp);
            return get<I> ();
        }
 
        template <std::size_t I, class Up, class... Args>
        constexpr std::tuple_element_t<I, std::tuple<Ts...>>& set (std::initializer_list<Up> il, Args&&... args)
            requires std::is_constructible_v<std::tuple_element_t<I, std::tuple<Ts...>>, std::initializer_list<Up>&,
                                             Args&&...>
        {
            Variant tmp (std::in_place_index<I>, il, std::forward<Args> (args)...);
            *this = std::move (tmp);
            return get<I> ();
        }
 
        template <typename T>
        constexpr T& get ()
            requires is_unique_v<T, Ts...>
        {
            if (index () != find_index_v<T, Ts...>)
            {
                throwException<std::bad_cast> ();
            }
            return *reinterpret_cast<T*> (storage ());
        }
 
        template <typename T>
        constexpr const T& get () const
            requires is_unique_v<T, Ts...>
        {
            if (index () != find_index_v<T, Ts...>)
            {
                throwException<std::bad_cast> ();
            }
            return *reinterpret_cast<const T*> (storage ());
        }
 
        template <std::size_t I>
        constexpr std::tuple_element_t<I, std::tuple<Ts...>>& get ()
            requires (I < sizeof...(Ts))
        {
            if (index () != I)
            {
                throwException<std::bad_cast> ();
            }
            return *reinterpret_cast<std::tuple_element_t<I, std::tuple<Ts...>>*> (storage ());
        }
 
        template <std::size_t I>
        constexpr const std::tuple_element_t<I, std::tuple<Ts...>>& get () const
            requires (I < sizeof...(Ts))
        {
            if (index () != I)
            {
                throwException<std::bad_cast> ();
            }
            return *reinterpret_cast<const std::tuple_element_t<I, std::tuple<Ts...>>*> (storage ());
        }
 
        template <typename T>
        constexpr T* getIf ()
            requires is_unique_v<T, Ts...>
        {
            if (index () != find_index_v<T, Ts...>)
            {
                return nullptr;
            }
            return reinterpret_cast<T*> (storage ());
        }
 
        template <typename T>
        constexpr const T* getIf () const
            requires is_unique_v<T, Ts...>
        {
            if (index () != find_index_v<T, Ts...>)
            {
                return nullptr;
            }
            return reinterpret_cast<const T*> (storage ());
        }
 
        template <std::size_t I>
        constexpr std::tuple_element_t<I, std::tuple<Ts...>>* getIf ()
            requires (I < sizeof...(Ts))
        {
            if (index () != I)
            {
                return nullptr;
            }
            return reinterpret_cast<std::tuple_element_t<I, std::tuple<Ts...>>*> (storage ());
        }
 
        template <std::size_t I>
        constexpr const std::tuple_element_t<I, std::tuple<Ts...>>* getIf () const
            requires (I < sizeof...(Ts))
        {
            if (index () != I)
            {
                return nullptr;
            }
            return reinterpret_cast<const std::tuple_element_t<I, std::tuple<Ts...>>*> (storage ());
        }
 
        constexpr std::size_t index () const noexcept
        {
            if (_which >= sizeof...(Ts))
            {
                __builtin_unreachable ();
            }
            return _which;
        }
 
        void swap (Variant& other) noexcept
        {
            if constexpr (_trivial)
            {
                std::swap (_data, other._data);
                std::swap (_which, other._which);
            }
            else
            {
                alignas (Ts...) unsigned char tmp[std::max ({sizeof (Ts)...})];
                details::VariantHelper<Ts...>::move (_which, storage (), &tmp);
                details::VariantHelper<Ts...>::destroy (_which, storage ());
                details::VariantHelper<Ts...>::move (other._which, other.storage (), storage ());
                details::VariantHelper<Ts...>::destroy (other._which, other.storage ());
                details::VariantHelper<Ts...>::move (_which, &tmp, other.storage ());
                details::VariantHelper<Ts...>::destroy (_which, &tmp);
                std::swap (_which, other._which);
            }
        }
 
    protected:
        constexpr bool equal (const Variant& rhs) const
        {
            if (index () != rhs.index ())
            {
                return false;
            }
            return details::VariantHelper<Ts...>::equal (index (), storage (), rhs.storage ());
        }
 
        constexpr auto compare (const Variant& rhs) const
        {
            using Ordering = details::VariantOrdering<Ts...>;
            if (index () != rhs.index ())
            {
                return Ordering (index () <=> rhs.index ());
            }
            return details::VariantHelper<Ts...>::template compare<Ordering> (index (), storage (), rhs.storage ());
        }
 
        // friendship with equal operator.
        template <typename... _Ts>
        friend constexpr bool operator== (const Variant<_Ts...>& lhs, const Variant<_Ts...>& rhs);
 
        // friendship with three-way comparison operator.
        template <typename... _Ts>
        friend constexpr details::VariantOrdering<_Ts...> operator<=> (const Variant<_Ts...>& lhs,
                                                                       const Variant<_Ts...>& rhs);
 
    private:
        constexpr void* storage ()
        {
            return static_cast<void*> (std::addressof (_data));
        }
 
        constexpr const void* storage () const
        {
            return static_cast<const void*> (std::addressof (_data));
        }
 
        alignas (Ts...) unsigned char _data[std::max ({sizeof (Ts)...})];
 
        uint32_t _which = 0;
    };
 
    template <typename... Ts>
    constexpr bool operator== (const Variant<Ts...>& lhs, const Variant<Ts...>& rhs)
    {
        return lhs.equal (rhs);
    }
 
    template <typename... Ts>
    constexpr details::VariantOrdering<Ts...> operator<=> (const Variant<Ts...>& lhs, const Variant<Ts...>& rhs)
    {
        return lhs.compare (rhs);
    }
 
    template <typename... Ts>
    void swap (Variant<Ts...>& lhs, Variant<Ts...>& rhs) noexcept
    {
        lhs.swap (rhs);
    }
}
 
#endif