fsb_work.h

 
#ifndef FSB_WORK_H
#define FSB_WORK_H
 
#include <array>
#include <cstddef>
#include <cstdint>
 
namespace fsb
{
 
enum class WorkArrayStatus : uint8_t
{
    SUCCESS = 0,
    FULL,
    INVALID_ARGUMENT,
    OUT_OF_ORDER
};
 
template <typename T> struct WorkBlock
{
    T* data = nullptr;
    size_t size = 0;
    size_t offset = 0;
 
    [[nodiscard]] explicit operator bool() const noexcept
    {
        return (data != nullptr) && (size > 0U);
    }
};
 
template <typename T, size_t Capacity> class WorkArray final
{
public:
    WorkArray() = default;
 
    static constexpr size_t get_capacity() noexcept
    {
        return Capacity;
    }
 
    [[nodiscard]] size_t get_used() const noexcept
    {
        return m_top;
    }
 
    [[nodiscard]] size_t get_remaining() const noexcept
    {
        return Capacity - get_used();
    }
 
    [[nodiscard]] T* data() noexcept
    {
        return m_data.data();
    }
 
    [[nodiscard]] const T* data() const noexcept
    {
        return m_data.data();
    }
 
    void reset() noexcept
    {
        m_top = 0U;
    }
 
    [[nodiscard]] size_t get_marker() const noexcept
    {
        return m_top;
    }
 
    WorkArrayStatus restore(size_t marker) noexcept
    {
        if (marker > m_top)
        {
            return WorkArrayStatus::INVALID_ARGUMENT;
        }
        m_top = marker;
        return WorkArrayStatus::SUCCESS;
    }
 
    WorkArrayStatus allocate(size_t len, WorkBlock<T>& out) noexcept
    {
        out = {};
        if ((len == 0U) || (len > Capacity))
        {
            return WorkArrayStatus::INVALID_ARGUMENT;
        }
        if ((m_top + len) > Capacity)
        {
            return WorkArrayStatus::FULL;
        }
 
        out.offset = m_top;
        out.data = &m_data[m_top];
        out.size = len;
        m_top += len;
        return WorkArrayStatus::SUCCESS;
    }
 
    WorkArrayStatus deallocate(T* ptr, size_t len) noexcept
    {
        if ((ptr == nullptr) || (len == 0U) || (len > Capacity))
        {
            return WorkArrayStatus::INVALID_ARGUMENT;
        }
 
        T* const begin = m_data.data();
        T* const end = m_data.data() + Capacity;
        if ((ptr < begin) || (ptr >= end))
        {
            return WorkArrayStatus::INVALID_ARGUMENT;
        }
 
        const size_t start = static_cast<size_t>(ptr - begin);
        if ((start + len) > Capacity)
        {
            return WorkArrayStatus::INVALID_ARGUMENT;
        }
 
        // Strict LIFO: must free from the current top of stack.
        if ((start + len) != m_top)
        {
            return WorkArrayStatus::OUT_OF_ORDER;
        }
 
        m_top = start;
        return WorkArrayStatus::SUCCESS;
    }
 
    WorkArrayStatus deallocate(const WorkBlock<T>& block) noexcept
    {
        return deallocate(block.data, block.size);
    }
 
private:
    std::array<T, Capacity> m_data = {};
    size_t m_top = 0U;
};
 
template <typename T, size_t Capacity> class WorkFrame final
{
public:
    explicit WorkFrame(WorkArray<T, Capacity>& work) noexcept
        : m_work(work)
        , m_marker(work.get_marker())
    {
    }
 
    WorkFrame(const WorkFrame&) = delete;
    WorkFrame& operator=(const WorkFrame&) = delete;
    WorkFrame(WorkFrame&&) = delete;
    WorkFrame& operator=(WorkFrame&&) = delete;
 
    ~WorkFrame() noexcept
    {
        (void)m_work.restore(m_marker);
    }
 
    [[nodiscard]] size_t get_marker() const noexcept
    {
        return m_marker;
    }
 
    WorkArrayStatus allocate(size_t len, WorkBlock<T>& out) noexcept
    {
        return m_work.allocate(len, out);
    }
 
private:
    WorkArray<T, Capacity>& m_work;
    size_t m_marker;
};
 
} // namespace fsb
 
#endif // FSB_WORK_H