vref.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 "vari/vptr.h"
 
namespace vari
{
 
template < typename... Ts >
class _vref
{
public:
        using types     = typelist< Ts... >;
        using pointer   = _vptr< Ts... >;
        using reference = _vref< Ts... >;
 
        template < typename... Us >
                requires( vconvertible_to< typelist< Us... >, types > )
        constexpr _vref( _vref< Us... > const& p ) noexcept
          : _core( p._core )
        {
        }
 
        template < typename U >
                requires( vconvertible_to< typelist< U >, types > )
        constexpr _vref( U& u ) noexcept
        {
                _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();
        }
 
        template < typename U >
                requires( vconvertible_to< types, typelist< U > > )
        constexpr operator U&() const noexcept
        {
                return *_core.ptr;
        }
 
        constexpr pointer vptr() const& noexcept
        {
                pointer res;
                res._core = _core;
                return res;
        }
 
        template < typename... Fs >
        constexpr decltype( auto ) visit( Fs&&... fs ) const
        {
                typename _check_unique_invocability< types >::template with_pure_ref< Fs... > _{};
                VARI_ASSERT( _core.ptr );
                return _core.visit_impl( (Fs&&) fs... );
        }
 
        friend constexpr void swap( _vref& lh, _vref& rh ) noexcept
        {
                swap( lh._core, rh._core );
        }
 
private:
        constexpr _vref() noexcept = default;
 
        _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<=>( _vref< Lhs... > const& lh, _vref< Rhs... > const& rh ) noexcept
{
        return lh.get() <=> rh.get();
}
 
template < typename... Lhs, typename... Rhs >
constexpr bool operator==( _vref< Lhs... > const& lh, _vref< Rhs... > const& rh ) noexcept
{
        return lh.get() == rh.get();
}
 
 
template < typename... Ts >
using vref = _define_variadic< _vref, typelist< Ts... > >;
 
}  // namespace vari
 
VARI_GET_PTR_HASH_SPECIALIZATION( vari::_vref );