source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp

@@ -266,6 +266,16 @@ namespace armarx::aron::type
         return "armarx::aron::type::Object<" + this->aron->objectName + (extends ? (" : " + extends->getFullName()) : "") + ">";
     }
 
+    std::string Object::GetFullNamePrefix()
+    {
+        return "armarx::aron::type::Object";
+    }
+
+    std::string Object::GetNamePrefix()
+    {
+        return "Object";
+    }
+
     VariantPtr Object::navigateAbsolute(const Path& path) const
     {
         if (!path.hasElement())

source/RobotAPI/libraries/aron/core/type/variant/container/Object.h

@@ -86,6 +86,9 @@ namespace armarx::aron::type
         std::vector<VariantPtr> getChildren() const override;
         size_t childrenSize() const override;
 
+        static std::string GetFullNamePrefix();
+        static std::string GetNamePrefix();
+
     private:
         // members
         std::shared_ptr<Object> extends;

source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp

@@ -115,6 +115,16 @@ namespace armarx::aron::type
         return "armarx::aron::type::Pair<" + acceptedType1->getFullName() + ", " + acceptedType2->getFullName() + ">";
     }
 
+    std::string Pair::GetFullNamePrefix()
+    {
+        return "armarx::aron::type::Pair";
+    }
+
+    std::string Pair::GetNamePrefix()
+    {
+        return "Pair";
+    }
+
     VariantPtr Pair::navigateAbsolute(const Path& path) const
     {
         if (!path.hasElement())

source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h

@@ -62,6 +62,9 @@ namespace armarx::aron::type
         std::vector<VariantPtr> getChildren() const override;
         size_t childrenSize() const override;
 
+        static std::string GetFullNamePrefix();
+        static std::string GetNamePrefix();
+
     private:
         // members
         VariantPtr acceptedType1;

source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp

@@ -112,6 +112,16 @@ namespace armarx::aron::type
         return "armarx::aron::type::Tuple<" + simox::alg::to_string(names, ", ") + ">";
     }
 
+    std::string Tuple::GetFullNamePrefix()
+    {
+        return "armarx::aron::type::Tuple";
+    }
+
+    std::string Tuple::GetNamePrefix()
+    {
+        return "Tuple";
+    }
+
     VariantPtr Tuple::navigateAbsolute(const Path& path) const
     {
         if (!path.hasElement())

source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h

@@ -60,6 +60,9 @@ namespace armarx::aron::type
         std::vector<VariantPtr> getChildren() const override;
         size_t childrenSize() const override;
 
+        static std::string GetFullNamePrefix();
+        static std::string GetNamePrefix();
+
     private:
         std::vector<VariantPtr> acceptedTypes;
     };

source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h

@@ -31,5 +31,7 @@ namespace armarx::aron::type
     using StringPtr = std::shared_ptr<class String>;
     using BoolPtr = std::shared_ptr<class Bool>;
 
+    using AnyObjectPtr = std::shared_ptr<class AnyObject>;
+
 }
 

source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h

@@ -151,9 +151,6 @@ namespace armarx::aron::type
         virtual void visitMatrix(Input&) {};
         virtual void visitNDArray(Input&) {};
         virtual void visitQuaternion(Input&) {};
-        virtual void visitOrientation(Input&) {};
-        virtual void visitPosition(Input&) {};
-        virtual void visitPose(Input&) {};
         virtual void visitImage(Input&) {};
         virtual void visitPointCloud(Input&) {};
         virtual void visitIntEnum(Input&) {};

source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp

@@ -147,6 +147,12 @@ namespace armarx::aron::type
         visitAronVariant(aron);
     }
 
+    void ConstVariantVisitor::visitAnyObject(Input& i)
+    {
+        auto aron = type::AnyObject::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
     void ConstVariantVisitor::visitAronVariant(const type::ObjectPtr&) {}
     void ConstVariantVisitor::visitAronVariant(const type::DictPtr&) {}
     void ConstVariantVisitor::visitAronVariant(const type::PairPtr&) {}
@@ -164,6 +170,7 @@ namespace armarx::aron::type
     void ConstVariantVisitor::visitAronVariant(const type::DoublePtr&) {}
     void ConstVariantVisitor::visitAronVariant(const type::BoolPtr&) {}
     void ConstVariantVisitor::visitAronVariant(const type::StringPtr&) {}
+    void ConstVariantVisitor::visitAronVariant(const type::AnyObjectPtr&) {}
 
     /****************************************************************************
      * RecursiveVariantVisitor
@@ -227,4 +234,166 @@ namespace armarx::aron::type
     {
         return GetTupleAcceptedTypes(t);
     }
+
+    void RecursiveConstVariantVisitor::visitObjectOnEnter(Input& i)
+    {
+        auto aron = type::Object::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitObjectOnExit(Input& i)
+    {
+        auto aron = type::Object::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitDictOnEnter(Input& i)
+    {
+        auto aron = type::Dict::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitDictOnExit(Input& i)
+    {
+        auto aron = type::Dict::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitPairOnEnter(Input& i)
+    {
+        auto aron = type::Pair::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitPairOnExit(Input& i)
+    {
+        auto aron = type::Pair::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitTupleOnEnter(Input& i)
+    {
+        auto aron = type::Tuple::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitTupleOnExit(Input& i)
+    {
+        auto aron = type::Tuple::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitListOnEnter(Input& i)
+    {
+        auto aron = type::List::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitListOnExit(Input& i)
+    {
+        auto aron = type::List::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitMatrix(Input& i)
+    {
+        auto aron = type::Matrix::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitNDArray(Input& i)
+    {
+        auto aron = type::NDArray::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitQuaternion(Input & i)
+    {
+        auto aron = type::Quaternion::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitImage(Input& i)
+    {
+        auto aron = type::Image::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitPointCloud(Input& i)
+    {
+        auto aron = type::PointCloud::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitIntEnum(Input& i)
+    {
+        auto aron = type::IntEnum::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitInt(Input& i)
+    {
+        auto aron = type::Int::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitLong(Input& i)
+    {
+        auto aron = type::Long::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitFloat(Input& i)
+    {
+        auto aron = type::Float::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitDouble(Input& i)
+    {
+        auto aron = type::Double::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitBool(Input& i)
+    {
+        auto aron = type::Bool::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitString(Input& i)
+    {
+        auto aron = type::String::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitAnyObject(Input& i)
+    {
+        auto aron = type::AnyObject::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::ObjectPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::ObjectPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::DictPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::DictPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::PairPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::PairPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::TuplePtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::TuplePtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::ListPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::ListPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::NDArrayPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::MatrixPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::QuaternionPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::ImagePtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::PointCloudPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::IntEnumPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::IntPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::LongPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::FloatPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::DoublePtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::BoolPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::StringPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::AnyObjectPtr&) {}
 }

source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h

@@ -60,6 +60,7 @@ namespace armarx::aron::type
         void visitDouble(Input&) override;
         void visitBool(Input&) override;
         void visitString(Input&) override;
+        void visitAnyObject(Input&) override;
 
         // Use these if you do not want to cast manually
         virtual void visitAronVariant(const type::ObjectPtr&);
@@ -79,6 +80,7 @@ namespace armarx::aron::type
         virtual void visitAronVariant(const type::DoublePtr&);
         virtual void visitAronVariant(const type::BoolPtr&);
         virtual void visitAronVariant(const type::StringPtr&);
+        virtual void visitAronVariant(const type::AnyObjectPtr&);
     };
 
     /**
@@ -98,6 +100,57 @@ namespace armarx::aron::type
         static TupleElements GetTupleAcceptedTypes(Input& t);
         TupleElements getTupleAcceptedTypes(Input& t) override;
 
+        void visitObjectOnEnter(Input&) override;
+        void visitObjectOnExit(Input&) override;
+        void visitDictOnEnter(Input&) override;
+        void visitDictOnExit(Input&) override;
+        void visitPairOnEnter(Input&) override;
+        void visitPairOnExit(Input&) override;
+        void visitTupleOnEnter(Input&) override;
+        void visitTupleOnExit(Input&) override;
+        void visitListOnEnter(Input&) override;
+        void visitListOnExit(Input&) override;
+
+        void visitMatrix(Input&) override;
+        void visitNDArray(Input&) override;
+        void visitQuaternion(Input&) override;
+        void visitImage(Input&) override;
+        void visitPointCloud(Input&) override;
+        void visitIntEnum(Input&) override;
+        void visitInt(Input&) override;
+        void visitLong(Input&) override;
+        void visitFloat(Input&) override;
+        void visitDouble(Input&) override;
+        void visitBool(Input&) override;
+        void visitString(Input&) override;
+        void visitAnyObject(Input&) override;
+
+
+        // Use these if you do not want to cast manually
+        virtual void visitAronVariantEnter(const type::ObjectPtr&);
+        virtual void visitAronVariantExit(const type::ObjectPtr&);
+        virtual void visitAronVariantEnter(const type::DictPtr&);
+        virtual void visitAronVariantExit(const type::DictPtr&);
+        virtual void visitAronVariantEnter(const type::ListPtr&);
+        virtual void visitAronVariantExit(const type::ListPtr&);
+        virtual void visitAronVariantEnter(const type::PairPtr&);
+        virtual void visitAronVariantExit(const type::PairPtr&);
+        virtual void visitAronVariantEnter(const type::TuplePtr&);
+        virtual void visitAronVariantExit(const type::TuplePtr&);
+        virtual void visitAronVariant(const type::MatrixPtr&);
+        virtual void visitAronVariant(const type::NDArrayPtr&);
+        virtual void visitAronVariant(const type::QuaternionPtr&);
+        virtual void visitAronVariant(const type::PointCloudPtr&);
+        virtual void visitAronVariant(const type::ImagePtr&);
+        virtual void visitAronVariant(const type::IntEnumPtr&);
+        virtual void visitAronVariant(const type::IntPtr&);
+        virtual void visitAronVariant(const type::LongPtr&);
+        virtual void visitAronVariant(const type::FloatPtr&);
+        virtual void visitAronVariant(const type::DoublePtr&);
+        virtual void visitAronVariant(const type::BoolPtr&);
+        virtual void visitAronVariant(const type::StringPtr&);
+        virtual void visitAronVariant(const type::AnyObjectPtr&);
+
         virtual ~RecursiveConstVariantVisitor() = default;
     };
 }

source/RobotAPI/libraries/aron_component_config/ComponentPlugin.h

@@ -50,7 +50,7 @@ namespace armarx::plugins
         {
             ARMARX_TRACE;
             armarx::aron::component_config::PropertyDefinitionGetterVisitor vis(
-                parent<armarx::PropertyUser>());
+                parent<armarx::PropertyUser>(), prefix());
             auto data = std::static_pointer_cast<armarx::aron::data::Variant>(
                 config_.getUpToDateReadBuffer().toAron());
             auto type = config_.getUpToDateReadBuffer().ToAronType();
@@ -65,7 +65,7 @@ namespace armarx::plugins
         postCreatePropertyDefinitions(armarx::PropertyDefinitionsPtr& properties) override
         {
             ARMARX_TRACE;
-            armarx::aron::component_config::PropertyDefinitionSetterVisitor vis(properties);
+            armarx::aron::component_config::PropertyDefinitionSetterVisitor vis(properties, prefix());
             const auto& config = config_.getUpToDateReadBuffer();
             armarx::aron::data::visitRecursive(vis, config.toAron(), config.ToAronType());
             ComponentPlugin::postCreatePropertyDefinitions(properties);

source/RobotAPI/libraries/aron_component_config/PropertyDefinitionVisitors.cpp

@@ -157,8 +157,8 @@ namespace armarx::aron::component_config
     }
 
     PropertyDefinitionGetterVisitor::PropertyDefinitionGetterVisitor(
-        const armarx::PropertyUser& defs) :
-        property_user_(std::experimental::make_observer(&defs)), in_list_(false)
+        const armarx::PropertyUser& defs, const std::string& global_namespace):
+        property_user_(std::experimental::make_observer(&defs)), global_namespace_(global_namespace), in_list_(false)
     {
     }
 
@@ -246,16 +246,16 @@ namespace armarx::aron::component_config
                                                         const std::shared_ptr<type::Variant>& j)
     {
         INPUT_GUARD(i);
-        auto t = type::Object::DynamicCastAndCheck(j);
         if (global_namespace_.empty())
         {
+            auto t = type::Object::DynamicCastAndCheck(j);
             global_namespace_ = t->getObjectNameWithoutNamespace() + ".";
         }
     }
 
     PropertyDefinitionSetterVisitor::PropertyDefinitionSetterVisitor(
-        const PropertyDefinitionsPtr& defs) :
-        property_definitions_(std::experimental::make_observer(defs.get()))
+        const PropertyDefinitionsPtr& defs, const std::string& global_namespace) :
+        property_definitions_(std::experimental::make_observer(defs.get())), global_namespace_(global_namespace)
     {
     }
 

source/RobotAPI/libraries/aron_component_config/PropertyDefinitionVisitors.h

@@ -34,7 +34,7 @@ namespace armarx::aron::component_config
     class PropertyDefinitionSetterVisitor : public aron::data::RecursiveConstTypedVariantVisitor
     {
     public:
-        explicit PropertyDefinitionSetterVisitor(const armarx::PropertyDefinitionsPtr& defs);
+        explicit PropertyDefinitionSetterVisitor(const armarx::PropertyDefinitionsPtr& defs, const std::string& global_namespace = "");
 
         void visitAronVariant(const data::IntPtr&, const type::IntEnumPtr&) override;
 
@@ -61,7 +61,7 @@ namespace armarx::aron::component_config
 
     private:
         std::experimental::observer_ptr<PropertyDefinitionContainer> property_definitions_;
-        std::string global_namespace_{""};
+        std::string global_namespace_;
         std::atomic<bool> in_list_{false};
     };
 
@@ -69,7 +69,7 @@ namespace armarx::aron::component_config
         public aron::data::RecursiveTypedVisitor<data::VariantPtr, const type::VariantPtr>
     {
     public:
-        explicit PropertyDefinitionGetterVisitor(const armarx::PropertyUser& defs);
+        explicit PropertyDefinitionGetterVisitor(const armarx::PropertyUser& defs, const std::string& global_namespace = "");
 
         type::Descriptor getDescriptor(DataInput& o, TypeInput& t) override;
 
@@ -109,7 +109,7 @@ namespace armarx::aron::component_config
 
     private:
         std::experimental::observer_ptr<const armarx::PropertyUser> property_user_;
-        std::string global_namespace_{""};
+        std::string global_namespace_;
         std::atomic<bool> in_list_;
     };
 

source/RobotAPI/libraries/skills/provider/SkillProviderComponentPlugin.cpp

@@ -6,24 +6,26 @@
 
 namespace armarx::plugins
 {
-    void SkillProviderComponentPlugin::preOnInitComponent()
+    void
+    SkillProviderComponentPlugin::preOnInitComponent()
     {
-
     }
 
-    void SkillProviderComponentPlugin::preOnConnectComponent()
+    void
+    SkillProviderComponentPlugin::preOnConnectComponent()
     {
         auto& p = parent<SkillProviderComponentPluginUser>();
         p.getProxy(myPrx, -1);
     }
 
-    void SkillProviderComponentPlugin::postOnConnectComponent()
+    void
+    SkillProviderComponentPlugin::postOnConnectComponent()
     {
         auto& p = parent<SkillProviderComponentPluginUser>();
         const std::string providerName = p.getName();
 
         // update skill ownership
-        for (auto& [skillName, impl] : p.skillImplementations)
+        for (auto& [skillName, impl] : skillImplementations)
         {
             impl.skill->manager = manager;
             impl.skill->providerName = providerName;
@@ -38,10 +40,11 @@ namespace armarx::plugins
         i.providedSkills = p.getSkillDescriptions();
         manager->addProvider(i);
 
-        p.connected = true;
+        connected = true;
     }
 
-    void SkillProviderComponentPlugin::preOnDisconnectComponent()
+    void
+    SkillProviderComponentPlugin::preOnDisconnectComponent()
     {
         auto& p = parent<SkillProviderComponentPluginUser>();
         std::string providerName = p.getName();
@@ -49,22 +52,27 @@ namespace armarx::plugins
         manager->removeProvider(providerName);
     }
 
-    void SkillProviderComponentPlugin::postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties)
+    void
+    SkillProviderComponentPlugin::postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties)
     {
         std::string prefix = "skill.";
-        properties->component(manager, "SkillMemory", prefix + "SkillManager", "The name of the SkillManager (or SkillMemory) proxy this provider belongs to.");
+        properties->component(
+            manager,
+            "SkillMemory",
+            prefix + "SkillManager",
+            "The name of the SkillManager (or SkillMemory) proxy this provider belongs to.");
     }
-}
-
 
-namespace armarx
-{
-    SkillProviderComponentPluginUser::SkillProviderComponentPluginUser()
+    void
+    SkillProviderComponentPlugin::addSkill(const skills::LambdaSkill::FunT& f,
+                                           const skills::SkillDescription& desc)
     {
-        addPlugin(plugin);
+        auto lambda = std::make_unique<skills::LambdaSkill>(f, desc);
+        addSkill(std::move(lambda));
     }
 
-    void SkillProviderComponentPluginUser::addSkill(std::unique_ptr<skills::Skill>&& skill)
+    void
+    SkillProviderComponentPlugin::addSkill(std::unique_ptr<skills::Skill>&& skill)
     {
         if (!skill)
         {
@@ -74,70 +82,119 @@ namespace armarx
         std::string skillName = skill->description.skillName;
         if (connected) // TODO: fix so that skills can be added anytime!!!
         {
-            ARMARX_WARNING << "The SkillProvider already registered to a manager. The skill '" + skillName + "' therefore cannot be added anymore. Please only add skills in the onInit method.";
+            ARMARX_WARNING << "The SkillProvider already registered to a manager. The skill '" +
+                                  skillName +
+                                  "' therefore cannot be added anymore. Please only add skills in "
+                                  "the onInit method.";
             return;
         }
 
         // lock skills map
-        std::unique_lock l(skillsMutex);
+        const std::unique_lock l(skillsMutex);
         if (skillImplementations.find(skillName) != skillImplementations.end())
         {
-            ARMARX_WARNING << "Try to add a skill '" + skillName + "' which already exists in list. Ignoring this skill.";
+            ARMARX_WARNING << "Try to add a skill '" + skillName +
+                                  "' which already exists in list. Ignoring this skill.";
             return;
         }
 
         ARMARX_INFO << "Adding skill and set owning provider name" << skillName;
         auto s = skillImplementations.emplace(skillName, std::move(skill));
-        s.first->second.statusUpdate.skillId = skills::SkillID(getName(), skillName);
+        s.first->second.statusUpdate.skillId = skills::SkillID(parent().getName(), skillName);
     }
 
-    void SkillProviderComponentPluginUser::addSkill(const skills::LambdaSkill::FunT& f, const skills::SkillDescription& desc)
+    skills::detail::SkillImplementationWrapper&
+    SkillProviderComponentPlugin::getSkill(const std::string& name)
     {
-        auto lambda = std::make_unique<skills::LambdaSkill>(f, desc);
-        addSkill(std::move(lambda));
+        ARMARX_CHECK_GREATER(skillImplementations.count(name), 0)
+            << "Skill '" + name + "' not found.";
+        const std::unique_lock l(skillsMutex);
+        return skillImplementations.at(name);
     }
 
-    skills::provider::dto::SkillDescription SkillProviderComponentPluginUser::getSkillDescription(const std::string& name, const Ice::Current &)
+    skills::provider::dto::SkillStatusUpdateMap
+    SkillProviderComponentPlugin::getSkillExecutionStatuses() const
     {
-        std::shared_lock l(skillsMutex);
-        const auto& skillWrapper = skillImplementations.at(name);
-        return skillWrapper.skill->description.toIce();
+        skills::provider::dto::SkillStatusUpdateMap skillUpdates;
+        const std::unique_lock l(skillsMutex);
+        for (const auto& [key, impl] : skillImplementations)
+        {
+            const std::shared_lock l2(impl.skillStatusMutex);
+            skillUpdates.insert({key, impl.statusUpdate.toIce()});
+        }
+        return skillUpdates;
     }
 
-    skills::provider::dto::SkillDescriptionMap SkillProviderComponentPluginUser::getSkillDescriptions(const Ice::Current &)
+    skills::provider::dto::SkillDescriptionMap
+    SkillProviderComponentPlugin::getSkillDescriptions() const
     {
-        std::shared_lock l(skillsMutex);
         skills::provider::dto::SkillDescriptionMap skillDesciptions;
-        for (const auto& [key, skillWrapper] : skillImplementations)
+        const std::unique_lock l(skillsMutex);
+        for (const auto& [key, impl] : skillImplementations)
         {
-            skillDesciptions.insert({key, skillWrapper.skill->description.toIce()});
+            skillDesciptions.insert({key, impl.skill->description.toIce()});
         }
         return skillDesciptions;
     }
 
-    skills::provider::dto::SkillStatusUpdate SkillProviderComponentPluginUser::getSkillExecutionStatus(const std::string& skill, const Ice::Current &)
+} // namespace armarx::plugins
+
+namespace armarx
+{
+    SkillProviderComponentPluginUser::SkillProviderComponentPluginUser()
+    {
+        addPlugin(plugin);
+    }
+
+    void
+    SkillProviderComponentPluginUser::addSkill(std::unique_ptr<skills::Skill>&& skill)
     {
-        std::shared_lock l(skillsMutex);
-        auto& skillWrapper = skillImplementations.at(skill);
+        plugin->addSkill(std::move(skill));
+    }
+
+    void
+    SkillProviderComponentPluginUser::addSkill(const skills::LambdaSkill::FunT& f,
+                                               const skills::SkillDescription& desc)
+    {
+        plugin->addSkill(f, desc);
+    }
+
+    skills::provider::dto::SkillDescription
+    SkillProviderComponentPluginUser::getSkillDescription(const std::string& name,
+                                                          const Ice::Current& /*unused*/)
+    {
+
+        const auto& skillWrapper = plugin->getSkill(name);
+        return skillWrapper.skill->description.toIce();
+    }
+
+    skills::provider::dto::SkillDescriptionMap
+    SkillProviderComponentPluginUser::getSkillDescriptions(const Ice::Current& /*unused*/)
+    {
+        return plugin->getSkillDescriptions();
+    }
 
-        std::shared_lock l2(skillWrapper.skillStatusMutex);
+    skills::provider::dto::SkillStatusUpdate
+    SkillProviderComponentPluginUser::getSkillExecutionStatus(const std::string& skill,
+                                                              const Ice::Current& /*unused*/)
+    {
+        auto& skillWrapper = plugin->getSkill(skill);
+
+        const std::shared_lock l(skillWrapper.skillStatusMutex);
         return skillWrapper.statusUpdate.toIce();
     }
 
-    skills::provider::dto::SkillStatusUpdateMap SkillProviderComponentPluginUser::getSkillExecutionStatuses(const Ice::Current &)
+    skills::provider::dto::SkillStatusUpdateMap
+    SkillProviderComponentPluginUser::getSkillExecutionStatuses(const Ice::Current& /*unused*/)
     {
-        std::shared_lock l(skillsMutex);
-        skills::provider::dto::SkillStatusUpdateMap skillUpdates;
-        for (const auto& [key, skillWrapper] : skillImplementations)
-        {
-            std::shared_lock l2(skillWrapper.skillStatusMutex);
-            skillUpdates.insert({key, skillWrapper.statusUpdate.toIce()});
-        }
-        return skillUpdates;
+        return plugin->getSkillExecutionStatuses();
     }
 
     // Please not that this method waits until the skill can be scheduled!
-    skills::provider::dto::SkillStatusUpdate SkillProviderComponentPluginUser::executeSkill(const skills::provider::dto::SkillExecutionRequest& info, const Ice::Current &)
+    skills::provider::dto::SkillStatusUpdate
+    SkillProviderComponentPluginUser::executeSkill(
+        const skills::provider::dto::SkillExecutionRequest& info,
+        const Ice::Current& /*unused*/)
     {
         // The skill will be executed in a different thread
         std::thread execution;
@@ -149,19 +206,17 @@ namespace armarx
 
         skills::provider::dto::SkillStatusUpdate ret;
         {
-            std::shared_lock l(skillsMutex);
-            std::string skillName = info.skillName;
-            ARMARX_CHECK_EXPRESSION(skillImplementations.count(skillName) > 0) << "\nThe names are: " << VAROUT(skillName) << ", " << VAROUT(getName());
-
-            // get reference of the wrapper
-            auto& wrapper = skillImplementations.at(skillName);
+            const std::string skillName = info.skillName;
+            auto& wrapper = plugin->getSkill(skillName);
 
             // async start execution. But we wait for the execution to finish at the end of this method
-            execution = std::thread([&ret, &wrapper, &info, &usedParameterization](){
-                // execute waits until the previous execution finishes.
-                auto x = wrapper.setupAndExecuteSkill(info.executorName, usedParameterization);
-                ret = x.toIce();
-            });
+            execution = std::thread(
+                [&ret, &wrapper, &info, &usedParameterization]()
+                {
+                    // execute waits until the previous execution finishes.
+                    auto x = wrapper.setupAndExecuteSkill(info.executorName, usedParameterization);
+                    ret = x.toIce();
+                });
         } // release lock. We don't know how long the skill needs to finish and we have to release the lock for being able to abort the execution
 
         if (execution.joinable())
@@ -171,12 +226,16 @@ namespace armarx
         return ret;
     }
 
-    void SkillProviderComponentPluginUser::abortSkill(const std::string& skillName, const Ice::Current &)
+    void
+    SkillProviderComponentPluginUser::abortSkill(const std::string& skillName, const Ice::Current& /*unused*/)
     {
-        std::shared_lock l(skillsMutex);
-        ARMARX_CHECK_EXPRESSION(skillImplementations.count(skillName) > 0);
-
-        auto& wrapper = skillImplementations.at(skillName);
+        auto& wrapper = plugin->getSkill(skillName);
         wrapper.skill->notifySkillToStopASAP();
     }
-}
+
+    const std::experimental::observer_ptr<plugins::SkillProviderComponentPlugin>&
+    SkillProviderComponentPluginUser::getSkillProviderPlugin() const
+    {
+        return plugin;
+    }
+} // namespace armarx

source/RobotAPI/libraries/skills/provider/SkillProviderComponentPlugin.h

 #pragma once
 
-#include <shared_mutex>
+#include <functional>
 #include <queue>
+#include <shared_mutex>
 #include <thread>
-#include <functional>
 #include <type_traits>
+#include <experimental/memory>
 
 #include <ArmarXCore/core/ComponentPlugin.h>
 #include <ArmarXCore/core/ManagedIceObject.h>
-
 #include <ArmarXCore/core/services/tasks/RunningTask.h>
 
 #include <RobotAPI/interface/skills/SkillManagerInterface.h>
 #include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
 
 // Include all types of skills
-#include "Skill.h"
-#include "SpecializedSkill.h"
 #include "LambdaSkill.h"
 #include "PeriodicSkill.h"
 #include "PeriodicSpecializedSkill.h"
+#include "Skill.h"
+#include "SpecializedSkill.h"
 
 // Helper wrapper for execution
 #include "detail/SkillImplementationWrapper.h"
-
+namespace armarx
+{
+    class SkillProviderComponentPluginUser; // forward declaration
+}
 namespace armarx::plugins
 {
     class SkillProviderComponentPlugin : public ComponentPlugin
@@ -40,53 +43,82 @@ namespace armarx::plugins
 
         void preOnDisconnectComponent() override;
 
+        void addSkill(const skills::LambdaSkill::FunT&, const skills::SkillDescription&);
+        void addSkill(std::unique_ptr<skills::Skill>&&);
+
+        template <typename T>
+        T*
+        addSkill()
+        {
+            static_assert(std::is_base_of<skills::Skill, T>::value,
+                          "T must be derived from skills::Skill!");
+            static_assert(std::is_default_constructible<T>::value,
+                          "T must be default constructible!");
+
+            auto skill = std::make_unique<T>();
+            auto* skillPtr = skill.get();
+            addSkill(std::move(skill));
+            return static_cast<T*>(skillPtr);
+        }
+
     private:
+        skills::detail::SkillImplementationWrapper& getSkill(const std::string& name);
+        skills::provider::dto::SkillStatusUpdateMap getSkillExecutionStatuses() const;
+        skills::provider::dto::SkillDescriptionMap getSkillDescriptions() const;
+
         skills::manager::dti::SkillManagerInterfacePrx manager;
         skills::provider::dti::SkillProviderInterfacePrx myPrx;
+
+        mutable std::shared_mutex skillsMutex;
+
+        bool connected = false;
+        std::map<std::string, skills::detail::SkillImplementationWrapper> skillImplementations;
+
+        friend class armarx::SkillProviderComponentPluginUser;
     };
-}
+} // namespace armarx::plugins
 
 namespace armarx
 {
     class SkillProviderComponentPluginUser :
-            virtual public ManagedIceObject,
-            virtual public skills::provider::dti::SkillProviderInterface
+        virtual public ManagedIceObject,
+        virtual public skills::provider::dti::SkillProviderInterface
     {
     public:
         SkillProviderComponentPluginUser();
 
-        skills::provider::dto::SkillDescription getSkillDescription(const std::string&, const Ice::Current &current = Ice::Current()) override;
-        skills::provider::dto::SkillDescriptionMap getSkillDescriptions(const Ice::Current &current = Ice::Current()) override;
-        skills::provider::dto::SkillStatusUpdate getSkillExecutionStatus(const std::string& skill, const Ice::Current &current = Ice::Current()) override;
-        skills::provider::dto::SkillStatusUpdateMap getSkillExecutionStatuses(const Ice::Current &current = Ice::Current()) override;
-
-        skills::provider::dto::SkillStatusUpdate executeSkill(const skills::provider::dto::SkillExecutionRequest& executionInfo, const Ice::Current &current = Ice::Current()) override;
-        void abortSkill(const std::string& name, const Ice::Current &current = Ice::Current()) override;
+        skills::provider::dto::SkillDescription
+        getSkillDescription(const std::string&,
+                            const Ice::Current& current = Ice::Current()) override;
+        skills::provider::dto::SkillDescriptionMap
+        getSkillDescriptions(const Ice::Current& current = Ice::Current()) override;
+        skills::provider::dto::SkillStatusUpdate
+        getSkillExecutionStatus(const std::string& skill,
+                                const Ice::Current& current = Ice::Current()) override;
+        skills::provider::dto::SkillStatusUpdateMap
+        getSkillExecutionStatuses(const Ice::Current& current = Ice::Current()) override;
+
+        skills::provider::dto::SkillStatusUpdate
+        executeSkill(const skills::provider::dto::SkillExecutionRequest& executionInfo,
+                     const Ice::Current& current = Ice::Current()) override;
+        void abortSkill(const std::string& name,
+                        const Ice::Current& current = Ice::Current()) override;
+
+        const std::experimental::observer_ptr<plugins::SkillProviderComponentPlugin>&
+        getSkillProviderPlugin() const;
 
     protected:
         void addSkill(const skills::LambdaSkill::FunT&, const skills::SkillDescription&);
         void addSkill(std::unique_ptr<skills::Skill>&&);
 
-        template<typename T>
-        T* addSkill()
+        template <typename T>
+        T*
+        addSkill()
         {
-            static_assert(std::is_base_of<skills::Skill, T>::value, "T must be derived from skills::Skill!");
-            static_assert(std::is_default_constructible<T>::value, "T must be default constructible!");
-
-            auto skill = std::make_unique<T>();
-            auto* skillPtr = skill.get();
-            addSkill(std::move(skill));
-            return static_cast<T*>(skillPtr);
+            return plugin->addSkill<T>();
         }
 
     private:
-        armarx::plugins::SkillProviderComponentPlugin* plugin = nullptr;
-
-    protected:
-        mutable std::shared_mutex skillsMutex;
-
-    public:
-        bool connected = false;
-        std::map<std::string, skills::detail::SkillImplementationWrapper> skillImplementations;
+        std::experimental::observer_ptr<plugins::SkillProviderComponentPlugin> plugin = nullptr;
     };
-}
+} // namespace armarx