SkillProviderComponentPlugin.h

Go to the documentation of this file.

#pragma once
 
#include <experimental/memory>
#include <functional>
#include <queue>
#include <shared_mutex>
#include <thread>
#include <type_traits>
 
#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 <RobotAPI/libraries/skills/core/Skill.h>
#include <RobotAPI/libraries/skills/core/SkillExecutionRequest.h>
#include <RobotAPI/libraries/skills/core/SkillPreparationInput.h>
 
#include "LambdaSkill.h"
#include "PeriodicSkill.h"
#include "PeriodicSpecializedSkill.h"
#include "SkillFactory.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
    {
    public:
        using ComponentPlugin::ComponentPlugin;
 
        void preOnInitComponent() override;
 
        void preOnConnectComponent() override;
        void postOnConnectComponent() override;
 
        void postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties) override;
 
        void preOnDisconnectComponent() override;
 
        void addSkillFactory(std::unique_ptr<skills::SkillBlueprint>&&);
 
        skills::SkillBlueprint* addSkillFactory(const skills::SkillDescription&,
                                                const skills::LambdaSkill::FunctionType&);
 
        template <class SkillT, typename... Args>
 
        requires skills::isSkill<SkillT> skills::SkillBlueprint*
        addSkillFactory(Args&&... args)
        {
            auto fac = skills::SkillBlueprint::ForSkill<SkillT>(std::forward<Args>(args)...);
            auto* facPtr = fac.get();
            addSkillFactory(std::move(fac));
            return static_cast<skills::SkillBlueprint*>(facPtr);
        }
 
        template <typename FactoryT, typename... Args>
 
        requires skills::isSkillBlueprint<FactoryT> FactoryT*
        addCustomSkillFactory(Args&&... args)
        {
            auto fac = std::make_unique<FactoryT>(std::forward<Args>(args)...);
            auto* facPtr = fac.get();
            addSkillFactory(std::move(fac));
            return static_cast<FactoryT*>(facPtr);
        }
 
        // Ice forwards
        std::optional<skills::SkillStatusUpdate>
        getSkillExecutionStatus(const skills::SkillExecutionID&) const;
        std::map<skills::SkillExecutionID, skills::SkillStatusUpdate>
        getSkillExecutionStatuses() const;
 
        std::optional<skills::SkillDescription> getSkillDescription(const skills::SkillID&) const;
        std::map<skills::SkillID, skills::SkillDescription> getSkillDescriptions() const;
 
        skills::SkillStatusUpdate executeSkill(const skills::SkillExecutionRequest& executionInfo);
 
        skills::SkillExecutionID
        executeSkillAsync(const skills::SkillExecutionRequest& executionInfo);
 
        bool updateSkillParameters(const skills::SkillExecutionID& id,
                                   const armarx::aron::data::DictPtr& params);
 
        bool abortSkill(const skills::SkillExecutionID& execId);
 
        bool abortSkillAsync(const skills::SkillExecutionID& execId);
 
    private:
        skills::SkillBlueprint* getSkillFactory(const armarx::skills::SkillID& name);
 
 
        skills::manager::dti::SkillManagerInterfacePrx manager;
        skills::provider::dti::SkillProviderInterfacePrx myPrx;
 
        mutable std::shared_mutex skillFactoriesMutex;
        std::map<skills::SkillID, std::unique_ptr<skills::SkillBlueprint>> skillFactories;
 
        mutable std::shared_mutex skillExecutionsMutex;
        std::map<skills::SkillExecutionID, skills::detail::SkillRuntime> skillExecutions;
 
        friend class armarx::SkillProviderComponentPluginUser;
    };
} // namespace armarx::plugins
 
namespace armarx
 
{
    class SkillProviderComponentPluginUser :
        virtual public ManagedIceObject,
        virtual public skills::provider::dti::SkillProviderInterface
    {
    public:
        SkillProviderComponentPluginUser();
 
        // Ice Implementations
        IceUtil::Optional<skills::provider::dto::SkillDescription>
        getSkillDescription(const skills::provider::dto::SkillID& skill,
                            const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::SkillDescriptionMap
        getSkillDescriptions(const Ice::Current& current = Ice::Current()) override;
 
        IceUtil::Optional<skills::provider::dto::SkillStatusUpdate>
        getSkillExecutionStatus(const skills::provider::dto::SkillExecutionID& executionId,
                                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;
 
        skills::provider::dto::SkillExecutionID
        executeSkillAsync(const skills::provider::dto::SkillExecutionRequest& executionInfo,
                          const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::ParameterUpdateResult
        updateSkillParameters(const skills::provider::dto::SkillExecutionID& executionId,
                              const armarx::aron::data::dto::DictPtr& parameters,
                              const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::AbortSkillResult
        abortSkill(const skills::provider::dto::SkillExecutionID& skill,
                   const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::AbortSkillResult
        abortSkillAsync(const skills::provider::dto::SkillExecutionID& skill,
                        const Ice::Current& current = Ice::Current()) override;
 
        // Plugin
        const std::experimental::observer_ptr<plugins::SkillProviderComponentPlugin>&
        getSkillProviderPlugin() const;
 
    protected:
        // -----------------------------------------------------------------------------------------
        // New
        // -----------------------------------------------------------------------------------------
        skills::SkillBlueprint*
        addSkillFactory(const skills::SkillDescription& desc,
                        const skills::LambdaSkill::FunctionType& f)
        {
            auto ret = plugin->addSkillFactory(desc, f);
            return ret;
        }
 
        template <class SkillT, typename... Args>
 
        requires skills::isSkill<SkillT> skills::SkillBlueprint*
        addSkillFactory(Args&&... args)
        {
            return plugin->addSkillFactory<SkillT>(std::forward<Args>(args)...);
        }
 
        template <typename FacT, typename... Args>
 
        requires skills::isSkillBlueprint<FacT> FacT*
        addCustomSkillFactory(Args&&... args)
        {
            return plugin->addCustomSkillFactory<FacT>(std::forward<Args>(args)...);
        }
 
    private:
        std::experimental::observer_ptr<plugins::SkillProviderComponentPlugin> plugin = nullptr;
    };
} // namespace armarx