refactor: remove switch case from Parser::buildComponent()

include/parser/Parser.hpp

@@ -5,8 +5,14 @@
 #include <memory>
 #include <string>
 
-#include "neuronide.pb.h"
-#include "scene/SceneAll.hpp"
+class Scene;
+class SceneObject;
+class Component;
+
+namespace NeuronIDE {
+class SceneObject;
+class Component;
+}  // namespace NeuronIDE
 
 class Parser {
    public:

include/scene/Scene.hpp

@@ -5,7 +5,7 @@
 #include <string>
 #include <vector>
 
-#include "SceneObject.hpp"
+class SceneObject;
 
 class Scene {
    private:

include/scene/SceneObject.hpp

@@ -6,7 +6,7 @@
 #include <string>
 #include <vector>
 
-#include "components/Component.hpp"
+class Component;
 
 class SceneObject {
    public:
@@ -19,15 +19,11 @@ class SceneObject {
 
     std::vector<std::unique_ptr<Component>> components;
 
-    SceneObject(std::string n, bool visible = true) : name(std::move(n)), isVisible(visible) {
-        std::cout << "  [SceneObject] Utworzono obiekt: " << name << "\n";
-    }
+    SceneObject(std::string n, bool visible = true);
 
-    void setTransform(double posX, double posY, double width, double height, double rotation) {
-        transform = {posX, posY, width, height, rotation};
-    }
+    void setTransform(Transform t);
 
-    void addComponent(std::unique_ptr<Component> comp) { components.push_back(std::move(comp)); }
+    void addComponent(std::unique_ptr<Component> comp);
 };
 
 #endif  // SCENEOBJECT_HPP

include/scene/components/BlinkComponent.hpp

@@ -2,16 +2,23 @@
 #define BLINKCOMPONENT_HPP
 
 #include <iostream>
+#include <memory>
 
 #include "Component.hpp"
 
+namespace NeuronIDE {
+class Component;
+}
+
 class BlinkComponent : public Component {
    public:
     BlinkComponent(double freq) : blinkFrequencyHz(freq) {
         std::cout << "    + [BlinkComponent] Utworzono z czestotliwoscia: " << blinkFrequencyHz
                   << "Hz\n";
     }
-    void setFrequency(double freq) { blinkFrequencyHz = freq; }
+    void setFrequency(double freq);
+
+    static std::unique_ptr<Component> createBlinker(const NeuronIDE::Component& protoComp);
 
    private:
     double blinkFrequencyHz = 0.0;

include/scene/components/ComponentRegistry.hpp

@@ -0,0 +1,52 @@
+#ifndef COMPONENTREGISTRY_HPP
+#define COMPONENTREGISTRY_HPP
+
+#include <functional>
+#include <memory>
+#include <unordered_map>
+
+class Component;
+namespace NeuronIDE {
+class Component;
+}
+
+using ComponentCreatorFunc = std::function<std::unique_ptr<Component>(const NeuronIDE::Component&)>;
+
+class ComponentRegistry {
+   public:
+    ComponentRegistry(const ComponentRegistry&)            = delete;
+    ComponentRegistry& operator=(const ComponentRegistry&) = delete;
+
+    ComponentRegistry(ComponentRegistry&&)            = delete;
+    ComponentRegistry& operator=(ComponentRegistry&&) = delete;
+
+    static ComponentRegistry& instance() {
+        static ComponentRegistry instance;
+        return instance;
+    }
+
+    void registerCreator(int typeId, ComponentCreatorFunc creator);
+
+    std::unique_ptr<Component> build(const NeuronIDE::Component& protoComp);
+
+   private:
+    ComponentRegistry() = default;
+
+    std::unordered_map<int, ComponentCreatorFunc> creators;
+};
+
+#define COMPONENT_REGISTRATION_CONCAT_IMPL(x, y) x##y
+#define COMPONENT_REGISTRATION_CONCAT(x, y) COMPONENT_REGISTRATION_CONCAT_IMPL(x, y)
+
+#define REGISTER_COMPONENT(typeId, creatorFunc)                                                  \
+    namespace {                                                                                  \
+    struct COMPONENT_REGISTRATION_CONCAT(ComponentRegistrar_, __LINE__) {                        \
+        COMPONENT_REGISTRATION_CONCAT(ComponentRegistrar_, __LINE__)() {                         \
+            ComponentRegistry::instance().registerCreator(static_cast<int>(typeId), creatorFunc);\
+        }                                                                                        \
+    };                                                                                           \
+    static COMPONENT_REGISTRATION_CONCAT(ComponentRegistrar_, __LINE__)                          \
+        COMPONENT_REGISTRATION_CONCAT(global_registrar_, __LINE__);                              \
+    }
+
+#endif  // COMPONENTREGISTRY_HPP

protoFiles/tests/test_scene.pbtxt

@@ -17,12 +17,6 @@ scene_objects {
       blink_frequency_hz: 1.5
     }
   }
-
-  components {
-    blinker {
-      blink_frequency_hz: 3
-    }
-  }
 }
 
 scene_objects {

src/CMakeLists.txt

@@ -1,8 +1,11 @@
 protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS ${CMAKE_CURRENT_SOURCE_DIR}/../protoFiles/neuronide.proto)
 
-add_library(runtime_core 
+add_library(runtime_core OBJECT
     Runtime.cpp
-    parser/Parser.cpp 
+    parser/Parser.cpp
+    scene/components/ComponentRegistry.cpp
+    scene/components/BlinkComponent.cpp
+    scene/SceneObject.cpp
     ${PROTO_SRCS} 
     ${PROTO_HDRS}
 )

src/parser/Parser.cpp

@@ -1,14 +1,16 @@
 #include "parser/Parser.hpp"
 
-#include <google/protobuf/text_format.h>  // dla .pbtxt jeśli będzie potrzeba
-
 #include <fstream>
 #include <stdexcept>
+#include <unordered_set>
 
 #include "neuronide.pb.h"
-#include "scene/SceneAll.hpp"
+#include "scene/Scene.hpp"
+#include "scene/SceneObject.hpp"
+#include "scene/components/Component.hpp"
+#include "scene/components/ComponentRegistry.hpp"
 
-std::shared_ptr<::Scene> Parser::parse(const std::string& filePath) {
+std::shared_ptr<Scene> Parser::parse(const std::string& filePath) {
     NeuronIDE::Scene protoScene;
 
     std::ifstream file(filePath, std::ios::binary);
@@ -36,10 +38,20 @@ std::shared_ptr<SceneObject> Parser::buildSceneObject(const NeuronIDE::SceneObje
 
     if (protoObj.has_transform()) {
         const auto& tra = protoObj.transform();
-        obj->setTransform(tra.x(), tra.y(), tra.width(), tra.height(), tra.rotation());
+        obj->setTransform({tra.x(), tra.y(), tra.width(), tra.height(), tra.rotation()});
     }
 
+    std::unordered_set<int> seenComponentTypes;
+
     for (const auto& protoComp : protoObj.components()) {
+        int typeId = static_cast<int>(protoComp.component_type_case());
+
+        if (seenComponentTypes.find(typeId) != seenComponentTypes.end()) {
+            throw std::runtime_error("Parser: duplicate component type in object '" +
+                                     protoObj.name() + "'.");
+        }
+        seenComponentTypes.insert(typeId);
+
         auto comp = buildComponent(protoComp);
         if (comp) {
             obj->addComponent(std::move(comp));
@@ -50,31 +62,5 @@ std::shared_ptr<SceneObject> Parser::buildSceneObject(const NeuronIDE::SceneObje
 }
 
 std::unique_ptr<Component> Parser::buildComponent(const NeuronIDE::Component& protoComp) {
-    using CT = NeuronIDE::Component::ComponentTypeCase;
-
-    switch (protoComp.component_type_case()) {
-            // case CT::kRenderer: {
-            //     const auto& ren = protoComp.renderer();
-            //     return std::make_unique<SpriteRenderer>(ren.texture_path(), ren.img_path());
-            // }
-
-            // case CT::kText: {
-            //     const auto& txt = protoComp.text();
-            //     return std::make_unique<TextRenderer>(txt.text(), txt.font_path(),
-            //     txt.font_size());
-            // }
-
-        case CT::kBlinker: {
-            const auto& bli = protoComp.blinker();
-            return std::make_unique<BlinkComponent>(bli.blink_frequency_hz());
-        }
-
-            // case CT::kScript: {
-            //     const auto& scr = protoComp.script();
-            //     return std::make_unique<ScriptComponent>(scr.script_path());
-            // }
-
-        default:
-            return nullptr;
-    }
+    return ComponentRegistry::instance().build(protoComp);
 }

src/scene/SceneObject.cpp

@@ -0,0 +1,15 @@
+#include "scene/SceneObject.hpp"
+
+#include <utility>
+
+#include "scene/components/Component.hpp"
+
+SceneObject::SceneObject(std::string n, bool visible) : name(std::move(n)), isVisible(visible) {
+    std::cout << "  [SceneObject] Utworzono obiekt: " << name << "\n";
+}
+
+void SceneObject::setTransform(Transform t) { transform = t; }
+
+void SceneObject::addComponent(std::unique_ptr<Component> comp) {
+    components.push_back(std::move(comp));
+}

src/scene/components/BlinkComponent.cpp

@@ -0,0 +1,12 @@
+#include "scene/components/BlinkComponent.hpp"
+
+#include "neuronide.pb.h"
+#include "scene/components/ComponentRegistry.hpp"
+
+void BlinkComponent::setFrequency(double freq) { blinkFrequencyHz = freq; }
+
+std::unique_ptr<Component> BlinkComponent::createBlinker(const NeuronIDE::Component& protoComp) {
+    return std::make_unique<BlinkComponent>(protoComp.blinker().blink_frequency_hz());
+}
+
+REGISTER_COMPONENT(NeuronIDE::Component::kBlinker, BlinkComponent::createBlinker)

src/scene/components/ComponentRegistry.cpp

@@ -0,0 +1,27 @@
+#include "scene/components/ComponentRegistry.hpp"
+
+#include <stdexcept>
+#include <utility>
+
+#include "neuronide.pb.h"
+#include "scene/components/Component.hpp"
+
+void ComponentRegistry::registerCreator(int typeId, ComponentCreatorFunc creator) {
+    if (creators.find(typeId) != creators.end()) {
+        throw std::runtime_error("Creator for this typeId is already registered.");
+    }
+    creators[typeId] = std::move(creator);
+}
+
+std::unique_ptr<Component> ComponentRegistry::build(const NeuronIDE::Component& protoComp) {
+    auto activeCase = protoComp.component_type_case();
+
+    int typeId = static_cast<int>(activeCase);
+
+    auto it = creators.find(typeId);
+    if (it != creators.end()) {
+        return it->second(protoComp);
+    }
+
+    return nullptr;
+}