refactoring. Everything is pointer.

src/system/connect.cpp

@@ -4,4 +4,4 @@ Connection::Connection(std::string name) : SystemElement(name) {};
 
 Connections::Connections(void): SystemElementContainer<Connection>("connections") {}
 
-Connections::Connections(std::vector<Connection> conns): SystemElementContainer<Connection>("connections", conns) {}
+Connections::Connections(std::vector<Connection *> conns): SystemElementContainer<Connection>("connections", conns) {}

src/system/connect.hpp

@@ -13,7 +13,7 @@ class Connections : public SystemElementContainer<Connection>
 {
 public:
     Connections(void);
-    Connections(std::vector<Connection> connections);
+    Connections(std::vector<Connection *> connections);
 };
 
 #endif // _CONNECT_HPP_

src/system/modules.cpp

@@ -1,7 +1,7 @@
 #include "modules.hpp"
 
-Module::Module(std::string name) : SystemElementContainer<Part>(name) {};
+Module::Module(std::string name) : SystemElementContainer<Part>(name) {}
 
 Modules::Modules(void): SystemElementContainer<Module>("modules") {}
 
-Modules::Modules(std::vector<Module> modules): SystemElementContainer<Module>("modules", modules) {}
+Modules::Modules(std::vector<Module *> modules): SystemElementContainer<Module>("modules", modules) {}

src/system/modules.hpp

@@ -3,10 +3,12 @@
 
 #include "syselmts.hpp"
 #include "parts.hpp"
+#include "signals.hpp"
 
 class Module : public SystemElementContainer<Part>
 {
 public:
+    Signals sigs;
     Module(std::string name);
 };
 
@@ -14,7 +16,7 @@ class Modules : public SystemElementContainer<Module>
 {
 public:
     Modules(void);
-    Modules(std::vector<Module> pins);
+    Modules(std::vector<Module *> pins);
 };
 
 #endif // _MODULES_HPP_

src/system/parts.cpp

@@ -4,4 +4,4 @@ Part::Part(std::string name) : SystemElementContainer<Pin>(name) {};
 
 Parts::Parts(void): SystemElementContainer<Part>("parts") {}
 
-Parts::Parts(std::vector<Part> parts): SystemElementContainer<Part>("parts", parts) {}
+Parts::Parts(std::vector<Part *> parts): SystemElementContainer<Part>("parts", parts) {}

src/system/parts.hpp

@@ -14,7 +14,7 @@ class Parts : public SystemElementContainer<Part>
 {
 public:
     Parts(void);
-    Parts(std::vector<Part> parts);
+    Parts(std::vector<Part *> parts);
 };
 
 #endif // _PARTS_HPP_

src/system/pins.cpp

@@ -1,7 +1,16 @@
 #include "pins.hpp"
 
-Pin::Pin(std::string name) : SystemElement(name) {};
+Pin::Pin(std::string name) : SystemElement(name), sig(nullptr) {};
+
+bool Pin::connected() {
+    return sig != nullptr;
+}
+
+void Pin::connect(Signal *signal)
+{
+    sig = signal;
+}
 
 Pins::Pins(void): SystemElementContainer<Pin>("pins") {}
 
-Pins::Pins(std::vector<Pin> pins): SystemElementContainer<Pin>("pins", pins) {}
+Pins::Pins(std::vector<Pin *> pins): SystemElementContainer<Pin>("pins", pins) {}

src/system/pins.hpp

@@ -2,18 +2,22 @@
 #define _PINS_HPP_
 
 #include "syselmts.hpp"
+#include "signals.hpp"
 
 class Pin : public SystemElement
 {
+    Signal *sig;
 public:
     Pin(std::string name);
+    bool connected();
+    void connect(Signal *signal);
 };
 
 class Pins : public SystemElementContainer<Pin>
 {
 public:
     Pins(void);
-    Pins(std::vector<Pin> pins);
+    Pins(std::vector<Pin *> pins);
 };
 
 #endif // _PINS_HPP_

src/system/signals.cpp

@@ -5,5 +5,5 @@ Signal::Signal(std::string name) : SystemElementContainer<Pin>(name) {};
 
 Signals::Signals(void): SystemElementContainer<Signal>("signals") {}
 
-Signals::Signals(std::vector<Signal> signals): SystemElementContainer<Signal>("signals", signals) {}
+Signals::Signals(std::vector<Signal *> signals): SystemElementContainer<Signal>("signals", signals) {}
 

src/system/signals.hpp

@@ -2,7 +2,9 @@
 #define _SIGNALS_HPP_
 
 #include "syselmts.hpp"
-#include "pins.hpp"
+
+#pragma once
+class Pin;
 
 class Signal : public SystemElementContainer<Pin>
 {
@@ -14,7 +16,7 @@ class Signals : public SystemElementContainer<Signal>
 {
 public:
     Signals(void);
-    Signals(std::vector<Signal> signals);
+    Signals(std::vector<Signal *> signals);
 };
 
 #endif // _SIGNALS_HPP_

src/system/syselmts.hpp

@@ -6,65 +6,82 @@
 #include <unordered_map>
 #include <stdexcept>
 
+using namespace std;
+
 class SystemElement
 {
 public:
-    std::string name;
-    SystemElement(std::string name) : name(name) {};
+    string name;
+    SystemElement(string name) : name(name) {};
 };
 
 template <typename T>
 class SystemElementContainer : public SystemElement
 {
 private:
-    static_assert(std::is_base_of<SystemElement, T>::value, "T shall be a system element descendant !");
+    //static_assert(is_base_of<SystemElement, T>::value, "T shall be a system element descendant !");
     unsigned int iter_count;
-    std::unordered_map<std::string, T> content;
+    unordered_map<string, T*> content;
 
-    bool name_exists(std::string name)
+    void add(unordered_map<string, T*> el_content)
     {
-        return get(name) != nullptr;
+        for (const auto &[key, value] : el_content)
+        {
+            add(value);
+        }
     }
 
 public:
-    SystemElementContainer(std::string name) : SystemElement(name) {};
-    SystemElementContainer(std::string name, std::vector<T> elements) : SystemElement(name)
+    SystemElementContainer(string name) : SystemElement(name) {};
+    SystemElementContainer(string name, vector<T *> elements) : SystemElement(name)
     {
         add(elements);
     }
-    void add(T element)
+    bool exists(string name)
     {
-        if ("" == element.name)
+        try
         {
-            throw std::runtime_error("System elements with empty names are forbidden");
+            get(name);
+            return true;
         }
-        if (name_exists(element.name))
+        catch (const exception &e)
         {
-            throw std::runtime_error("System elements of same names are forbidden");
+            return false;
         }
-        content.insert({element.name, element});
     }
-    void add(SystemElementContainer<T> elements)
+    void add(T* element)
     {
-        add(elements.content);
+        if ("" == element->name)
+        {
+            throw runtime_error("System elements with empty names are forbidden");
+        }
+        if (exists(element->name))
+        {
+            throw runtime_error("System elements of same names are forbidden");
+        }
+        content.insert({element->name, element});
     }
-    void add(std::vector<T> elements)
+    void add(SystemElementContainer<T> *elements)
+    {
+        add(elements->content);
+    }
+    void add(vector<T*> elements)
     {
         for (auto &element : elements)
         {
             add(element);
         }
     }
-    T *get(std::string name)
+    T *get(string name)
     {
         auto it = content.find(name);
         if (it != content.end())
         {
-            return &it->second;
+            return it->second;
         }
         else
         {
-            return nullptr;
+            throw runtime_error("System elements not found");
         }
     }
 };