static_storage.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <memory>
#include <utility>
 
namespace emlabcpp
{
 
template < typename T, std::size_t N >
struct static_storage
{
        static constexpr std::size_t capacity = N;
 
        using value_type      = T;
        using reference       = T&;
        using const_reference = T const&;
        using pointer         = T*;
        using const_pointer   = T const*;
        using size_type       = std::size_t;
 
        [[nodiscard]] constexpr pointer data() noexcept
        {
                return reinterpret_cast< pointer >( data_ );
        }
 
        [[nodiscard]] constexpr const_pointer data() const noexcept
        {
                return reinterpret_cast< const_pointer >( data_ );
        }
 
        template < typename... Args >
        constexpr T& emplace_item( size_type const i, Args&&... args ) noexcept(
            std::is_nothrow_constructible_v< T, Args... > )
        {
                return *std::construct_at( data() + i, std::forward< Args >( args )... );
        }
 
        constexpr void
        delete_item( size_type const i ) noexcept( std::is_nothrow_destructible_v< T > )
        {
                std::destroy_at( data() + i );
        }
 
        [[nodiscard]] constexpr reference operator[]( size_type const i ) noexcept
        {
                return *( data() + i );
        }
 
        [[nodiscard]] constexpr const_reference operator[]( size_type const i ) const noexcept
        {
                return *( data() + i );
        }
 
private:
        alignas( T ) std::byte data_[N * sizeof( T )];
};
 
template < typename T >
concept trivial_for_static_storage =
    std::is_trivially_default_constructible_v< T > && std::is_trivially_destructible_v< T >;
 
template < typename T, std::size_t N >
requires( trivial_for_static_storage< T > )
struct static_storage< T, N >
{
        static constexpr std::size_t capacity = N;
 
        using value_type      = T;
        using reference       = T&;
        using const_reference = T const&;
        using pointer         = T*;
        using const_pointer   = T const*;
        using size_type       = std::size_t;
 
        [[nodiscard]] constexpr pointer data() noexcept
        {
                return data_;
        }
 
        [[nodiscard]] constexpr const_pointer data() const noexcept
        {
                return data_;
        }
 
        template < typename... Args >
        constexpr T& emplace_item( size_type const i, Args&&... args ) noexcept(
            std::is_nothrow_constructible_v< T, Args... > )
        {
                data_[i] = T{ std::forward< Args >( args )... };
                return data_[i];
        }
 
        constexpr void
        delete_item( size_type const i ) noexcept( std::is_nothrow_destructible_v< T > )
        {
                data_[i] = T{};
        }
 
        [[nodiscard]] constexpr reference operator[]( size_type const i ) noexcept
        {
                return data_[i];
        }
 
        [[nodiscard]] constexpr const_reference operator[]( size_type const i ) const noexcept
        {
                return data_[i];
        }
 
private:
        T data_[N];
};
}  // namespace emlabcpp