AssetContainer semantic

Bigfoot/Sources/Engine/Include/Engine/BigFile/Asset/AssetContainer.hpp

@@ -7,25 +7,91 @@
 #ifndef BIGFOOT_ENGINE_ASSETCONTAINER_HPP
 #define BIGFOOT_ENGINE_ASSETCONTAINER_HPP
 #include <Engine/BigFile/Asset/Asset.hpp>
-
 #include <Engine/EngineAssertHandler.hpp>
 
-#include <unordered_map>
+#include <eastl/vector_map.h>
 
 namespace Bigfoot
 {
 template<typename ASSET>
-concept BigfootAssetConcept = requires(ASSET p_asset) {
+concept BigfootAssetConcept = requires(ASSET p_asset, const ASSET p_constAsset) {
     requires FlatAssetConcept<typename ASSET::FLAT_ASSET> &&
-                 std::constructible_from<ASSET, FlatAssetWrapper<typename ASSET::FLAT_ASSET>>;
+                 std::constructible_from<ASSET, FlatAssetWrapper<typename ASSET::FLAT_ASSET>*>;
 };
 
 template<BigfootAssetConcept ASSET>
 class AssetContainer
 {
   public:
+    AssetContainer() = default;
+
+    AssetContainer(const AssetContainer& p_container) = delete;
+    AssetContainer(AssetContainer&& p_container) = delete;
+
+    [[nodiscard]]
+    bool Add(const UUID& p_uuid, const eastl::string_view p_name)
+    {
+        FlatAssetWrapper<typename ASSET::FLAT_ASSET> flatAsset {};
+        flatAsset.Asset().asset_header->uuid = p_uuid;
+        flatAsset.Asset().asset_header->name = p_name;
+
+        return Add(p_uuid, flatAsset.Pack());
+    }
+
+    [[nodiscard]]
+    bool Add(const UUID& p_uuid, const eastl::span<const std::byte> p_flatBuffer)
+    {
+        const auto& added = m_assets.emplace(p_uuid, eastl::make_unique<AssetFlatAssetWrapperPair>(p_flatBuffer));
+
+        CRITICAL_ASSERT(EngineAssertHandler,
+                        !added.second || added.first->second->m_flatAsset.Asset().asset_header->uuid == p_uuid,
+                        "Added ASSET UUID does not match !");
+
+        return added.second;
+    }
+
+    [[nodiscard]]
+    ASSET* Get(const UUID& p_uuid)
+    {
+        return m_assets.contains(p_uuid) ? &m_assets.at_key(p_uuid)->m_asset : nullptr;
+    }
+
+    [[nodiscard]]
+    const ASSET* Get(const UUID& p_uuid) const
+    {
+        return m_assets.contains(p_uuid) ? &m_assets.at_key(p_uuid)->m_asset : nullptr;
+    }
+
+    void Remove(const UUID& p_uuid)
+    {
+        m_assets.erase(p_uuid);
+    }
+
+    [[nodiscard]]
+    eastl::vector<std::byte> Pack(const UUID& p_uuid) const
+    {
+        return m_assets.contains(p_uuid) ? m_assets.at_key(p_uuid)->m_flatAsset.Pack() : eastl::vector<std::byte> {};
+    }
+
+    ~AssetContainer() = default;
+
+    AssetContainer& operator=(const AssetContainer& p_container) = delete;
+    AssetContainer& operator=(AssetContainer&& p_container) = delete;
 
   private:
+    struct AssetFlatAssetWrapperPair
+    {
+        AssetFlatAssetWrapperPair(const eastl::span<const std::byte> p_flatbuffer):
+            m_flatAsset(p_flatbuffer),
+            m_asset(&m_flatAsset)
+        {
+        }
+
+        FlatAssetWrapper<typename ASSET::FLAT_ASSET> m_flatAsset;
+        ASSET m_asset;
+    };
+
+    eastl::vector_map<UUID, eastl::unique_ptr<AssetFlatAssetWrapperPair>> m_assets;
 };
 }   // namespace Bigfoot
 

Bigfoot/Tests/Engine/BigFile/BigFile.cpp

@@ -15,6 +15,7 @@
 #include <Utils/Singleton.hpp>
 #include <Utils/TargetMacros.h>
 
+#include <EngineTests/BigFile/Asset/AssetA.hpp>
 #include <EngineTests/BigFile/Asset/AssetA_generated.hpp>
 #include <EngineTests/BigFileInfo_generated.hpp>
 
@@ -36,7 +37,7 @@ class BigFileFixture: public ::testing::Test
         m_bigFile.CommitTransaction();
     }
 
-    FlatAssetWrapper<Flat::AssetA> test;
+    AssetAContainer m_assetAContainer;
 
     BIGFOOT_NOT_OPTIMIZED_ONLY(Singleton<Log>::Lifetime m_loggerLifetime;)
 
@@ -48,31 +49,36 @@ class BigFileFixture: public ::testing::Test
 TEST_F(BigFileFixture, Lol)
 {
     {
-        UUID uuid;
-
-        test.Asset().health = 100;
-        test.Asset().mana = 42;
-
-        test.Asset().asset_header->name = "Instance";
-        test.Asset().asset_header->uuid = uuid;
-        test.Asset().asset_header->version = 2;
-
-        const eastl::vector<std::byte> flatbuffer = test.Pack();
-
         EXPECT_STREQ(FlatAssetWrapper<Flat::AssetA>::TypeName().data(), "Bigfoot.Flat.AssetA");
         EXPECT_EQ(FlatAssetWrapper<Flat::AssetA>::TypeID(),
                   rapidhash(FlatAssetWrapper<Flat::AssetA>::TypeName().data(),
                             FlatAssetWrapper<Flat::AssetA>::TypeName().size()));
 
-        FlatAssetWrapper<Flat::AssetA> test2 {flatbuffer};
-        EXPECT_EQ(test2.Asset().health, 100);
-        EXPECT_EQ(test2.Asset().mana, 42);
+        UUID uuid;
+        std::ignore = m_assetAContainer.Add(uuid, "Instance");
 
-        EXPECT_STREQ(test2.Asset().asset_header->name.c_str(), "Instance");
-        EXPECT_EQ(test2.Asset().asset_header->type_id, FlatAssetWrapper<Flat::AssetA>::TypeID());
-        EXPECT_STREQ(test2.Asset().asset_header->type_name.c_str(), FlatAssetWrapper<Flat::AssetA>::TypeName().data());
-        EXPECT_EQ(test2.Asset().asset_header->uuid, uuid);
-        EXPECT_EQ(test2.Asset().asset_header->version, 2);
+        AssetA* test = m_assetAContainer.Get(uuid);
+
+        test->Health() = 100;
+        test->Mana() = 42;
+
+        const eastl::vector<std::byte> flatbuffer = m_assetAContainer.Pack(uuid);
+        m_assetAContainer.Remove(uuid);
+
+        std::ignore = m_assetAContainer.Add(uuid, flatbuffer);
+        std::ignore = m_assetAContainer.Add(UUID {}, "Instance2");
+        std::ignore = m_assetAContainer.Add(UUID {}, "Instance3");
+
+        AssetA* test2 = m_assetAContainer.Get(uuid);
+
+        EXPECT_EQ(test2->Health(), 100);
+        EXPECT_EQ(test2->Mana(), 42);
+
+        EXPECT_STREQ(test2->AssetHeader()->name.c_str(), "Instance");
+        EXPECT_EQ(test2->AssetHeader()->type_id, FlatAssetWrapper<Flat::AssetA>::TypeID());
+        EXPECT_STREQ(test2->AssetHeader()->type_name.c_str(), FlatAssetWrapper<Flat::AssetA>::TypeName().data());
+        EXPECT_EQ(test2->AssetHeader()->uuid, uuid);
+        EXPECT_EQ(test2->AssetHeader()->version, 2);
     }
 
     UUID uuid;

Bigfoot/Tests/Engine/Include/EngineTests/BigFile/Asset/AssetA.hpp

@@ -17,17 +17,50 @@ class AssetA
   public:
     using FLAT_ASSET = Flat::AssetA;
 
-    AssetA(const FlatAssetWrapper<Flat::AssetA>& p_flatAsset);
+    AssetA(FlatAssetWrapper<Flat::AssetA>* p_flatAsset):
+        m_flatAsset(p_flatAsset)
+    {
+        // deprecation...
+        if (m_flatAsset->Asset().asset_header->version < 2)
+        {
+            m_flatAsset->Asset().asset_header->version = 2;
+        }
+    }
 
     AssetA(const AssetA& p_assetA) = default;
     AssetA(AssetA&& p_assetA) = default;
 
+    [[nodiscard]]
+    std::uint32_t& Health()
+    {
+        return m_flatAsset->Asset().health;
+    }
+
+    [[nodiscard]]
+    std::uint32_t& Mana()
+    {
+        return m_flatAsset->Asset().mana;
+    }
+
+    [[nodiscard]]
+    Flat::AssetHeaderT* AssetHeader()
+    {
+        return m_flatAsset->Asset().asset_header.get();
+    }
+
+    [[nodiscard]]
+    const Flat::AssetHeaderT* AssetHeader() const
+    {
+        return m_flatAsset->Asset().asset_header.get();
+    }
+
     ~AssetA() = default;
 
     AssetA& operator=(const AssetA& p_assetA) = default;
     AssetA& operator=(AssetA&& p_assetA) = default;
 
   private:
+    FlatAssetWrapper<Flat::AssetA>* m_flatAsset;
 };
 
 using AssetAContainer = AssetContainer<AssetA>;