variant.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_VARIANT_HPP__
#define __JOIN_VARIANT_HPP__
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
 
// libjoin.
#include <join/traits.hpp>
 
// C++.
#include <algorithm>
#include <typeinfo>
 
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
        {
        };
 
        template <typename Last>
        struct VariantHelper <Last>
        {
            inline static void destroy (std::size_t /*index*/, void* data)
            {
                reinterpret_cast <Last *> (data)->~Last ();
            }
 
            inline static void copy (std::size_t /*oldIndex*/, const void* oldData, void* newData)
            {
                new (newData) Last (*reinterpret_cast <const Last *> (oldData));
            }
 
            inline static void move (std::size_t /*oldIndex*/, void* oldData, void* newData)
            {
                new (newData) Last (std::move (*reinterpret_cast <Last *> (oldData)));
            }
 
            inline static bool equal (std::size_t /*index*/, const void* data, const void* otherData)
            {
                return *reinterpret_cast <const Last *> (data) == *reinterpret_cast <const Last *> (otherData);
            }
 
            template <typename T = Last, typename std::enable_if_t <!std::is_null_pointer <T>::value>* = nullptr>
            inline static bool lower (std::size_t /*index*/, const void* data, const void* otherData)
            {
                return *reinterpret_cast <const Last *> (data) < *reinterpret_cast <const Last *> (otherData);
            }
 
            template <typename T = Last, typename std::enable_if_t <std::is_null_pointer <T>::value>* = nullptr>
            inline static bool lower (std::size_t /*index*/, const void* /*data*/, const void* /*otherData*/)
            {
                return false;
            }
        };
 
        template <typename First, typename... Ts>
        struct VariantHelper <First, Ts...>
        {
            inline static void destroy (std::size_t index, void* data)
            {
                if (index == sizeof... (Ts))
                {
                    reinterpret_cast <First *> (data)->~First ();
                }
                else
                {
                    VariantHelper <Ts...>::destroy (index, data);
                }
            }
 
            inline static void copy (std::size_t oldIndex, const void* oldData, void* newData)
            {
                if (oldIndex == sizeof... (Ts))
                {
                    new (newData) First (*reinterpret_cast <const First *> (oldData));
                }
                else
                {
                    VariantHelper <Ts...>::copy (oldIndex, oldData, newData);
                }
            }
 
            inline static void move (std::size_t oldIndex, void* oldData, void* newData)
            {
                if (oldIndex == sizeof... (Ts))
                {
                    new (newData) First (std::move (*reinterpret_cast <First *> (oldData)));
                }
                else
                {
                    VariantHelper <Ts...>::move (oldIndex, oldData, newData);
                }
            }
 
            inline static bool equal (std::size_t index, const void* data, const void* otherData)
            {
                if (index == sizeof... (Ts))
                {
                    return *reinterpret_cast <const First *> (data) == *reinterpret_cast <const First *> (otherData);
                }
                else
                {
                    return VariantHelper <Ts...>::equal (index, data, otherData);
                }
            }
 
            template <typename T = First, typename std::enable_if_t <!std::is_null_pointer <T>::value>* = nullptr>
            inline static bool lower (std::size_t index, const void* data, const void* otherData)
            {
                if (index == sizeof... (Ts))
                {
                    return *reinterpret_cast <const First *> (data) < *reinterpret_cast <const First *> (otherData);
                }
                else
                {
                    return VariantHelper <Ts...>::lower (index, data, otherData);
                }
            }
 
            template <typename T = First, typename std::enable_if_t <std::is_null_pointer <T>::value>* = nullptr>
            inline static bool lower (std::size_t index, const void* data, const void* otherData)
            {
                if (index == sizeof... (Ts))
                {
                    return false;
                }
                else
                {
                    return VariantHelper <Ts...>::lower (index, data, otherData);
                }
            }
        };
 
        template <typename... Ts>
        struct VariantStorage
        {
            constexpr VariantStorage () noexcept
            : 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 (sizeof... (Ts) - I - 1)
            {
                new (storage ()) find_element_t <I, Ts...> (std::forward <Args> (args)...);
            }
 
            ~VariantStorage ()
            {
                VariantHelper <Ts...>::destroy (_which, storage ());
            }
 
            constexpr VariantStorage& operator= (const VariantStorage& other)
            {
                VariantHelper <Ts...>::destroy (_which, storage ());
                VariantHelper <Ts...>::copy (other._which, other.storage (), storage ());
                _which = other._which;
                return *this;
            }
 
            constexpr VariantStorage& operator= (VariantStorage&& other) noexcept
            {
                VariantHelper <Ts...>::destroy (_which, storage ());
                VariantHelper <Ts...>::move (other._which, other.storage (), storage ());
                _which = other._which;
                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));
            }
 
            typename std::aligned_union <std::max ({sizeof (Ts)...}), Ts...>::type _data;
 
            std::size_t _which = sizeof... (Ts) - 1;
        };
    }
 
    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) noexcept
        : 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 {})
        {
        }
 
        virtual ~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) noexcept
        {
            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 sizeof... (Ts) - this->_which - 1;
        }
 
    protected:
        constexpr bool equal (const Variant& rhs) const
        {
            if (index () != rhs.index ())
            {
                return false;
            }
            return details::VariantHelper <Ts...>::equal (this->_which, 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 (this->_which, 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);
    }
}
 
#pragma GCC diagnostic pop
 
#endif