uvref.h

 
 
#pragma once
 
#include "vari/bits/assert.h"
#include "vari/bits/ptr_core.h"
#include "vari/bits/typelist.h"
#include "vari/bits/util.h"
#include "vari/deleter.h"
#include "vari/forward.h"
#include "vari/vptr.h"
#include "vari/vref.h"
 
 
namespace vari
{
 
template < typename Deleter, typename... Ts >
class _uvref : private _deleter_box< Deleter >
{
        template < typename... Us >
        using same_uvref = _uvref< Deleter, Us... >;
        using dbox       = _deleter_box< Deleter >;
 
public:
        using types = typelist< Ts... >;
 
        using core_type      = _ptr_core< types >;
        using reference      = _vref< Ts... >;
        using pointer        = _vptr< Ts... >;
        using owning_pointer = _uvptr< Deleter, Ts... >;
 
        constexpr _uvref( _uvref const& )            = delete;
        constexpr _uvref& operator=( _uvref const& ) = delete;
 
        template < typename Deleter2, typename... Us >
                requires(
                    vconvertible_to< typelist< Us... >, types > &&
                    convertible_deleter< Deleter2, Deleter > )
        constexpr _uvref( _uvref< Deleter2, Us... >&& p ) noexcept
          : dbox( std::move( (dbox&) p ) )
        {
                _core = std::move( p._core );
                p._core.reset();
        }
 
        template < typename U >
                requires( vconvertible_type< U, types > )
        constexpr explicit _uvref( U& u ) noexcept
        {
                _core.set( u );
        }
 
        template < typename U >
                requires( vconvertible_type< U, types > && copy_constructible_deleter< Deleter > )
        constexpr explicit _uvref( U& u, Deleter const& d ) noexcept
          : dbox( d )
        {
                _core.set( u );
        }
 
        template < typename U >
                requires( vconvertible_type< U, types > && move_constructible_deleter< Deleter > )
        constexpr explicit _uvref( U& u, Deleter&& d ) noexcept
          : dbox( std::move( d ) )
        {
                _core.set( u );
        }
 
        template < typename Deleter2, typename... Us >
                requires(
                    vconvertible_to< typelist< Us... >, types > &&
                    convertible_deleter< Deleter2, Deleter > )
        constexpr _uvref& operator=( _uvref< Deleter2, Us... >&& p ) noexcept
        {
                _uvref tmp{ std::move( p ) };
                swap( _core, tmp._core );
                swap( (dbox&) ( *this ), (dbox&) tmp );
                return *this;
        }
 
        constexpr auto& operator*() const noexcept
        {
                return *_core.ptr;
        }
 
        constexpr auto* operator->() const noexcept
        {
                return _core.ptr;
        }
 
        constexpr reference get() const noexcept
        {
                VARI_ASSERT( _core.ptr );
                reference res;
                res._core = _core;
                return res;
        }
 
        [[nodiscard]] constexpr index_type index() const noexcept
        {
                VARI_ASSERT( _core.ptr );
                return _core.index;
        }
 
        template < typename... Us >
                requires( vconvertible_to< types, typelist< Us... > > )
        constexpr operator _vref< Us... >() & noexcept
        {
                VARI_ASSERT( _core.ptr );
                return vptr().vref();
        }
        template < typename... Us >
                requires( vconvertible_to< types, typelist< Us... > > )
        constexpr operator _vref< Us... >() const& noexcept
        {
                VARI_ASSERT( _core.ptr );
                return vptr().vref();
        }
 
        template < typename... Us >
        constexpr operator _vref< Us... >() && = delete;
 
        constexpr pointer vptr() const& noexcept
        {
                VARI_ASSERT( _core.ptr );
                pointer res;
                res._core = _core;
                return res;
        }
 
        constexpr owning_pointer vptr() && noexcept
        {
                VARI_ASSERT( _core.ptr );
                owning_pointer res;
                swap( res._core, _core );
                return res;
        }
 
        template < typename... Fs >
        constexpr decltype( auto ) visit( Fs&&... f ) const
        {
                typename _check_unique_invocability< types >::template with_pure_ref< Fs... > _{};
                VARI_ASSERT( _core.ptr );
                return _core.visit_impl( (Fs&&) f... );
        }
 
        template < typename... Fs >
        constexpr decltype( auto ) take( Fs&&... fs ) &&
        {
                typename _check_unique_invocability< types >::template with_deleter<
                    Deleter >::template with_uvref< Fs... >
                    _{};
                VARI_ASSERT( _core.ptr );
                auto tmp = _core;
                _core.reset();
                return tmp.template take_impl< same_uvref >( (Fs&&) fs... );
        }
 
        Deleter& get_deleter() noexcept
        {
                return dbox::get();
        }
 
        Deleter const& get_deleter() const noexcept
        {
                return dbox::get();
        }
 
 
        constexpr ~_uvref()
        {
                _core.delete_ptr( dbox::get() );
        }
 
        friend constexpr void swap( _uvref& lh, _uvref& rh ) noexcept
        {
                swap( lh._core, rh._core );
                swap( (dbox&) lh, (dbox&) rh );
        }
 
private:
        constexpr _uvref() noexcept = default;
 
        core_type _core;
 
        template < typename... Us >
        friend class _vptr;
 
        template < typename Deleter2, typename... Us >
        friend class _uvptr;
 
        template < typename Deleter2, typename... Us >
        friend class _uvref;
};
 
template < typename... Lhs, typename... Rhs >
constexpr auto operator<=>( _uvref< Lhs... > const& lh, _uvref< Rhs... > const& rh ) noexcept
{
        return lh.get() <=> rh.get();
}
 
template < typename... Lhs, typename... Rhs >
constexpr bool operator==( _uvref< Lhs... > const& lh, _uvref< Rhs... > const& rh ) noexcept
{
        return lh.get() == rh.get();
}
 
template < typename... Ts >
using uvref = _define_variadic< _uvref, typelist< Ts... >, def_del >;
 
template < typename T >
constexpr uvref< T > uwrap( T item )
{
        return uvref< T >( *new T( std::move( item ) ) );
}
 
}  // namespace vari
 
VARI_REC_GET_HASH_SPECIALIZATION( vari::_uvref );