component_storage.h

#pragma once
 
#include "pixelbullet/core/assert.h"
#include "pixelbullet/core/containers/sparse_set.h"
#include "pixelbullet/serialization/node.h"
#include "pixelbullet/serialization/serialization_result.h"
 
#include <cstdint>
#include <functional>
#include <string>
#include <string_view>
#include <typeinfo>
#include <utility>
 
namespace pixelbullet
{
struct ComponentStorageBase
{
    virtual ~ComponentStorageBase() = default;
    virtual void Serialize(Node& node) const = 0;
    virtual void Deserialize(const Node& node) = 0;
    virtual void DeserializeComponent(uint32_t entity, const Node& node) = 0;
    [[nodiscard]] virtual SerializationResult TryDeserializeComponent(uint32_t entity, const Node& node,
                                                                      std::string_view diagnostic_path) = 0;
    virtual void Clear() = 0;
    virtual void RemoveComponent(uint32_t entity) = 0;
};
 
template <typename T>
struct ComponentStorage : public ComponentStorageBase
{
    using SafeDeserializeFn = std::function<SerializationResult(T&, const Node&, std::string_view)>;
 
    ComponentStorage() = default;
 
    explicit ComponentStorage(SafeDeserializeFn safe_deserialize)
        : safe_deserialize_(std::move(safe_deserialize))
    {
    }
 
    SparseSet<T> components;
 
    void Serialize(Node& node) const override
    {
        node.set_type(NodeType::Array);
        auto& properties = node.properties();
        properties.clear();
        for (const auto& entry : components)
        {
            Node entry_node;
            entry_node["entity"] << entry.id;
            Node component_node;
            component_node << entry.value;
            entry_node["component"] = component_node;
            properties.push_back({ "", entry_node });
        }
    }
 
    void Deserialize(const Node& node) override
    {
        ASSERT(node.type() == NodeType::Array || node.type() == NodeType::Null, "Expected component storage data to be an array");
        for (const auto& [key, entry_node] : node.properties())
        {
            (void)key;
            uint32_t entity = 0;
            entry_node["entity"] >> entity;
            DeserializeComponent(entity, entry_node["component"]);
        }
    }
 
    void DeserializeComponent(const uint32_t entity, const Node& node) override
    {
        T component{};
        node >> component;
        components.insert_or_assign(entity, std::move(component));
    }
 
    [[nodiscard]] SerializationResult TryDeserializeComponent(const uint32_t entity, const Node& node,
                                                              const std::string_view diagnostic_path) override
    {
        T component{};
        if (!safe_deserialize_)
        {
            return SerializationResult{
                false,
                "Component type '" + std::string(typeid(T).name()) + "' does not support safe deserialization.",
                { SerializationDiagnostic{ .path = std::string(diagnostic_path),
                                           .message = "Component type does not support safe deserialization." } },
            };
        }
 
        if (const SerializationResult result = safe_deserialize_(component, node, diagnostic_path); !result)
        {
            return result;
        }
 
        components.insert_or_assign(entity, std::move(component));
        return SerializationResult{ true, {} };
    }
 
    void Clear() override
    {
        components.clear();
    }
 
    void RemoveComponent(uint32_t entity) override
    {
        components.erase(entity);
    }
 
private:
    SafeDeserializeFn safe_deserialize_;
};
} // namespace pixelbullet