uvptr.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 <cstddef>
 
namespace vari
{
 
template < typename Deleter, typename... Ts >
class _uvptr : 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 pointer          = _vptr< Ts... >;
        using reference        = _vref< Ts... >;
        using owning_reference = _uvref< Deleter, Ts... >;
 
        constexpr _uvptr() noexcept = default;
 
        constexpr _uvptr( _uvptr const& )            = delete;
        constexpr _uvptr& operator=( _uvptr const& ) = delete;
 
        constexpr _uvptr( std::nullptr_t ) noexcept
        {
        }
 
        template < typename Deleter2, typename... Us >
                requires(
                    vconvertible_to< typelist< Us... >, types > &&
                    convertible_deleter< Deleter2, Deleter > )
        constexpr explicit _uvptr( _uvref< Deleter2, Us... >&& p ) noexcept
        {
                _core = std::move( p._core );
                p._core.reset();
        }
 
        template < typename Deleter2, typename... Us >
                requires(
                    vconvertible_to< typelist< Us... >, types > &&
                    convertible_deleter< Deleter2, Deleter > )
        constexpr _uvptr( _uvptr< 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 _uvptr( U* u ) noexcept
        {
                if ( u )
                        _core.set( *u );
        }
 
        template < typename U >
                requires( vconvertible_type< U, types > && copy_constructible_deleter< Deleter > )
        constexpr _uvptr( U* u, Deleter const& d ) noexcept
          : dbox( d )
        {
                if ( u )
                        _core.set( *u );
        }
 
        template < typename U >
                requires( vconvertible_type< U, types > && move_constructible_deleter< Deleter > )
        constexpr _uvptr( U* u, Deleter&& d ) noexcept
          : dbox( std::move( d ) )
        {
                if ( u )
                        _core.set( *u );
        }
 
 
        constexpr _uvptr& operator=( std::nullptr_t ) noexcept
        {
                reset( nullptr );
                return *this;
        }
 
        template < typename Deleter2, typename... Us >
                requires(
                    vconvertible_to< typelist< Us... >, types > &&
                    convertible_deleter< Deleter2, Deleter > )
        constexpr _uvptr& operator=( _uvptr< Deleter2, Us... >&& p ) noexcept
        {
                _uvptr 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 pointer get() const noexcept
        {
                pointer res;
                res._core = _core;
                return res;
        }
 
        [[nodiscard]] constexpr index_type index() const noexcept
        {
                return _core.get_index();
        }
 
        template < typename... Us >
                requires( vconvertible_to< types, typelist< Us... > > )
        constexpr operator _vptr< Us... >() & noexcept
        {
                _vptr< Us... > res;
                res._core = _core;
                return res;
        }
 
        template < typename... Us >
                requires( vconvertible_to< types, typelist< Us... > > )
        constexpr operator _vptr< Us... >() const& noexcept
        {
                _vptr< Us... > res;
                res._core = _core;
                return res;
        }
 
        template < typename... Us >
        constexpr operator _vptr< Us... >() && = delete;
 
        constexpr void reset( pointer ptr = pointer() )
        {
                auto tmp = _core;
                _core    = std::move( ptr._core );
                tmp.delete_ptr( _deleter_box< Deleter >::get() );
        }
 
        constexpr pointer release() noexcept
        {
                pointer res;
                swap( res._core, _core );
                return res;
        }
 
        constexpr explicit operator bool() const noexcept
        {
                return _core.get_index() != null_index;
        }
 
        constexpr reference vref() const& noexcept
        {
                VARI_ASSERT( _core.get_index() != null_index );
                reference res;
                res._core = _core;
                return res;
        }
 
        constexpr owning_reference vref() && noexcept
        {
                VARI_ASSERT( _core.get_index() != null_index );
                owning_reference res;
                swap( res._core, _core );
                return res;
        }
 
        template < typename... Fs >
        constexpr decltype( auto ) visit( Fs&&... f ) const
        {
 
                typename _check_unique_invocability< types >::template with_nullable_pure_ref<
                    Fs... >
                    _{};
                if ( _core.ptr == nullptr )
                        return _dispatch_fun( empty, (Fs&&) f... );
                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_nullable_uvref< Fs... >
                     _{};
                auto p = release();
                if ( p._core.ptr == nullptr )
                        return _dispatch_fun( empty, (Fs&&) fs... );
                return p._core.template take_impl< same_uvref >( (Fs&&) fs... );
        }
 
        Deleter& get_deleter() noexcept
        {
                return dbox::get();
        }
 
        Deleter const& get_deleter() const noexcept
        {
                return dbox::get();
        }
 
        constexpr ~_uvptr()
        {
                _core.delete_ptr( _deleter_box< Deleter >::get() );
        }
 
        friend constexpr void swap( _uvptr& lh, _uvptr& rh ) noexcept
        {
                swap( lh._core, rh._core );
                swap( (dbox&) lh, (dbox&) rh );
        }
 
private:
        core_type _core;
 
        template < typename Deleter2, typename... Us >
        friend class _uvptr;
 
        template < typename Deleter2, typename... Us >
        friend class _uvref;
};
 
template < typename... Lhs, typename... Rhs >
constexpr auto operator<=>( _uvptr< Lhs... > const& lh, _uvptr< Rhs... > const& rh ) noexcept
{
        return lh.get() <=> rh.get();
}
 
template < typename... Lhs, typename... Rhs >
constexpr bool operator==( _uvptr< Lhs... > const& lh, _uvptr< Rhs... > const& rh ) noexcept
{
        return lh.get() == rh.get();
}
 
template < typename... Ts >
using uvptr = _define_variadic< _uvptr, typelist< Ts... >, def_del >;
 
}  // namespace vari
 
VARI_REC_GET_HASH_SPECIALIZATION( vari::_uvptr );