implement connection interface

lib/CMakeLists.txt

@@ -5,6 +5,7 @@ project(mdd_lib)
 
 add_library(${PROJECT_NAME} STATIC
         include/HandlerModule
+	include/IConnector.h
         include/IInput.h
         include/IListener.h
         include/IModule.h

lib/include/IConnector.h

@@ -0,0 +1,18 @@
+#ifndef ICONNECTOR_H
+#define ICONNECTOR_H
+
+#include <vector>
+#include <memory>
+
+namespace mdd {
+	template <class T>
+	class IConnector {
+	public:
+		virtual int addConnection(std::shared_ptr<T> conector) = 0;
+		virtual int removeConnection(std::shared_ptr<T> conector) = 0;
+		virtual bool connect(std::shared_ptr<T> conector) = 0;
+		virtual ~IConnector() {};
+	};
+}
+
+#endif

lib/include/IInput.h

@@ -1,17 +1,23 @@
 #ifndef MDD_IINPUT_H
 #define MDD_IINPUT_H
 
-#include "IUnique.h"
+#include "json.hpp"
+#include <memory>
 #include "IOutput.h"
+#include "IUnique.h"
 #include "IState.h"
+#include "IConnector.h"
 
 namespace mdd{
-    class IInput : public IUnique, public IState{
+    class IInput 
+        : public IUnique
+        , public IState
+        , public IConnector<IOutput>
+    {
     public:
         virtual const json& getValue() = 0;
         virtual json& setDefaultValue() = 0;
         virtual bool verify(const json & data) = 0;
-        virtual bool connect(std::shared_ptr<IOutput> output) = 0;
         virtual std::shared_ptr<IOutput> getConnection() = 0;
         virtual ~IInput() = default;
     };

lib/include/IOutput.h

@@ -4,15 +4,19 @@
 #include <memory>
 #include "IUnique.h"
 #include "IState.h"
+//#include "IInput.h"
+#include "IConnector.h"
 
 namespace mdd
 {
+    class IInput;
     class IModule;
 
-    class IOutput : public IUnique, public IState{
+    class IOutput : public IUnique, public IState, public IConnector<IInput>{
     public:
         virtual const json& getValue() = 0;
         virtual json& getValueInternal() = 0;
+        virtual std::vector<std::shared_ptr<IInput>> getConnections() = 0;
         virtual ~IOutput() = default;
     };
 }

lib/include/IUnique.h

@@ -12,5 +12,4 @@ namespace mdd{
         virtual std::string setAppendix(int appendix) = 0;
     };
 }
-
 #endif

lib/include/Input.h

@@ -19,6 +19,9 @@ namespace mdd {
         std::function<bool(const json &)> _verification;
         std::shared_ptr <IOutput> _output;
 
+    protected:
+       
+
     public:
         Input(const std::string &type, int appendix, const json &default_value,
               const std::function<bool(const json &)> &verification = [](
@@ -36,6 +39,8 @@ namespace mdd {
         std::shared_ptr<IOutput> getConnection() override;
         json& setDefaultValue() override;
         bool verify(const json & data) override;
+        int addConnection(std::shared_ptr<IOutput> output) override;
+        int removeConnection(std::shared_ptr<IOutput> output) override;
         bool connect(std::shared_ptr<IOutput> output) override;
     };
 }

lib/include/Output.h

@@ -1,6 +1,7 @@
 #ifndef MDD_OUTPUT_H
 #define MDD_OUTPUT_H
 #include "IOutput.h"
+#include "IInput.h"
 #include "IModule.h"
 
 namespace mdd {
@@ -11,6 +12,9 @@ namespace mdd {
         std::string _prefix;
         std::string _type;
         int _appendix;
+        std::vector<std::shared_ptr<IInput>> _connections;
+
+    protected:
 
     public:
         Output(const std::string& type, int appendix, const json& initial);
@@ -23,6 +27,10 @@ namespace mdd {
         std::string getID() override;
         std::string setPrefix(std::string prefix) override;
         std::string setAppendix(int appendix) override;
+        int addConnection(std::shared_ptr<IInput> input) override;
+        int removeConnection(std::shared_ptr<IInput> input) override;
+        bool connect(std::shared_ptr<IInput> input) override;
+        std::vector<std::shared_ptr<IInput>> getConnections() override;
     };
 }
 #endif

lib/include/ProcessorStandard.h

@@ -18,10 +18,10 @@ namespace mdd {
             size_t connectionCounter;
             size_t changeCounter;
             std::chrono::milliseconds runtime;
+            module_priority(std::shared_ptr<IModule> module, size_t connection = 0, size_t change = 0);
         };
         std::vector<module_priority> _priority_list;
 
-        priority _prioritization;
     public:
         int maxIterations;
         priority priorityEvaluation;

lib/src/Input.cpp

@@ -1,6 +1,16 @@
 #include "Input.h"
 
 namespace mdd{
+    int Input::addConnection(std::shared_ptr<IOutput> output)
+    {
+        _output = output;
+        return 1;
+    }
+    int Input::removeConnection(std::shared_ptr<IOutput> output)
+    {
+        _output = nullptr;
+        return 0;
+    }
     Input::Input(const std::string& type, int appendix, const json& default_value,
                  const std::function<bool(const json&)>& verification) {
         _type = type;
@@ -65,7 +75,9 @@ namespace mdd{
     bool Input::connect(std::shared_ptr<IOutput> output){
         if (verify(output->getValue())) {
             _output = output;
+            _output->addConnection(std::make_shared<Input>((*this)));
             return true;
         }
+        return false;
     }
 }

lib/src/Output.cpp

@@ -1,5 +1,20 @@
 #include "Output.h"
 namespace mdd {
+    int Output::addConnection(std::shared_ptr<IInput> input)
+    {
+        _connections.push_back(input);
+        return _connections.size();
+    }
+    int Output::removeConnection(std::shared_ptr<IInput> input)
+    {
+        for (auto it = _connections.begin(); it != _connections.end(); ++it) {
+            if ((*it) == input)
+            {
+                _connections.erase(it);
+            }
+        }
+        return _connections.size();
+    }
     Output::Output( const std::string& type, int appendix, const json& initial) :
             _state(state::UNCHANGED)
     {
@@ -40,4 +55,17 @@ namespace mdd {
         _appendix = appendix;
         return getID();
     }
+    bool Output::connect(std::shared_ptr<IInput> input)
+    {
+        if (input->verify(getValue())) {
+            addConnection(input);
+            input->addConnection(std::make_shared<Output>((*this)));
+            return true;
+        }
+        return false;
+    }
+    std::vector<std::shared_ptr<IInput>> Output::getConnections()
+    {
+        return _connections;
+    }
 }

lib/src/ProcessorBase.cpp

@@ -80,14 +80,14 @@ namespace mdd{
     void ProcessorBase::removeModule(std::shared_ptr<IModule> module)
     {
         for (auto it = _module_inputs.begin(); it != _module_inputs.end(); ++it) {
-            if (it->accessHandler == module)
+            if (it->moduleHandler == module)
             {
                 _module_inputs.erase(it);
             }
         }
 
         for (auto it = _module_outputs.begin(); it != _module_outputs.end(); ++it) {
-            if (it->accessHandler == module)
+            if (it->moduleHandler == module)
             {
                 _module_outputs.erase(it);
             }

lib/src/ProcessorStandard.cpp

@@ -2,7 +2,7 @@
 #include <iostream>
 
 namespace mdd {
-    ProcessorStandard::ProcessorStandard(priority priorityEvaluation = MANUAL, int maxIterations = -1):
+    ProcessorStandard::ProcessorStandard(priority priorityEvaluation , int maxIterations):
         priorityEvaluation(priorityEvaluation),
         maxIterations(maxIterations)
     {
@@ -12,7 +12,7 @@ namespace mdd {
     std::string ProcessorStandard::addModule(std::shared_ptr<IModule> module)
     {
         std::string id = ProcessorBase::addModule(module);
-        _priority_list.emplace_back(module);
+        _priority_list.emplace_back(module_priority(module));
         return id;
     }
 
@@ -51,6 +51,7 @@ namespace mdd {
                     }
                 }
             }
+            //sort by connections
             std::sort(_priority_list.begin(), _priority_list.end(), [](module_priority a, module_priority b) {
                 return a.connectionCounter < b.connectionCounter;
             });
@@ -103,4 +104,10 @@ namespace mdd {
     std::shared_ptr<IOutput> ProcessorStandard::getIteration(){
         return getProcessorOutput(0);
     }
+    ProcessorStandard::module_priority::module_priority(std::shared_ptr<IModule> module, size_t connection, size_t change)
+    {
+        module_ptr = module;
+        connectionCounter = connection;
+        changeCounter = change;
+    }
 }

lib/test/CMakeLists.txt

@@ -3,7 +3,7 @@ add_executable(auslegung_test
         test_ModuleMath.cpp
         test_ModuleSQL.cpp
         test_ModuleSwitch.cpp
-        test_ProcessorManual.cpp
+        test_ProcessorStandard.cpp
         )
 target_link_libraries(auslegung_test gtest gtest_main ${PROJECT_NAME})
 add_test(auslegung_test auslegung_test)

lib/test/test_ModuleHTTP.cpp

@@ -2,7 +2,7 @@
 #include <json.hpp>
 #include <httplib.h>
 //#define private public
-#include <ProcessorManual.h>
+#include <ProcessorStandard.h>
 #include <ModuleHTTP.h>
 #include <ModuleMath.h>
 #include <ModuleSwitch.h>

lib/test/test_ModuleSwitch.cpp

@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 #include <json.hpp>
 //#define private public
-#include <ProcessorManual.h>
+#include <ProcessorStandard.h>
 #include <ModuleMath.h>
 #include <ModuleSwitch.h>
 
@@ -64,6 +64,6 @@ TEST(ModuleSwitch, ConnectTest){
     f2.update();
     sModule.update();
 
-
+    //std::cout << sModule.getOutput(sModule.getOutputIDs()[0])->getValue()["value"].dump() << std::endl;
     EXPECT_EQ(sModule.getOutput(sModule.getOutputIDs()[0])->getValue()["value"].get<int>(), 6);
 }

lib/test/test_ProcessorManual.cpp

@@ -1,13 +1,13 @@
 #include <gtest/gtest.h>
 #include <json.hpp>
 //#define private public
-#include <ProcessorManual.h>
+#include "ProcessorStandard.h"
 #include <ModuleMath.h>
 #include <ModuleSwitch.h>
 
 
 using namespace mdd;
-TEST(ProcessorManual, CalculateSimpleFormula){
+TEST(ProcessorStandard, CalculateSimpleFormula){
     //f4:(f3:(f1:(5*3)-f2:(4+5))/2)==(15-9)/2==6/2==3
     std::vector<std::string> inputs;
     std::shared_ptr<ModuleMath> f1 = std::make_shared<ModuleMath>(MathOperation::MULTIPLY);
@@ -49,7 +49,7 @@ TEST(ProcessorManual, CalculateSimpleFormula){
     EXPECT_EQ(test->getOutput(test->getOutputIDs()[1])->getValue()["value"].get<int>(), 3);
 }
 
-TEST(ProcessorManual, CalculateAdvancedFormula){
+TEST(ProcessorStandard, CalculateAdvancedFormula){
     //f4:(f3:(f1:(5*3)-f2:(4+5))/2)==(15-9)/2==6/2==3
     std::vector<std::string> inputs;
     std::shared_ptr<ModuleMath> f1 = std::make_shared<ModuleMath>(MathOperation::MULTIPLY);
@@ -83,7 +83,7 @@ TEST(ProcessorManual, CalculateAdvancedFormula){
     EXPECT_EQ(test->getOutput(test->getOutputIDs()[1])->getValue()["value"].get<int>(), 3);
 }
 
-TEST(ProcessorManual, CalculateExtremeFormula){
+TEST(ProcessorStandard, CalculateExtremeFormula){
     //x_0=8, x_i=x_{i-1}/2
     std::shared_ptr<ModuleSwitch> switchModule =  std::make_shared<ModuleSwitch>();
     std::shared_ptr<ModuleMath> calcModule = std::make_shared<ModuleMath>(MathOperation::DIVIDE);