SkillManagerComponentPlugin.h

Go to the documentation of this file.

#pragma once
 
#include <exception>
#include <mutex>
#include <optional>
 
#include <ArmarXCore/core/ComponentPlugin.h>
#include <ArmarXCore/core/ManagedIceObject.h>
 
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/libraries/skills/core/error/Exception.h>
#include <RobotAPI/libraries/skills/core/ProviderID.h>
#include <RobotAPI/libraries/skills/core/ProviderInfo.h>
#include <RobotAPI/libraries/skills/core/SkillExecutionRequest.h>
#include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
 
namespace armarx
{
    class SkillManagerComponentPluginUser; // forward declaration
}
 
namespace armarx::plugins
{
    class SkillManagerComponentPlugin : public ComponentPlugin
    {
    public:
        using ComponentPlugin::ComponentPlugin;
 
        void preOnInitComponent() override;
 
        void preOnConnectComponent() override;
 
        void postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties) override;
 
        void addProvider(const skills::ProviderInfo& info);
 
        void removeProvider(const skills::ProviderID& id);
 
        skills::SkillStatusUpdate executeSkill(const skills::SkillExecutionRequest& req);
 
        skills::SkillExecutionID executeSkillAsync(const skills::SkillExecutionRequest& req);
 
        bool updateSkillParameters(const skills::SkillExecutionID& id,
                                   const aron::data::DictPtr& data);
 
        bool abortSkill(const skills::SkillExecutionID& id);
 
        bool abortSkillAsync(const skills::SkillExecutionID& id);
 
        std::optional<skills::SkillDescription> getSkillDescription(const skills::SkillID& id);
 
        std::map<skills::SkillID, skills::SkillDescription> getSkillDescriptions();
 
        std::optional<skills::SkillStatusUpdate>
        getSkillExecutionStatus(const skills::SkillExecutionID& id);
 
        std::map<skills::SkillExecutionID, skills::SkillStatusUpdate> getSkillExecutionStatuses();
 
    protected:
        skills::ProviderID getFirstProviderNameThatHasSkill(const skills::SkillID& skillid);
 
    private:
        [[ noreturn ]] void handleExceptionNonLockingThrow(const char* funcName, const std::exception& e, skills::ProviderID providerId,
                                                           bool eraseSkillProvider = true);
 
        std::optional<std::map<skills::ProviderID, skills::provider::dti::SkillProviderInterfacePrx>::iterator>
        handleExceptionNonLocking(const char* funcName, const std::exception& e, skills::ProviderID providerId,
                                  bool eraseSkillProvider = true);
 
        skills::manager::dti::SkillManagerInterfacePrx myPrx;
 
        std::mutex skillProviderMapMutex;
        std::map<skills::ProviderID, skills::provider::dti::SkillProviderInterfacePrx>
            skillProviderMap;
 
        friend class armarx::SkillManagerComponentPluginUser;
    };
} // namespace armarx::plugins
 
namespace armarx
{
    class SkillManagerComponentPluginUser :
        virtual public ManagedIceObject,
        virtual public skills::manager::dti::SkillManagerInterface
    {
    public:
        SkillManagerComponentPluginUser();
 
        void addProvider(const skills::manager::dto::ProviderInfo& providerInfo,
                         const Ice::Current& current) override;
        void removeProvider(const skills::manager::dto::ProviderID& provider,
                            const Ice::Current& current) override;
 
        skills::manager::dto::SkillStatusUpdate
        executeSkill(const skills::manager::dto::SkillExecutionRequest& info,
                     const Ice::Current& current) override;
 
        skills::manager::dto::SkillExecutionID
        executeSkillAsync(const skills::manager::dto::SkillExecutionRequest& skillExecutionRequest,
                          const Ice::Current& current) override;
 
        skills::provider::dto::ParameterUpdateResult
        updateSkillParameters(const skills::manager::dto::SkillExecutionID& executionId,
                              const aron::data::dto::DictPtr& params,
                              const Ice::Current& current) override;
 
        void updateStatusForSkill(const skills::provider::dto::SkillStatusUpdate& update,
                                  const skills::callback::dto::ProviderID& id,
                                  const Ice::Current& current) override;
 
        skills::provider::dto::AbortSkillResult
        abortSkill(const skills::manager::dto::SkillExecutionID& id,
                   const Ice::Current& current) override;
 
        skills::provider::dto::AbortSkillResult
        abortSkillAsync(const skills::manager::dto::SkillExecutionID& id,
                        const Ice::Current& current) override;
 
 
        skills::manager::dto::SkillDescriptionMap
        getSkillDescriptions(const Ice::Current& current) override;
 
        IceUtil::Optional<skills::manager::dto::SkillDescription>
        getSkillDescription(const skills::manager::dto::SkillID& id,
                            const Ice::Current& current) override;
 
        IceUtil::Optional<skills::manager::dto::SkillStatusUpdate>
        getSkillExecutionStatus(const skills::manager::dto::SkillExecutionID& executionId,
                                const Ice::Current& current) override;
 
        skills::manager::dto::SkillStatusUpdateMap
        getSkillExecutionStatuses(const Ice::Current& current) override;
 
    private:
        armarx::plugins::SkillManagerComponentPlugin* plugin = nullptr;
    };
} // namespace armarx