derived_storage.h

Go to the documentation of this file.

 
#pragma once
 
#include "./pmr/util.h"
 
#include <concepts>
#include <memory>
 
namespace emlabcpp
{
 
template < typename T, std::size_t N >
class derived_storage
{
public:
        static_assert(
            std::has_virtual_destructor_v< T >,
            "Type stored in derived_storage has to have a virtual destructor" );
 
        using storage_type = std::byte[N];
 
        using base_type = T;
 
        derived_storage()
          : ptr_( nullptr )
        {
        }
 
        template < std::derived_from< T > U >
        derived_storage( U&& item )
          : ptr_( &storage_ )
        {
                static_assert( is_storable_with_align< U >( N ) );
                ptr_ = align( ptr_, alignof( U ) );
                std::construct_at( ptr_, std::forward< U >( item ) );
        }
 
        derived_storage( derived_storage const& ) = delete;
        derived_storage( derived_storage&& )      = delete;
 
        derived_storage& operator=( derived_storage const& ) = delete;
        derived_storage& operator=( derived_storage&& )      = delete;
 
        T& operator*()
        {
                return *ptr_;
        }
 
        T const& operator*() const
        {
                return *ptr_;
        }
 
        T* operator->()
        {
                return ptr_;
        }
 
        T const* operator->() const
        {
                return ptr_;
        }
 
        operator bool() const
        {
                return ptr_ != nullptr;
        }
 
        T& get()
        {
                return *ptr_;
        }
 
        T const& get() const
        {
                return *ptr_;
        }
 
        ~derived_storage()
        {
                std::destroy_at( ptr_ );
        }
 
private:
        T*           ptr_;
        storage_type storage_;
};
 
}  // namespace emlabcpp