xxxx

zdenyhraz · May 30, 2024 · 8cde98d · 8cde98d
1 parent 9399db7
commit 8cde98d
Show file tree

Hide file tree

Showing 3 changed files with 62 additions and 58 deletions.
diff --git a/src/Microservice/Microservice.hpp b/src/Microservice/Microservice.hpp
@@ -1,10 +1,6 @@
 #pragma once
 
-struct MicroserviceStartParameter
-{
-};
-
-struct MicroserviceFinishParameter
+struct MicroserviceStartFinish
 {
 };
 
@@ -32,11 +28,9 @@ struct MicroserviceOutputParameter
 
 class Microservice
 {
-  friend class Workflow;
-
   std::string microserviceName;
-  MicroserviceInputParameter start = MicroserviceInputParameter{.type = std::type_index(typeid(MicroserviceStartParameter)), .name = "start"};
-  MicroserviceOutputParameter finish = MicroserviceOutputParameter{.type = std::type_index(typeid(MicroserviceFinishParameter)), .name = "finish"};
+  MicroserviceInputParameter start = MicroserviceInputParameter{.type = std::type_index(typeid(MicroserviceStartFinish)), .name = "start"};
+  MicroserviceOutputParameter finish = MicroserviceOutputParameter{.type = std::type_index(typeid(MicroserviceStartFinish)), .name = "finish"};
   std::unordered_map<std::string, MicroserviceInputParameter> inputParameters;
   std::unordered_map<std::string, MicroserviceOutputParameter> outputParameters;
 
@@ -153,6 +147,10 @@ class Microservice
 
   std::unordered_map<std::string, MicroserviceOutputParameter>& GetOutputParameters() { return outputParameters; }
 
+  MicroserviceInputParameter& GetStartParameter() { return start; }
+
+  MicroserviceOutputParameter& GetFinishParameter() { return finish; }
+
   MicroserviceInputParameter& GetInputParameter(const std::string& paramName)
   {
     if (not inputParameters.contains(paramName))

diff --git a/src/Microservice/TODO.md b/src/Microservice/TODO.md
@@ -1,7 +1,15 @@
+# General
 - [x] use std::any, std::any_cast for input / output parameters / connections
 - [x] named inputs / outputs
-- [ ] dont duplicate data storage during ms output -> ms input
-- [ ] add dedicated start node
-- [ ] add parameter id for pins
-- [ ] use void* as node/link/pin ids
+- [x] dont duplicate data storage during ms output -> ms input
+- [x] add dedicated start node
+- [x] add parameter id for pins
+- [ ] workflow save to / load from file - json
+- [ ] fetch all inputs recursively when notified
 
+# GUI
+- [ ] gui layout save? - json
+- [ ] connection curves fix
+- [ ] input / output parameter text alignment
+- [x] use *this* as node/link/pin ids
+- [ ] pin sprites depending on parameter type
diff --git a/src/Microservice/Workflow.hpp b/src/Microservice/Workflow.hpp
@@ -6,7 +6,6 @@
 
 class Workflow
 {
-
   struct MicroserviceConnection
   {
     Microservice* outputMicroservice = nullptr;
@@ -17,8 +16,6 @@ class Workflow
     auto operator<=>(const MicroserviceConnection&) const = default;
 
     uintptr_t GetId() const { return reinterpret_cast<uintptr_t>(this); }
-
-    void Connect() { inputParameter->value = &outputParameter->value; }
   };
 
   std::string name = "Default workflow";
@@ -36,7 +33,7 @@ class Workflow
       return;
 
     auto relevantConnections = std::views::filter(connections.at(&microservice),
-        [&microservice](MicroserviceConnection& conn) { return conn.outputMicroservice == &microservice and conn.outputParameter == &microservice.finish; });
+        [&microservice](MicroserviceConnection& conn) { return conn.outputMicroservice == &microservice and conn.outputParameter == &microservice.GetFinishParameter(); });
     LOG_DEBUG("Microservice '{}' has {} output connections:", microservice.GetName(), std::ranges::distance(relevantConnections));
     for (auto& connection : relevantConnections)
       LOG_DEBUG("'{}'", connection.inputMicroservice->GetName());
@@ -50,13 +47,21 @@ class Workflow
   }
 
 public:
-  Workflow()
+  Workflow() { microservices.push_back(std::make_unique<StartMicroservice>()); }
+
+  Workflow(const std::filesystem::path& path) : Workflow()
   {
-    microservices.push_back(std::make_unique<StartMicroservice>());
     // TODO: load microservices from file
     // TODO: load connections from file
     // TODO: connect the parameters
     // TODO: set workflow name according to file name
+    // TODO: set node locations from file
+  }
+
+  void Save(const std::filesystem::path& path) const
+  {
+    // TODO: serialize microservices to json
+    // TODO: serialize connections to json
   }
 
   const std::string& GetName() { return name; }
@@ -84,43 +89,50 @@ class Workflow
     LOG_ERROR("Workflow '{}' error: {}", GetName(), e.what());
   }
 
+  void Connect(MicroserviceConnection&& connection)
+  {
+    if (connection.outputParameter->type != connection.inputParameter->type)
+      return LOG_WARNING("Connection {}:{} -> {}:{} type mismatch: {} != {}", connection.outputMicroservice->GetName(), connection.outputParameter->GetName(),
+          connection.inputMicroservice->GetName(), connection.inputParameter->GetName(), connection.inputParameter->type.name(), connection.outputParameter->type.name());
+    if (connection.outputMicroservice == connection.inputMicroservice)
+      return LOG_WARNING("Connection {}:{} -> {}:{}: cannot connect microservice to itself ", connection.outputMicroservice->GetName(), connection.outputParameter->GetName(),
+          connection.inputMicroservice->GetName(), connection.inputParameter->GetName());
+    if (connections.contains(connection.outputMicroservice))
+      if (std::ranges::any_of(connections.at(connection.outputMicroservice), [&connection](auto& conn) { return conn == connection; }))
+        return LOG_WARNING("Ignoring duplicate connection {}:{} -> {}:{}", connection.outputMicroservice->GetName(), connection.outputParameter->GetName(),
+            connection.inputMicroservice->GetName(), connection.inputParameter->GetName());
+
+    LOG_DEBUG("Connected {}:{} -> {}:{}", connection.outputMicroservice->GetName(), connection.outputParameter->GetName(), connection.inputMicroservice->GetName(),
+        connection.inputParameter->GetName());
+
+    connection.inputParameter->value = &connection.outputParameter->value;
+    connections[connection.outputMicroservice].push_back(std::move(connection));
+  }
+
   void Connect(Microservice& outputMicroservice, Microservice& inputMicroservice, const std::string& outputParameterName, const std::string& inputParameterName)
   {
     auto& outputParameter = outputMicroservice.GetOutputParameter(outputParameterName);
     auto& inputParameter = inputMicroservice.GetInputParameter(inputParameterName);
     MicroserviceConnection connection(&outputMicroservice, &inputMicroservice, &outputParameter, &inputParameter);
-    if (connections.contains(&outputMicroservice))
-      if (std::ranges::any_of(connections.at(&outputMicroservice), [&connection](auto& conn) { return conn == connection; }))
-        return LOG_WARNING("Ignoring duplicate connection {}:{} -> {}:{}", outputMicroservice.GetName(), outputParameterName, inputMicroservice.GetName(), inputParameterName);
-
-    connection.Connect();
-    connections[&outputMicroservice].push_back(std::move(connection));
+    Connect(std::move(connection));
   }
 
   void Connect(Microservice& outputMicroservice, Microservice& inputMicroservice)
   {
-    MicroserviceConnection connection(&outputMicroservice, &inputMicroservice, &outputMicroservice.finish, &inputMicroservice.start);
-    if (connections.contains(&outputMicroservice))
-      if (std::ranges::any_of(connections.at(&outputMicroservice), [&connection](auto& conn) { return conn == connection; }))
-        return LOG_WARNING("Ignoring duplicate connection {}:{} -> {}:{}", connection.outputMicroservice->GetName(), connection.outputParameter->GetName(),
-            connection.inputMicroservice->GetName(), connection.inputParameter->GetName());
-
-    connection.Connect();
-    connections[&outputMicroservice].push_back(std::move(connection));
+    MicroserviceConnection connection(&outputMicroservice, &inputMicroservice, &outputMicroservice.GetFinishParameter(), &inputMicroservice.GetStartParameter());
+    Connect(std::move(connection));
   }
 
   void Connect(uintptr_t outputId, uintptr_t inputId)
   {
+    // TODO: remove this and use pin.aspointer
     MicroserviceConnection connection;
-    bool outputFound = false;
-    bool inputFound = false;
     for (const auto& microservice : microservices)
     {
-      if (microservice->finish.GetId() == outputId)
+      if (microservice->GetFinishParameter().GetId() == outputId)
       {
         connection.outputMicroservice = microservice.get();
-        connection.outputParameter = &microservice->finish;
-        outputFound = true;
+        connection.outputParameter = &microservice->GetFinishParameter();
       }
       else
       {
@@ -130,17 +142,15 @@ class Workflow
           {
             connection.outputMicroservice = microservice.get();
             connection.outputParameter = &param;
-            outputFound = true;
             break;
           }
         }
       }
 
-      if (microservice->start.GetId() == inputId)
+      if (microservice->GetStartParameter().GetId() == inputId)
       {
         connection.inputMicroservice = microservice.get();
-        connection.inputParameter = &microservice->start;
-        inputFound = true;
+        connection.inputParameter = &microservice->GetStartParameter();
       }
       else
       {
@@ -150,30 +160,18 @@ class Workflow
           {
             connection.inputMicroservice = microservice.get();
             connection.inputParameter = &param;
-            inputFound = true;
             break;
           }
         }
       }
-      if (outputFound and inputFound)
+      if (connection.outputMicroservice and connection.inputMicroservice)
         break;
     }
 
-    if (not connection.outputMicroservice)
-      return LOG_WARNING("Failed to find output parameter for id {}", outputId);
-
-    if (not connection.inputMicroservice)
-      return LOG_WARNING("Failed to find input parameter for id {}", inputId);
+    if (not connection.outputMicroservice or not connection.inputMicroservice)
+      return LOG_WARNING("Please connect outputs to inputs");
 
-    if (connections.contains(connection.outputMicroservice))
-      if (std::ranges::any_of(connections.at(connection.outputMicroservice), [&connection](auto& conn) { return conn == connection; }))
-        return LOG_WARNING("Ignoring duplicate connection {}:{} -> {}:{}", connection.outputMicroservice->GetName(), connection.outputParameter->GetName(),
-            connection.inputMicroservice->GetName(), connection.inputParameter->GetName());
-
-    connection.Connect();
-    LOG_DEBUG("Connected connection {}:{} -> {}:{}", connection.outputMicroservice->GetName(), connection.outputParameter->GetName(), connection.inputMicroservice->GetName(),
-        connection.inputParameter->GetName());
-    connections[connection.outputMicroservice].push_back(std::move(connection));
+    Connect(std::move(connection));
   }
 
   void Disconnect(uintptr_t connectionId)