static_storage.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstring>
#include <memory>
#include <utility>
 
namespace emlabcpp
{
 
struct static_storage_base
{
        template < typename F, typename T >
        static F _copy_n( F first, std::size_t n, T* dest )
        {
                if constexpr ( std::is_trivially_copy_constructible_v< T > ) {
                        std::memcpy( dest, &*first, n * sizeof( T ) );
                        std::advance(
                            first,
                            static_cast< typename std::iterator_traits< F >::difference_type >(
                                n ) );
                        return first;
                } else {
                        for ( std::size_t i = 0; i < n; ++i, ++first, ++dest )
                                ::new ( dest ) T( *first );
                        return first;
                }
        }
 
        template < typename F, typename T >
        static F _move_n( F first, std::size_t n, T* dest )
        {
                if constexpr ( std::is_trivially_move_constructible_v< T > ) {
                        std::memcpy( dest, &*first, n * sizeof( T ) );
                        std::advance(
                            first,
                            static_cast< typename std::iterator_traits< F >::difference_type >(
                                n ) );
                        return first;
                } else {
                        for ( std::size_t i = 0; i < n; ++i, ++first, ++dest )
                                ::new ( dest ) T( std::move( *first ) );
                        return first;
                }
        }
};
 
template < typename T, std::size_t N >
struct static_storage : static_storage_base
{
        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 auto copy_n( size_type const i, size_type const n, auto iter ) noexcept(
            std::is_nothrow_copy_constructible_v< T > )
        {
                return static_storage_base::_copy_n( iter, n, data() + i );
        }
 
        constexpr auto move_n( size_type const i, size_type const n, auto iter ) noexcept(
            std::is_nothrow_move_constructible_v< T > )
        {
                return static_storage_base::_move_n( iter, n, data() + i );
        }
 
        constexpr void delete_n( size_type const i, size_type const n ) noexcept(
            std::is_nothrow_destructible_v< T > )
        {
                for ( size_type j = 0; j < n; ++j )
                        std::destroy_at( data() + i + j );
        }
 
        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 auto copy_n( size_type const i, size_type const n, auto iter ) noexcept(
            std::is_nothrow_copy_constructible_v< T > )
        {
                return static_storage_base::_copy_n( iter, n, data() + i );
        }
 
        constexpr auto move_n( size_type const i, size_type const n, auto iter ) noexcept(
            std::is_nothrow_move_constructible_v< T > )
        {
                return static_storage_base::_move_n( iter, n, data() + i );
        }
 
        constexpr void delete_n( size_type const, size_type const ) noexcept
        {
        }
 
        constexpr void delete_item( size_type const ) noexcept
        {
        }
 
        [[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