source/RobotAPI/libraries/skills/core/CMakeLists.txt

@@ -15,6 +15,10 @@ armarx_add_library(
 
     SOURCES  
         error/Exception.cpp
+        executor/FluxioExecutor.cpp
+        executor/FluxioNativeExecutor.cpp
+        executor/FluxioCompositeExecutor.cpp
+        executor/FluxioMergerExecutor.cpp
         SkillID.cpp
         ProviderID.cpp
         ProviderInfo.cpp
@@ -39,6 +43,10 @@ armarx_add_library(
         FluxioSkillStatusUpdate.cpp
     HEADERS
         error/Exception.h
+        executor/FluxioExecutor.h
+        executor/FluxioNativeExecutor.h
+        executor/FluxioCompositeExecutor.h
+        executor/FluxioMergerExecutor.h
         SkillID.h
         ProviderID.h
         ProviderInfo.h

source/RobotAPI/libraries/skills/manager/FluxioCompositeExecutor.cpp → source/RobotAPI/libraries/skills/core/executor/FluxioCompositeExecutor.cpp

@@ -10,17 +10,24 @@
 
 #include <ArmarXCore/core/logging/Logging.h>
 
-#include "RobotAPI/libraries/skills/core/FluxioControlNode.h"
-#include "RobotAPI/libraries/skills/core/FluxioEdge.h"
-#include "RobotAPI/libraries/skills/core/FluxioParameter.h"
-#include "RobotAPI/libraries/skills/manager/FluxioMergerExecutor.h"
+#include "../FluxioControlNode.h"
+#include "../FluxioEdge.h"
+#include "../FluxioParameter.h"
+#include "FluxioMergerExecutor.h"
 
-namespace armarx::plugins
+namespace armarx::skills
 {
-    FluxioCompositeExecutor::FluxioCompositeExecutor(std::string& id,
-                                                     SkillManagerComponentPlugin* plugin,
-                                                     skills::FluxioSkill* skill) :
-        FluxioExecutor(id, plugin, false), skill(skill)
+    FluxioCompositeExecutor::FluxioCompositeExecutor(
+        std::string& id,
+        skills::FluxioSkill* skill,
+        const std::function<void(const std::string& executionId)>&& abortFluxioSkillFunc,
+        const std::function<FluxioExecutor*(const std::string& skillId,
+                                            const std::string& executorName)>&&
+            executeFluxioSkillFunc) :
+        FluxioExecutor(id, false),
+        skill(skill),
+        abortFluxioSkill(abortFluxioSkillFunc),
+        executeFluxioSkill(executeFluxioSkillFunc)
     {
     }
 
@@ -222,7 +229,7 @@ namespace armarx::plugins
         }
 
         // start skill execution
-        auto* executorPtr = plugin->executeFluxioSkill(subSkillNode->skillPtr->id, executorName);
+        auto* executorPtr = executeFluxioSkill(subSkillNode->skillPtr->id, executorName);
         if (executorPtr == nullptr)
         {
             ARMARX_WARNING << "Failed to execute subskill " << subSkillNode->skillPtr->id;
@@ -392,7 +399,7 @@ namespace armarx::plugins
 
                 // there is no execution for the merger yet, let´s start one
                 subExecutionsMap[controlNode->nodeId] =
-                    new FluxioMergerExecutor(IceUtil::generateUUID(), plugin, paramIds);
+                    new FluxioMergerExecutor(IceUtil::generateUUID(), paramIds);
 
                 mergerExecutorPtr =
                     dynamic_cast<FluxioMergerExecutor*>(subExecutionsMap[controlNode->nodeId]);
@@ -640,4 +647,4 @@ namespace armarx::plugins
         this->status = update;
         this->statusUpdates.push_front(update);
     }
-} // namespace armarx::plugins
+} // namespace armarx::skills

source/RobotAPI/libraries/skills/manager/FluxioCompositeExecutor.h → source/RobotAPI/libraries/skills/core/executor/FluxioCompositeExecutor.h

@@ -4,28 +4,28 @@
 #include <optional>
 #include <string>
 
-#include "RobotAPI/libraries/skills/core/FluxioControlNode.h"
-#include "RobotAPI/libraries/skills/core/FluxioParameter.h"
-#include "RobotAPI/libraries/skills/core/FluxioParameterNode.h"
-#include "RobotAPI/libraries/skills/core/FluxioSkill.h"
-#include "RobotAPI/libraries/skills/core/FluxioSkillStatusUpdate.h"
-#include "RobotAPI/libraries/skills/core/FluxioSubSkillNode.h"
-#include "RobotAPI/libraries/skills/core/SkillExecutionID.h"
-#include "RobotAPI/libraries/skills/core/SkillStatusUpdate.h"
-
+#include "../FluxioControlNode.h"
+#include "../FluxioParameter.h"
+#include "../FluxioParameterNode.h"
+#include "../FluxioSkill.h"
+#include "../FluxioSkillStatusUpdate.h"
+#include "../FluxioSubSkillNode.h"
+#include "../SkillExecutionID.h"
+#include "../SkillStatusUpdate.h"
 #include "FluxioExecutor.h"
-#include "SkillManagerComponentPlugin.h"
 
-namespace armarx::plugins
+namespace armarx::skills
 {
-    class SkillManagerComponentPlugin; // forward declaration
-
     class FluxioCompositeExecutor : public FluxioExecutor
     {
     public:
-        FluxioCompositeExecutor(std::string& id,
-                                SkillManagerComponentPlugin* plugin,
-                                skills::FluxioSkill* skill);
+        FluxioCompositeExecutor(
+            std::string& id,
+            skills::FluxioSkill* skill,
+            const std::function<void(const std::string& executionId)>&& abortFluxioSkillFunc,
+            const std::function<FluxioExecutor*(const std::string& skillId,
+                                                const std::string& executorName)>&&
+                executeFluxioSkillFunc);
         void run(const std::string executorName, armarx::aron::data::DictPtr parameters) override;
         void abort() override;
         std::optional<std::vector<skills::FluxioSkillStatusUpdate>> getStatusUpdate() override;
@@ -54,5 +54,9 @@ namespace armarx::plugins
         void setStatus(skills::SkillStatus status) override;
         void pollSubStatuses();
         std::map<std::string, FluxioExecutor*> subExecutionsMap; // key is node id
+        const std::function<void(const std::string& executionId)> abortFluxioSkill;
+        const std::function<FluxioExecutor*(const std::string& skillId,
+                                            const std::string& executorName)>
+            executeFluxioSkill;
     };
-} // namespace armarx::plugins
+} // namespace armarx::skills

source/RobotAPI/libraries/skills/manager/FluxioExecutor.h → source/RobotAPI/libraries/skills/core/executor/FluxioExecutor.h

 #pragma once
 
+#include <list>
 #include <string>
 #include <vector>
 
-#include "RobotAPI/libraries/skills/core/FluxioSkillStatusUpdate.h"
+#include "../FluxioSkillStatusUpdate.h"
 
-#include "SkillManagerComponentPlugin.h"
-
-namespace armarx::plugins
+namespace armarx::skills
 {
-    class SkillManagerComponentPlugin; // forward declaration
-
     class FluxioExecutor
     {
     public:
         virtual ~FluxioExecutor(){};
 
-        FluxioExecutor(const std::string& id, SkillManagerComponentPlugin* plugin, bool native) :
-            id(id), native(native), plugin(plugin){};
-        virtual void run(const std::string executorName, armarx::aron::data::DictPtr parameters){};
-        virtual void abort(){};
+        FluxioExecutor(const std::string& id, bool native) : id(id), native(native){};
+        virtual void run(const std::string executorName, armarx::aron::data::DictPtr parameters) {};
+        virtual void abort() {};
 
         virtual std::optional<std::vector<skills::FluxioSkillStatusUpdate>>
         getStatusUpdate()
@@ -39,8 +35,7 @@ namespace armarx::plugins
     protected:
         std::list<skills::FluxioSkillStatusUpdate> statusUpdates;
         std::string* executorName = nullptr;
-        SkillManagerComponentPlugin* plugin = nullptr;
         std::optional<skills::FluxioSkillStatusUpdate> status = std::nullopt;
-        virtual void setStatus(skills::SkillStatus status){};
+        virtual void setStatus(skills::SkillStatus status) {};
     };
-} // namespace armarx::plugins
+} // namespace armarx::skills

source/RobotAPI/libraries/skills/manager/FluxioMergerExecutor.cpp → source/RobotAPI/libraries/skills/core/executor/FluxioMergerExecutor.cpp

@@ -6,20 +6,20 @@
 
 #include <ArmarXCore/core/logging/Logging.h>
 
-#include "RobotAPI/libraries/skills/core/SkillStatusUpdate.h"
+#include "../SkillStatusUpdate.h"
 
-namespace armarx::plugins
+namespace armarx::skills
 {
     FluxioMergerExecutor::FluxioMergerExecutor(const std::string& id,
-                                               SkillManagerComponentPlugin* plugin,
                                                const std::vector<std::string>& parameterIds) :
-        FluxioExecutor(id, plugin, false)
+        FluxioExecutor(id, false)
     {
         for (const auto& id : parameterIds)
         {
             tokenHasArrivedMap[id] = false;
         }
-        ARMARX_WARNING << "Fluxio Merger is waiting for the following tokens to arrive: " << parameterIds;
+        ARMARX_WARNING << "Fluxio Merger is waiting for the following tokens to arrive: "
+                       << parameterIds;
     }
 
     void
@@ -94,4 +94,4 @@ namespace armarx::plugins
             armarx::DateTime::Now(), this->id, "noIdNeeded", status};
         this->status = update;
     }
-} // namespace armarx::plugins
+} // namespace armarx::skills

source/RobotAPI/libraries/skills/manager/FluxioMergerExecutor.h → source/RobotAPI/libraries/skills/core/executor/FluxioMergerExecutor.h

@@ -3,21 +3,15 @@
 #include <optional>
 #include <string>
 
-#include "RobotAPI/libraries/skills/core/FluxioSkillStatusUpdate.h"
-
+#include "../FluxioSkillStatusUpdate.h"
 #include "FluxioExecutor.h"
-#include "SkillManagerComponentPlugin.h"
 
-namespace armarx::plugins
+namespace armarx::skills
 {
-    class SkillManagerComponentPlugin; // forward declaration
-
     class FluxioMergerExecutor : public FluxioExecutor
     {
     public:
-        FluxioMergerExecutor(const std::string& id,
-                             SkillManagerComponentPlugin* plugin,
-                             const std::vector<std::string>& parameterIds);
+        FluxioMergerExecutor(const std::string& id, const std::vector<std::string>& parameterIds);
 
         void run(const std::string executorName, armarx::aron::data::DictPtr parameters) override;
         void abort() override;
@@ -28,4 +22,4 @@ namespace armarx::plugins
         void setStatus(skills::SkillStatus status) override;
         std::map<std::string, bool> tokenHasArrivedMap; // keys are parameterIds
     };
-} // namespace armarx::plugins
+} // namespace armarx::skills

source/RobotAPI/libraries/skills/manager/FluxioNativeExecutor.cpp → source/RobotAPI/libraries/skills/core/executor/FluxioNativeExecutor.cpp

@@ -4,29 +4,40 @@
 
 #include <ArmarXCore/core/logging/Logging.h>
 
-#include "RobotAPI/libraries/skills/core/ProviderID.h"
-#include "RobotAPI/libraries/skills/core/SkillExecutionRequest.h"
-#include "RobotAPI/libraries/skills/core/SkillID.h"
+#include "../ProviderID.h"
+#include "../SkillExecutionRequest.h"
+#include "../SkillID.h"
 
-namespace armarx::plugins
+namespace armarx::skills
 {
-    FluxioNativeExecutor::FluxioNativeExecutor(std::string& id,
-                                               SkillManagerComponentPlugin* plugin,
-                                               skills::SkillID& skillId,
-                                               std::string& fluxioUUID) :
-        FluxioExecutor(id, plugin, true), skillId(skillId), fluxioUUID(fluxioUUID)
+    FluxioNativeExecutor::FluxioNativeExecutor(
+        std::string& id,
+        skills::SkillID& skillId,
+        std::string& fluxioUUID,
+        const std::function<bool(const skills::SkillExecutionID&)>&& abortSkillFunc,
+        const std::function<skills::SkillExecutionID(const skills::SkillExecutionRequest&)>&&
+            executeSkillAsyncFunc,
+        const std::function<std::optional<skills::SkillStatusUpdate>(
+            const skills::SkillExecutionID&)>&& getSkillExecutionStatusFunc) :
+        FluxioExecutor(id, true),
+        skillId(skillId),
+        fluxioUUID(fluxioUUID),
+        abortSkill(abortSkillFunc),
+        executeSkillAsync(executeSkillAsyncFunc),
+        getSkillExecutionStatus(getSkillExecutionStatusFunc)
     {
     }
 
     void
-    FluxioNativeExecutor::run(const std::string executorName, armarx::aron::data::DictPtr parameters)
+    FluxioNativeExecutor::run(const std::string executorName,
+                              armarx::aron::data::DictPtr parameters)
     {
         skills::SkillExecutionRequest req;
         req.skillId = skillId;
         req.parameters = parameters;
         req.executorName = executorName;
 
-        auto eid = this->plugin->executeSkillAsync(req);
+        auto eid = executeSkillAsync(req);
 
         this->executionId = eid;
     }
@@ -34,7 +45,7 @@ namespace armarx::plugins
     void
     FluxioNativeExecutor::abort()
     {
-        if (!this->executionId.has_value() || this->plugin == nullptr)
+        if (!this->executionId.has_value())
         {
             // error
             ARMARX_WARNING << "Execution ID or plugin is not set";
@@ -42,13 +53,13 @@ namespace armarx::plugins
         }
 
         // TODO: check last execution status
-        this->plugin->abortSkill(this->executionId.value());
+        abortSkill(this->executionId.value());
     }
 
     std::optional<std::vector<skills::FluxioSkillStatusUpdate>>
     FluxioNativeExecutor::getStatusUpdate()
     {
-        if (!this->executionId.has_value() || this->plugin == nullptr)
+        if (!this->executionId.has_value())
         {
             // error
             ARMARX_WARNING << "Execution ID or plugin is not set";
@@ -57,7 +68,7 @@ namespace armarx::plugins
 
         auto executionId = this->executionId.value();
 
-        auto status = this->plugin->getSkillExecutionStatus(executionId);
+        auto status = getSkillExecutionStatus(executionId);
 
         if (!status.has_value())
         {
@@ -88,4 +99,4 @@ namespace armarx::plugins
         this->status = update;
         this->statusUpdates.push_front(update);
     }
-} // namespace armarx::plugins
+} // namespace armarx::skills

source/RobotAPI/libraries/skills/manager/FluxioNativeExecutor.h → source/RobotAPI/libraries/skills/core/executor/FluxioNativeExecutor.h

@@ -3,23 +3,28 @@
 #include <optional>
 #include <string>
 
-#include "RobotAPI/libraries/skills/core/FluxioSkillStatusUpdate.h"
-#include "RobotAPI/libraries/skills/core/SkillExecutionID.h"
+#include "RobotAPI/libraries/skills/core/SkillExecutionRequest.h"
+#include "RobotAPI/libraries/skills/core/SkillID.h"
+#include "RobotAPI/libraries/skills/core/SkillStatusUpdate.h"
 
+#include "../FluxioSkillStatusUpdate.h"
+#include "../SkillExecutionID.h"
 #include "FluxioExecutor.h"
-#include "SkillManagerComponentPlugin.h"
 
-namespace armarx::plugins
+namespace armarx::skills
 {
-    class SkillManagerComponentPlugin; // forward declaration
-
     class FluxioNativeExecutor : public FluxioExecutor
     {
     public:
-        FluxioNativeExecutor(std::string& id,
-                             SkillManagerComponentPlugin* plugin,
-                             skills::SkillID& skillId,
-                             std::string& fluxioUUID);
+        FluxioNativeExecutor(
+            std::string& id,
+            skills::SkillID& skillId,
+            std::string& fluxioUUID,
+            const std::function<bool(const skills::SkillExecutionID&)>&& abortSkillFunc,
+            const std::function<skills::SkillExecutionID(const skills::SkillExecutionRequest&)>&&
+                executeSkillAsyncFunc,
+            const std::function<std::optional<skills::SkillStatusUpdate>(
+                const skills::SkillExecutionID&)>&& getSkillExecutionStatusFunc);
 
         void run(const std::string executorName, armarx::aron::data::DictPtr parameters) override;
         void abort() override;
@@ -30,7 +35,11 @@ namespace armarx::plugins
         skills::SkillID skillId;
         std::string fluxioUUID;
         void setStatus(skills::SkillStatus status) override;
-
-        //std::function<void(skills::SkillID&)> foo;
+        const std::function<bool(const skills::SkillExecutionID&)> abortSkill;
+        const std::function<skills::SkillExecutionID(const skills::SkillExecutionRequest&)>
+            executeSkillAsync;
+        const std::function<std::optional<skills::SkillStatusUpdate>(
+            const skills::SkillExecutionID&)>
+            getSkillExecutionStatus;
     };
-} // namespace armarx::plugins
+} // namespace armarx::skills

source/RobotAPI/libraries/skills/manager/CMakeLists.txt

@@ -18,17 +18,9 @@ armarx_add_library(
     SOURCES
         SkillManagerComponentPlugin.cpp
         SkillManagerComponentPluginUser.cpp
-        FluxioExecutor.cpp
-        FluxioNativeExecutor.cpp
-        FluxioCompositeExecutor.cpp
-        FluxioMergerExecutor.cpp
     HEADERS
         SkillManagerComponentPlugin.h
         SkillManagerComponentPluginUser.h
-        FluxioExecutor.h
-        FluxioNativeExecutor.h
-        FluxioCompositeExecutor.h
-        FluxioMergerExecutor.h
 )
 
 add_library(RobotAPI::skills::manager ALIAS RobotAPISkillsManager)

source/RobotAPI/libraries/skills/manager/SkillManagerComponentPlugin.cpp

@@ -28,15 +28,14 @@
 #include "RobotAPI/libraries/skills/core/FluxioProvider.h"
 #include "RobotAPI/libraries/skills/core/FluxioSkill.h"
 #include "RobotAPI/libraries/skills/core/FluxioValue.h"
-#include "RobotAPI/libraries/skills/manager/FluxioCompositeExecutor.h"
-#include "RobotAPI/libraries/skills/manager/FluxioExecutor.h"
+#include "RobotAPI/libraries/skills/core/executor/FluxioCompositeExecutor.h"
+#include "RobotAPI/libraries/skills/core/executor/FluxioExecutor.h"
+#include "RobotAPI/libraries/skills/core/executor/FluxioNativeExecutor.h"
 #include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
 #include <RobotAPI/libraries/skills/core/SkillID.h>
 #include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
 #include <RobotAPI/libraries/skills/core/error/Exception.h>
 
-#include "FluxioNativeExecutor.h"
-
 namespace armarx::plugins
 {
     void
@@ -619,8 +618,8 @@ namespace armarx::plugins
     //** Fluxio related methods **//
     //****************************//
 
-    FluxioExecutor*
-    SkillManagerComponentPlugin::executeFluxioSkill(std::string skillId,
+    skills::FluxioExecutor*
+    SkillManagerComponentPlugin::executeFluxioSkill(const std::string& skillId,
                                                     const std::string& executorName)
     {
         const auto& skill = getSkill(skillId);
@@ -637,8 +636,18 @@ namespace armarx::plugins
             // currently empty parameters
             armarx::aron::data::DictPtr emptyParameters = {};
 
+            const auto& executeFluxioSkillFunc =
+                [this](const std::string& skillId, const std::string& executorName)
+            { return this->executeFluxioSkill(skillId, executorName); };
+
+            const auto& abortFluxioSkill = [this](const std::string& executionId)
+            { this->abortFluxioSkill(executionId); };
+
             fluxioDC.fluxioExecutors[executionId] =
-                new FluxioCompositeExecutor(executionId, this, &fluxioDC.skills[skillId]);
+                new skills::FluxioCompositeExecutor(executionId,
+                                                    &fluxioDC.skills[skillId],
+                                                    std::move(abortFluxioSkill),
+                                                    std::move(executeFluxioSkillFunc));
 
             std::thread(
                 [this, executionId, executorName, emptyParameters]()
@@ -659,10 +668,26 @@ namespace armarx::plugins
                 return nullptr;
             }
 
+            const auto& abortSkillFunc = [this](const skills::SkillExecutionID& executionId)
+            { return this->abortSkill(executionId); };
+
+            const auto& executeSkillAsyncFunc = [this](const skills::SkillExecutionRequest& req)
+            { return this->executeSkillAsync(req); };
+
+            const auto& getSkillExecutionStatusFunc =
+                [this](const skills::SkillExecutionID& executionId)
+            { return this->getSkillExecutionStatus(executionId); };
+
+
             // FIXME: do not use new, instead use smart pointer
             std::string fluxioSkillUUID = skill->id;
             fluxioDC.fluxioExecutors[executionId] =
-                new FluxioNativeExecutor(executionId, this, sID, fluxioSkillUUID);
+                new skills::FluxioNativeExecutor(executionId,
+                                                 sID,
+                                                 fluxioSkillUUID,
+                                                 std::move(abortSkillFunc),
+                                                 std::move(executeSkillAsyncFunc),
+                                                 std::move(getSkillExecutionStatusFunc));
             fluxioDC.fluxioExecutors[executionId]->run(executorName,
                                                        skillDescr->rootProfileDefaults);
         }
@@ -680,13 +705,13 @@ namespace armarx::plugins
             return;
         }
 
-        FluxioExecutor* executorPtr = executorIt->second;
+        skills::FluxioExecutor* executorPtr = executorIt->second;
         if (executorPtr->native)
         {
-            FluxioNativeExecutor* castedExecutor = nullptr;
+            skills::FluxioNativeExecutor* castedExecutor = nullptr;
             try
             {
-                castedExecutor = dynamic_cast<FluxioNativeExecutor*>(executorPtr);
+                castedExecutor = dynamic_cast<skills::FluxioNativeExecutor*>(executorPtr);
                 if (castedExecutor == nullptr)
                 {
                     ARMARX_WARNING << "Executor with id '" << executionId
@@ -705,10 +730,10 @@ namespace armarx::plugins
         }
         else
         {
-            FluxioCompositeExecutor* castedExecutor = nullptr;
+            skills::FluxioCompositeExecutor* castedExecutor = nullptr;
             try
             {
-                castedExecutor = dynamic_cast<FluxioCompositeExecutor*>(executorPtr);
+                castedExecutor = dynamic_cast<skills::FluxioCompositeExecutor*>(executorPtr);
                 if (castedExecutor == nullptr)
                 {
                     ARMARX_WARNING << "Executor with id '" << executionId
@@ -737,13 +762,13 @@ namespace armarx::plugins
             return std::nullopt;
         }
 
-        FluxioExecutor* executorPtr = executorIt->second;
+        skills::FluxioExecutor* executorPtr = executorIt->second;
         if (executorPtr->native)
         {
-            FluxioNativeExecutor* castedExecutor = nullptr;
+            skills::FluxioNativeExecutor* castedExecutor = nullptr;
             try
             {
-                castedExecutor = dynamic_cast<FluxioNativeExecutor*>(executorPtr);
+                castedExecutor = dynamic_cast<skills::FluxioNativeExecutor*>(executorPtr);
                 if (castedExecutor == nullptr)
                 {
                     ARMARX_WARNING << "Executor with id '" << executionId
@@ -761,10 +786,10 @@ namespace armarx::plugins
             return castedExecutor->getStatusUpdate();
         }
 
-        FluxioCompositeExecutor* castedExecutor = nullptr;
+        skills::FluxioCompositeExecutor* castedExecutor = nullptr;
         try
         {
-            castedExecutor = dynamic_cast<FluxioCompositeExecutor*>(executorPtr);
+            castedExecutor = dynamic_cast<skills::FluxioCompositeExecutor*>(executorPtr);
             if (castedExecutor == nullptr)
             {
                 ARMARX_WARNING << "Executor with id '" << executionId

source/RobotAPI/libraries/skills/manager/SkillManagerComponentPlugin.h

@@ -3,6 +3,7 @@
 #include <mutex>
 #include <optional>
 #include <string>
+
 #include <boost/uuid/uuid.hpp>
 
 #include <ArmarXCore/core/ComponentPlugin.h>
@@ -22,8 +23,8 @@
 #include <RobotAPI/libraries/skills/core/ProviderInfo.h>
 #include <RobotAPI/libraries/skills/core/SkillExecutionRequest.h>
 #include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
+#include <RobotAPI/libraries/skills/core/executor/FluxioExecutor.h>
 
-#include "FluxioExecutor.h"
 #include "SkillManagerComponentPluginUser.h"
 
 namespace armarx
@@ -33,8 +34,6 @@ namespace armarx
 
 namespace armarx::plugins
 {
-    class FluxioExecutor; // forward declaration
-
     class SkillManagerComponentPlugin : public ComponentPlugin
     {
     public:
@@ -76,8 +75,8 @@ namespace armarx::plugins
         //** Fluxio related methods **//
         //****************************//
 
-        FluxioExecutor* executeFluxioSkill(std::string skillId,
-                                                      const std::string& executorName);
+        skills::FluxioExecutor* executeFluxioSkill(const std::string& skillId,
+                                                   const std::string& executorName);
 
         void abortFluxioSkill(const std::string& executionId);
 
@@ -121,12 +120,12 @@ namespace armarx::plugins
     private:
         struct FluxioDataCollector
         {
-            std::map<std::string, skills::FluxioSkill> skills = {};
-            std::map<std::string, skills::FluxioProfile> profiles = {};
-            std::map<std::string, skills::FluxioProvider> providers = {};
-            std::map<std::string, std::tuple<std::string, armarx::DateTime>> skillMutexMap = {};
+            std::map<std::string, skills::FluxioSkill> skills;
+            std::map<std::string, skills::FluxioProfile> profiles;
+            std::map<std::string, skills::FluxioProvider> providers;
+            std::map<std::string, std::tuple<std::string, armarx::DateTime>> skillMutexMap;
             const std::int64_t mutexTimeout = 30; // minutes
-            std::map<std::string, FluxioExecutor*> fluxioExecutors = {};
+            std::map<std::string, skills::FluxioExecutor*> fluxioExecutors;
         };
 
         FluxioDataCollector fluxioDC = {};
@@ -141,7 +140,8 @@ namespace armarx::plugins
         std::vector<T> convertMapValuesToVector(std::map<S, T>& map);
 
         static boost::uuids::uuid
-        createUuidWithString(const std::string& str, std::optional<const boost::uuids::uuid> namespaceUUID = std::nullopt);
+        createUuidWithString(const std::string& str,
+                             std::optional<const boost::uuids::uuid> namespaceUUID = std::nullopt);
 
         static void
         convertAronObjectPtrToFluxioParameters(std::map<std::string, skills::FluxioParameter>& ret,