component_storage.h

#pragma once
 
#include "pixelbullet/core/assert.h"
#include "pixelbullet/core/containers/sparse_set.h"
#include "pixelbullet/serialization/node.h"
 
#include <cstdint>
#include <string>
#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 Clear() = 0;
    virtual void RemoveComponent(uint32_t entity) = 0;
};
 
template <typename T>
struct ComponentStorage : public ComponentStorageBase
{
    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;
            T component{};
            entry_node["component"] >> component;
            components.insert_or_assign(entity, std::move(component));
        }
    }
 
    void Clear() override
    {
        components.clear();
    }
 
    void RemoveComponent(uint32_t entity) override
    {
        components.erase(entity);
    }
};
} // namespace pixelbullet