sbo_poly.h

Go to the documentation of this file.

/**
 
    @file      sbo_poly.h
    @author    Khrapov
    @date      20.12.2025
    @copyright (c) Nick Khrapov, 2025. All right reserved.
 
**/
#pragma once
 
#include <qx/memory/sbo_bytes.h>
 
#include <exception>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>
 
namespace qx
{
 
// Check that the derived type is suitable for storing in sbo_poly
template<class T, class base_t>
concept sbo_poly_assignable_c =
    std::is_base_of_v<base_t, std::remove_cvref_t<T>> && std::is_nothrow_move_constructible_v<std::remove_cvref_t<T>>
    && std::is_nothrow_destructible_v<std::remove_cvref_t<T>> && std::is_constructible_v<std::remove_cvref_t<T>, T&&>;
 
// Check that the derived type fits into the SBO buffer
template<class sbo_poly_t, sbo_poly_assignable_c<typename sbo_poly_t::base_type> derived_t>
struct sbo_poly_fittable_type
{
    static constexpr size_t nAlignmentPadding =
        alignof(derived_t) <= alignof(typename sbo_poly_t::sbo_bytes_type) ? 0 : alignof(derived_t) - 1;
    static constexpr bool value = sizeof(derived_t) + nAlignmentPadding <= sbo_poly_t::sbo_bytes_type::nBufferSize;
};
 
template<class sbo_poly_t, sbo_poly_assignable_c<typename sbo_poly_t::base_type> derived_t>
constexpr bool sbo_poly_fittable_type_v = sbo_poly_fittable_type<sbo_poly_t, derived_t>::value;
 
// If you have several inheritors, you can check that they all fit into your SBO
template<class sbo_poly_t, class... args_t>
struct sbo_poly_fittable_types
{
    static constexpr bool value = ((sbo_poly_fittable_type_v<sbo_poly_t, args_t>) && ...);
};
 
template<class sbo_poly_t, class... args_t>
constexpr bool sbo_poly_fittable_types_v = sbo_poly_fittable_types<sbo_poly_t, args_t...>::value;
 
/**
 
    @class   sbo_poly
    @brief   Small Buffer Object for polymorphic classes.
    @details If the inherited class fits into the specified buffer, it stores it in place;
             if not, it allocates memory for it.
             Allows you to increase cache locality when storing in containers.
    @tparam  base_t    - base class type, you'll be able to work with each element through its interface
    @tparam  nSBOSize_ - the size of the whole SBO type, including internal data
    @author  Khrapov
    @date    24.12.2025
 
**/
template<class base_t, size_t nSBOSize_>
    requires(nSBOSize_ > sizeof(void*))
class sbo_poly
{
    struct sbo_poly_traits
    {
        using size_type                                  = size_t;
        static constexpr size_type nSBOSize              = nSBOSize_ - sizeof(void*);
        static constexpr bool      bShrinkToFitWhenSmall = true;
        static constexpr bool      bPreserveContents     = false;
        static constexpr size_type growth_strategy(size_type nOldCapacity) noexcept
        {
            return nOldCapacity;
        }
    };
 
public:
    using sbo_bytes_type = sbo_bytes<sbo_poly_traits>;
    using base_type      = base_t;
 
private:
    struct operations
    {
        base_t* (*Get)(sbo_bytes_type& object) noexcept;
        void (*Move)(sbo_bytes_type& from, sbo_bytes_type& to) noexcept;
        void (*Destroy)(sbo_bytes_type& object) noexcept;
    };
 
public:
    /**
        @brief  sbo_poly object constructor
        @tparam derived_t - type inherited from base_t
        @param  object    - an object to store
    **/
    template<sbo_poly_assignable_c<base_t> derived_t>
    sbo_poly(derived_t&& object);
 
    sbo_poly(sbo_poly&& other) noexcept;
    ~sbo_poly() noexcept;
 
    /**
        @brief  operator=
        @tparam derived_t - type inherited from base_t
        @param  object    - an object to store
        @retval           - this object reference
    **/
    template<sbo_poly_assignable_c<base_t> derived_t>
    sbo_poly& operator=(derived_t&& object);
 
    sbo_poly& operator=(sbo_poly&& other) noexcept;
 
    /**
        @brief  Assign a new object to this SBO
        @tparam derived_t - type inherited from base_t
        @param  object    - an object to store
    **/
    template<sbo_poly_assignable_c<base_t> derived_t>
    void assign(derived_t&& object);
 
 
    base_t*       operator->() noexcept;
    const base_t* operator->() const noexcept;
 
    /**
        @brief  Get object reference. Always valid.
        @retval  - object reference
    **/
    base_t& get() noexcept;
 
    /**
        @brief  Get object reference. Always valid.
        @retval  - object reference
    **/
    const base_t& get() const noexcept;
 
private:
    /**
        @brief  Get type operations table
        @tparam derived_t - type inherited from base_t
        @retval           - operations
    **/
    template<sbo_poly_assignable_c<base_t> derived_t>
    static const operations& get_operations() noexcept;
 
    /**
        @brief  Get the number of bytes required to store an object with proper alignment
        @tparam derived_t - type inherited from base_t
        @retval           - object size plus the worst-case alignment padding when required
    **/
    template<sbo_poly_assignable_c<base_t> derived_t>
    static constexpr size_t get_storage_size() noexcept;
 
    /**
        @brief  Get a properly aligned pointer to an object in the storage
        @tparam derived_t - type inherited from base_t
        @param  data      - storage containing the object
        @retval           - aligned pointer to the object
    **/
    template<sbo_poly_assignable_c<base_t> derived_t>
    static derived_t* get_object(sbo_bytes_type& data) noexcept;
 
private:
    sbo_bytes_type    m_Data;
    const operations* m_Operations = nullptr;
};
 
} // namespace qx
 
#include <qx/memory/sbo_poly.inl>