variant.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_VARIANT_HPP
#define JOIN_CORE_VARIANT_HPP
 
// libjoin.
#include <join/traits.hpp>
 
// C++.
#include <algorithm>
#include <typeinfo>
 
// C.
#include <cstddef>
 
namespace join
{
    namespace details
    {
        template <typename... Ts>
        struct is_first_default_constructible
        {
            static constexpr bool value = std::is_default_constructible<find_element_t<0, Ts...>>::value;
        };
 
        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);
            }
 
            static bool lower (std::size_t which, const void* a, const void* b)
            {
                static const LowerFunc table[] = {&lowerImpl<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*);
 
            using LowerFunc = bool (*) (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 T>
            static typename std::enable_if<!std::is_null_pointer<T>::value, bool>::type lowerDispatch (const void* a,
                                                                                                       const void* b)
            {
                return *reinterpret_cast<const T*> (a) < *reinterpret_cast<const T*> (b);
            }
 
            template <typename T>
            static typename std::enable_if<std::is_null_pointer<T>::value, bool>::type lowerDispatch (const void*,
                                                                                                      const void*)
            {
                return false;
            }
 
            template <typename T>
            static bool lowerImpl (const void* a, const void* b)
            {
                return lowerDispatch<T> (a, b);
            }
        };
 
        template <typename... Ts>
        struct VariantStorage
        {
            constexpr VariantStorage ()
            : VariantStorage (in_place_index_t<0>{})
            {
            }
 
            constexpr VariantStorage (const VariantStorage& other)
            : _which (other._which)
            {
                VariantHelper<Ts...>::copy (other._which, other.storage (), storage ());
            }
 
            constexpr VariantStorage (VariantStorage&& other) noexcept
            : _which (other._which)
            {
                VariantHelper<Ts...>::move (other._which, other.storage (), storage ());
            }
 
            template <std::size_t I, typename... Args>
            constexpr explicit VariantStorage (in_place_index_t<I>, Args&&... args)
            : _which (I)
            {
                new (storage ()) find_element_t<I, Ts...> (std::forward<Args> (args)...);
            }
 
            ~VariantStorage ()
            {
                VariantHelper<Ts...>::destroy (_which, storage ());
            }
 
            constexpr VariantStorage& operator= (const VariantStorage& other)
            {
                VariantStorage tmp (other);
                swap (tmp);
                return *this;
            }
 
            constexpr VariantStorage& operator= (VariantStorage&& other) noexcept
            {
                swap (other);
                return *this;
            }
 
            constexpr void* storage ()
            {
                return static_cast<void*> (std::addressof (_data));
            }
 
            constexpr const void* storage () const
            {
                return static_cast<const void*> (std::addressof (_data));
            }
 
            void swap (VariantStorage& other) noexcept
            {
                alignas (Ts...) unsigned char tmp[std::max ({sizeof (Ts)...})];
                VariantHelper<Ts...>::move (_which, storage (), &tmp);
                VariantHelper<Ts...>::destroy (_which, storage ());
                VariantHelper<Ts...>::move (other._which, other.storage (), storage ());
                VariantHelper<Ts...>::destroy (other._which, other.storage ());
                VariantHelper<Ts...>::move (_which, &tmp, other.storage ());
                VariantHelper<Ts...>::destroy (_which, &tmp);
                std::swap (_which, other._which);
            }
 
            alignas (Ts...) unsigned char _data[std::max ({sizeof (Ts)...})];
 
            std::size_t _which = 0;
        };
    }
 
    template <typename... Ts>
    class Variant
    : private details::VariantStorage<Ts...>,
      private EnableDefault<details::is_first_default_constructible<Ts...>::value, Variant<Ts...>>,
      private std::_Enable_copy_move<are_copy_constructible<Ts...>::value, are_copy_assignable<Ts...>::value,
                                     are_move_constructible<Ts...>::value, are_move_assignable<Ts...>::value,
                                     Variant<Ts...>>
    {
    public:
        static_assert (0 < sizeof...(Ts), "Variant must have at least one alternative");
        static_assert (all<!std::is_void<Ts>::value...>::value, "Variant must have no void alternative");
        static_assert (all<!std::is_array<Ts>::value...>::value, "Variant must have no array alternative.");
        static_assert (all<!std::is_reference<Ts>::value...>::value, "Variant must have no reference alternative");
 
        using Base           = details::VariantStorage<Ts...>;
        using DefaultEnabler = EnableDefault<details::is_first_default_constructible<Ts...>::value, Variant<Ts...>>;
 
        constexpr Variant () = default;
 
        constexpr Variant (const Variant&) = default;
 
        constexpr Variant (Variant&&) = default;
 
        template <
            typename T, typename Match = match_t<T&&, Ts...>,
            typename = std::enable_if_t<is_unique<Match, Ts...>::value && std::is_constructible<Match, T&&>::value>>
        constexpr Variant (T&& t)
        : Variant (in_place_index_t<find_index<Match, Ts...>::value>{}, std::forward<T> (t))
        {
        }
 
        template <typename T, typename... Args,
                  typename = std::enable_if_t<is_unique<T, Ts...>::value && std::is_constructible<T, Args&&...>::value>>
        constexpr explicit Variant (in_place_type_t<T>, Args&&... args)
        : Variant (in_place_index_t<find_index<T, Ts...>::value>{}, std::forward<Args> (args)...)
        {
        }
 
        template <typename T, typename Up, typename... Args,
                  typename = std::enable_if_t<is_unique<T, Ts...>::value &&
                                              std::is_constructible<T, std::initializer_list<Up>&, Args&&...>::value>>
        constexpr explicit Variant (in_place_type_t<T>, std::initializer_list<Up> il, Args&&... args)
        : Variant (in_place_index_t<find_index<T, Ts...>::value>{}, il, std::forward<Args> (args)...)
        {
        }
 
        template <std::size_t I, typename... Args,
                  typename = std::enable_if_t<std::is_constructible<find_element_t<I, Ts...>, Args&&...>::value>>
        constexpr explicit Variant (in_place_index_t<I>, Args&&... args)
        : Base (in_place_index_t<I>{}, std::forward<Args> (args)...)
        , DefaultEnabler (EnableDefaultTag{})
        {
        }
 
        template <std::size_t I, typename Up, typename... Args,
                  typename = std::enable_if_t<
                      std::is_constructible<find_element_t<I, Ts...>, std::initializer_list<Up>&, Args&&...>::value>>
        constexpr explicit Variant (in_place_index_t<I>, std::initializer_list<Up> il, Args&&... args)
        : Base (in_place_index_t<I>{}, il, std::forward<Args> (args)...)
        , DefaultEnabler (EnableDefaultTag{})
        {
        }
 
        ~Variant () = default;
 
        constexpr Variant& operator= (const Variant& other) = default;
 
        constexpr Variant& operator= (Variant&& other) = default;
 
        template <typename T, typename Match = match_t<T&&, Ts...>>
        constexpr std::enable_if_t<is_unique<Match, Ts...>::value && std::is_constructible<Match, T&&>::value, Variant&>
        operator= (T&& t)
        {
            set<find_index<Match, Ts...>::value> (std::forward<T> (t));
            return *this;
        }
 
        template <typename T>
        constexpr std::enable_if_t<is_unique<T, Ts...>::value, bool> is () const
        {
            return (index () == find_index<T, Ts...>::value);
        }
 
        template <std::size_t I>
        constexpr std::enable_if_t<is_index<I, Ts...>::value, bool> is () const
        {
            return (index () == I);
        }
 
        template <typename T, typename... Args>
        constexpr std::enable_if_t<is_unique<T, Ts...>::value && std::is_constructible<T, Args&&...>::value, T&> set (
            Args&&... args)
        {
            return set<find_index<T, Ts...>::value> (std::forward<Args> (args)...);
        }
 
        template <typename T, typename Up, typename... Args>
        constexpr std::enable_if_t<
            is_unique<T, Ts...>::value && std::is_constructible<T, std::initializer_list<Up>&, Args&&...>::value, T&>
        set (std::initializer_list<Up> il, Args&&... args)
        {
            return set<find_index<T, Ts...>::value> (il, std::forward<Args> (args)...);
        }
 
        template <std::size_t I, typename... Args>
        constexpr std::enable_if_t<std::is_constructible<find_element_t<I, Ts...>, Args&&...>::value,
                                   find_element_t<I, Ts...>&>
        set (Args&&... args)
        {
            Variant tmp (in_place_index_t<I>{}, std::forward<Args> (args)...);
            *this = std::move (tmp);
            return get<I> ();
        }
 
        template <std::size_t I, class Up, class... Args>
        constexpr std::enable_if_t<
            std::is_constructible<find_element_t<I, Ts...>, std::initializer_list<Up>&, Args&&...>::value,
            find_element_t<I, Ts...>&>
        set (std::initializer_list<Up> il, Args&&... args)
        {
            Variant tmp (in_place_index_t<I>{}, il, std::forward<Args> (args)...);
            *this = std::move (tmp);
            return get<I> ();
        }
 
        template <typename T>
        constexpr std::enable_if_t<is_unique<T, Ts...>::value, T&> get ()
        {
            if (index () != find_index<T, Ts...>::value)
            {
                throw std::bad_cast ();
            }
            return *reinterpret_cast<T*> (this->storage ());
        }
 
        template <typename T>
        constexpr std::enable_if_t<is_unique<T, Ts...>::value, const T&> get () const
        {
            if (index () != find_index<T, Ts...>::value)
            {
                throw std::bad_cast ();
            }
            return *reinterpret_cast<const T*> (this->storage ());
        }
 
        template <std::size_t I>
        constexpr std::enable_if_t<is_index<I, Ts...>::value, find_element_t<I, Ts...>&> get ()
        {
            if (index () != I)
            {
                throw std::bad_cast ();
            }
            return *reinterpret_cast<find_element_t<I, Ts...>*> (this->storage ());
        }
 
        template <std::size_t I>
        constexpr std::enable_if_t<is_index<I, Ts...>::value, const find_element_t<I, Ts...>&> get () const
        {
            if (index () != I)
            {
                throw std::bad_cast ();
            }
            return *reinterpret_cast<const find_element_t<I, Ts...>*> (this->storage ());
        }
 
        template <typename T>
        constexpr std::enable_if_t<is_unique<T, Ts...>::value, T*> getIf ()
        {
            if (index () != find_index<T, Ts...>::value)
            {
                return nullptr;
            }
            return reinterpret_cast<T*> (this->storage ());
        }
 
        template <typename T>
        constexpr std::enable_if_t<is_unique<T, Ts...>::value, const T*> getIf () const
        {
            if (index () != find_index<T, Ts...>::value)
            {
                return nullptr;
            }
            return reinterpret_cast<const T*> (this->storage ());
        }
 
        template <std::size_t I>
        constexpr std::enable_if_t<is_index<I, Ts...>::value, find_element_t<I, Ts...>*> getIf ()
        {
            if (index () != I)
            {
                return nullptr;
            }
            return reinterpret_cast<find_element_t<I, Ts...>*> (this->storage ());
        }
 
        template <std::size_t I>
        constexpr std::enable_if_t<is_index<I, Ts...>::value, const find_element_t<I, Ts...>*> getIf () const
        {
            if (index () != I)
            {
                return nullptr;
            }
            return reinterpret_cast<const find_element_t<I, Ts...>*> (this->storage ());
        }
 
        constexpr std::size_t index () const noexcept
        {
            return this->_which;
        }
 
        void swap (Variant& other) noexcept
        {
            Base::swap (other);
        }
 
    protected:
        constexpr bool equal (const Variant& rhs) const
        {
            if (index () != rhs.index ())
            {
                return false;
            }
            return details::VariantHelper<Ts...>::equal (index (), this->storage (), rhs.storage ());
        }
 
        constexpr bool lower (const Variant& rhs) const
        {
            if (index () < rhs.index ())
            {
                return true;
            }
            if (index () > rhs.index ())
            {
                return false;
            }
            return details::VariantHelper<Ts...>::lower (index (), this->storage (), rhs.storage ());
        }
 
        // friendship with equal operator.
        template <typename... _Ts>
        friend constexpr bool operator== (const Variant<_Ts...>& lhs, const Variant<_Ts...>& rhs);
 
        // friendship with lower operator.
        template <typename... _Ts>
        friend constexpr bool operator< (const Variant<_Ts...>& lhs, const Variant<_Ts...>& rhs);
    };
 
    template <typename... Ts>
    constexpr bool operator== (const Variant<Ts...>& lhs, const Variant<Ts...>& rhs)
    {
        return lhs.equal (rhs);
    }
 
    template <typename... Ts>
    constexpr bool operator!= (const Variant<Ts...>& lhs, const Variant<Ts...>& rhs)
    {
        return !(lhs == rhs);
    }
 
    template <typename... Ts>
    constexpr bool operator< (const Variant<Ts...>& lhs, const Variant<Ts...>& rhs)
    {
        return lhs.lower (rhs);
    }
 
    template <typename... Ts>
    constexpr bool operator> (const Variant<Ts...>& lhs, const Variant<Ts...>& rhs)
    {
        return rhs < lhs;
    }
 
    template <typename... Ts>
    constexpr bool operator<= (const Variant<Ts...>& lhs, const Variant<Ts...>& rhs)
    {
        return !(rhs < lhs);
    }
 
    template <typename... Ts>
    constexpr bool operator>= (const Variant<Ts...>& lhs, const Variant<Ts...>& rhs)
    {
        return !(lhs < rhs);
    }
 
    template <typename... Ts>
    void swap (Variant<Ts...>& lhs, Variant<Ts...>& rhs) noexcept
    {
        lhs.swap (rhs);
    }
}
 
#endif