vptr.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/forward.h"
 
#include <cstddef>
 
namespace vari
{
 
 
template < typename... Ts >
class _vptr
{
public:
        using types = typelist< Ts... >;
 
        using reference = _vref< Ts... >;
 
        constexpr _vptr()                              = default;
        constexpr _vptr( _vptr const& )                = default;
        constexpr _vptr( _vptr&& ) noexcept            = default;
        constexpr _vptr& operator=( _vptr const& )     = default;
        constexpr _vptr& operator=( _vptr&& ) noexcept = default;
 
        constexpr _vptr( std::nullptr_t ) noexcept
        {
        }
 
        template < typename... Us >
                requires( vconvertible_to< typelist< Us... >, types > )
        constexpr explicit _vptr( _vref< Us... > const& r ) noexcept
          : _core( r._core )
        {
        }
 
        template < typename... Us >
                requires( vconvertible_to< typelist< Us... >, types > )
        constexpr _vptr( _vptr< Us... > const& p ) noexcept
          : _core( p._core )
        {
        }
 
        template < typename U >
                requires( vconvertible_to< typelist< U >, types > )
        constexpr _vptr( U* u ) noexcept
        {
                if ( u )
                        _core.set( *u );
        }
 
        constexpr auto& operator*() const noexcept
        {
                return *_core.ptr;
        }
 
        constexpr auto* operator->() const noexcept
        {
                return _core.ptr;
        }
 
        constexpr auto* get() const noexcept
        {
                return _core.ptr;
        }
 
        [[nodiscard]] constexpr index_type index() const noexcept
        {
                return _core.get_index();
        }
 
        constexpr explicit operator bool() const noexcept
        {
                return _core.ptr != nullptr;
        }
 
        constexpr reference vref() const noexcept
        {
                VARI_ASSERT( _core.ptr );
 
                reference r;
                r._core = _core;
                return r;
        }
 
        template < typename... Fs >
        constexpr decltype( auto ) visit( Fs&&... fs ) const
        {
                typename _check_unique_invocability< types >::template with_nullable_pure_ref<
                    Fs... >
                    _{};
                if ( _core.ptr == nullptr )
                        return _dispatch_fun( empty, (Fs&&) fs... );
                return _core.visit_impl( (Fs&&) fs... );
        }
 
 
        friend constexpr void swap( _vptr& lh, _vptr& rh ) noexcept
        {
                swap( lh._core, rh._core );
        }
 
private:
        _ptr_core< types > _core;
 
        template < typename... Us >
        friend class _vref;
        template < typename... Us >
        friend class _vptr;
        template < typename Deleter, typename... Us >
        friend class _uvref;
        template < typename Deleter, typename... Us >
        friend class _uvptr;
};
 
template < typename... Lhs, typename... Rhs >
constexpr auto operator<=>( _vptr< Lhs... > const& lh, _vptr< Rhs... > const& rh ) noexcept
{
        return lh.get() <=> rh.get();
}
 
template < typename... Lhs, typename... Rhs >
constexpr bool operator==( _vptr< Lhs... > const& lh, _vptr< Rhs... > const& rh ) noexcept
{
        return lh.get() == rh.get();
}
 
template < typename... Ts >
using vptr = _define_variadic< _vptr, typelist< Ts... > >;
 
}  // namespace vari
 
VARI_GET_PTR_HASH_SPECIALIZATION( vari::_vptr );