spk_buffer_layout.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <variant>
#include <vector>
 
namespace spk
{
    class BufferLayout
    {
    public:
        using Buffer = std::uint8_t *;
 
        class Element;
 
    private:
        struct ObjectData
        {
            std::unordered_map<std::wstring, Element> children;
        };
 
        struct ArrayData
        {
            std::vector<Element> elements;

            void build(std::size_t p_count, const Element &p_unitElement);
        };
 
    public:
        class Element
        {
            friend class BufferLayout;
            friend struct ObjectData;
            friend struct ArrayData;
 
        public:
            using Content = std::variant<std::monostate, ObjectData, ArrayData>;

            Element() = default;

            explicit Element(std::size_t p_size) :
                _offset(0),
                _size(p_size),
                _content(std::monostate{})
            {
            }
 
        private:
            Element(std::size_t p_offset, std::size_t p_size) :
                _offset(p_offset),
                _size(p_size),
                _content(std::monostate{})
            {
            }
 
        public:
            Element(const Element &p_other) = default;
            Element &operator=(const Element &p_other) = default;

            std::size_t offset() const;
            std::size_t size() const;

            void bind(Buffer p_parentBuffer);

            template <typename TType>
            Element &operator=(const TType &p_value)
            {
                setData(p_value);
                return *this;
            }
 
            template <typename TType>
            void setData(const TType &p_value)
            {
                static_assert(std::is_trivially_copyable_v<TType>, "Element::setData requires trivially copyable types");
                setData(&p_value, sizeof(TType));
            }

            template <typename TType>
            const TType &as() const
            {
                static_assert(std::is_trivially_copyable_v<TType>, "Element::as requires trivially copyable types");
                if (_buffer == nullptr)
                {
                    throw std::runtime_error("Element::as: buffer is null (not bound)");
                }
                if (sizeof(TType) != _size)
                {
                    throw std::runtime_error("Element::as: size mismatch");
                }
                return *reinterpret_cast<const TType *>(_buffer);
            }

            template <typename TType>
            TType &as()
            {
                static_assert(std::is_trivially_copyable_v<TType>, "Element::as requires trivially copyable types");
                if (_buffer == nullptr)
                {
                    throw std::runtime_error("Element::as: buffer is null (not bound)");
                }
                if (sizeof(TType) != _size)
                {
                    throw std::runtime_error("Element::as: size mismatch");
                }
                return *reinterpret_cast<TType *>(_buffer);
            }

            void setData(const void *p_data, std::size_t p_size);

            Element &addMember(const std::wstring &p_name, std::size_t p_relativeOffset, const Element &p_member);

            Element &addArray(const std::wstring &p_name, std::size_t p_relativeOffset, std::size_t p_count, const Element &p_arrayElement);

            Element &addArray(const std::wstring &p_name, std::size_t p_count, const Element &p_arrayElement);

            Element &operator[](const std::wstring &p_name);
            const Element &operator[](const std::wstring &p_name) const;

            Element &operator[](std::size_t p_index);
            const Element &operator[](std::size_t p_index) const;

            void remove(const std::wstring &p_name);

            std::unordered_map<std::wstring, Element> &objectChildren();
            const std::unordered_map<std::wstring, Element> &objectChildren() const;

            std::vector<Element> &arrayElements();
            const std::vector<Element> &arrayElements() const;
 
        private:
            bool _isObject() const;
            bool _isArray() const;

            void _makeObject();
            void _makeArray();

            ObjectData &_asObject();
            const ObjectData &_asObject() const;

            ArrayData &_asArray();
            const ArrayData &_asArray() const;

            void _validateChildBounds(std::size_t p_relativeOffset, std::size_t p_childSize, const char *p_context) const;
 
            Buffer _buffer = nullptr;
            std::size_t _offset = 0;
            std::size_t _size = 0;
            Content _content = std::monostate{};
        };
 
    private:
        Buffer _buffer = nullptr;
        Element _root;
 
    public:
        BufferLayout(Buffer p_buffer, std::size_t p_size);

        Element &root();
        const Element &root() const;

        Element &addMember(const std::wstring &p_name, std::size_t p_relativeOffset, const Element &p_member);

        Element &addArray(const std::wstring &p_name, std::size_t p_relativeOffset, std::size_t p_count, const Element &p_arrayElement);

        Element &operator[](const std::wstring &p_name);
        const Element &operator[](const std::wstring &p_name) const;

        void remove(const std::wstring &p_name);
        void resize(std::size_t p_size);
    };
}