variant.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <variant>
#include <compare>
 
#include <ext/ostream>
 
#include <extensions/typeindex.h>
#include <extensions/type_traits.hpp>
#include <extensions/concepts.hpp>
 
namespace ext {
 
template < class Visitor, class... Variants >
constexpr auto visit ( Visitor && vis, Variants && ... vars ) {
    return std::visit ( std::forward < Visitor > ( vis ), std::forward < Variants > ( vars ).asStdVariant ( ) ... );
}
 
template < class Res, class ... Ts >
struct variant_builder_impl {
};
 
template < class ... ResTs >
struct variant_builder_impl < std::variant < ResTs ... > > {
    typedef std::variant < ResTs ... > std_variant;
 
    template < class T >
    using index_in = ext::index_in < T, ResTs ... >;
};
 
template < class ... ResTs, class T, class ... Ts >
struct variant_builder_impl < std::variant < ResTs ... >, T, Ts ... > : public variant_builder_impl < typename std::conditional < is_in < T, ResTs ... >::value, std::variant < ResTs ... >, std::variant < ResTs ..., T > >::type, Ts ... > {
};
 
template < class T, class ... Ts >
struct variant_builder_start : public variant_builder_impl < std::variant < T >, Ts ... > {
};
 
template < class ... Ts >
using std_variant = typename variant_builder_start < Ts ... >::std_variant;
 
template < typename ... Ts >
class variant : public std_variant < Ts ... > {
 
    template < class Visitor, class... Variants >
    friend constexpr auto visit ( Visitor && vis, Variants && ... vars );
 
    class VariantToStream {
        ext::ostream & m_out;
    public:
        explicit VariantToStream ( ext::ostream & out ) : m_out ( out ) {
        }
 
        template < class T >
        void operator ( ) ( const T & value ) {
            m_out << value;
        }
    };
 
    typedef std_variant < Ts ... > base;
 
    const base & asStdVariant ( ) const & {
        return * this;
    }
 
    base & asStdVariant ( ) & {
        return * this;
    }
 
    base && asStdVariant ( ) && {
        return std::move ( * this );
    }
 
public:
    using std_variant < Ts ... >::std_variant; // NOLINT(modernize-use-equals-default)
 
    using std_variant < Ts ... >::operator=;
#ifndef __clang__
 
    variant ( ) = default;
 
    variant ( const variant & other ) = default;
 
    variant ( variant && other ) = default;
 
    variant & operator = ( variant && other ) = default;
 
    variant & operator = ( const variant & other ) = default;
#endif
 
    template < typename T >
    bool is() const {
        return std::holds_alternative < T > ( * this );
    }
 
    template < typename T >
    requires ( ext::Included < std::decay_t < T >, Ts ... > )
    void set ( T && value ) {
        * this = std::forward < T > ( value );
    }
 
    template < typename T >
    T & get ( ) & {
        return std::get < T > ( * this );
    }
 
    template<typename T >
    const T & get ( ) const & {
        return std::get < T > ( * this );
    }
 
    template < typename T >
    T && get ( ) && {
        return std::move ( std::get < T > ( * this ) );
    }
 
    template < class Result, class Callable >
    Result call ( Callable callable ) const {
        return ext::visit ( callable, * this );
    }
 
    friend ext::ostream & operator << ( ext::ostream & out, const variant < Ts ... > & obj ) {
        obj.call < void > ( VariantToStream ( out ) );
        return out;
    }
 
    template < ext::Included < Ts ... > T >
    auto operator <=> ( const T & other ) const {
        auto indexRes = this->index ( ) <=> variant_builder_start < Ts ... >::template index_in < T >::value;
        if ( indexRes != 0 )
            return indexRes;
 
        return this->template get < T > ( ) <=> other;
    }
 
    template < ext::Included < Ts ... > T >
    bool operator == ( const T & other ) const {
        auto indexRes = this->index ( ) == variant_builder_start < Ts ... >::template index_in < T >::value;
        if ( ! indexRes )
            return indexRes;
 
        return this->template get < T > ( ) == other;
    }
};
 
} /* namespace ext */
 
namespace std {
 
template < class ... Types >
struct variant_size < ext::variant < Types ... > > : public variant_size < typename ext::variant < Types ... >::std_variant > { };
 
template < size_t Np, typename ... Types >
struct variant_alternative < Np, ext::variant < Types ... > > {
    using type = variant_alternative_t < Np, typename ext::variant < Types ... >::std_variant >;
};
 
}