SkillProxy.cpp

Go to the documentation of this file.

#include "SkillProxy.h"
 
#include <chrono>
#include <thread>
 
#include <RobotAPI/libraries/skills/core/error/Exception.h>
 
namespace armarx
{
    namespace skills
    {
        SkillProxy::SkillProxy(const manager::dti::SkillManagerInterfacePrx& manager,
                               const SkillID& skillId) :
            manager(manager)
        {
            ARMARX_CHECK_NOT_NULL(manager);
            IceUtil::Optional<manager::dto::SkillDescription> description =
                manager->getSkillDescription(skillId.toManagerIce());
            if (description)
            {
                skillDescription = SkillDescription::FromIce(description.value());
                ARMARX_CHECK(skillDescription.skillId.isFullySpecified());
            }
            else
            {
                std::stringstream reason;
                reason << "No skill with ID " << skillId << " found";
                throw error::SkillNotFoundException(__PRETTY_FUNCTION__, reason.str());
            }
        }
 
        SkillProxy::SkillProxy(const manager::dti::SkillManagerInterfacePrx& manager,
                               const SkillDescription& skillDesc) :
            manager(manager), skillDescription(skillDesc)
        {
            ARMARX_CHECK_NOT_NULL(manager);
            ARMARX_CHECK(skillDesc.skillId.isFullySpecified());
        }
 
        SkillDescription
        SkillProxy::getSkillDescription() const
        {
            return skillDescription;
        }
 
        SkillID
        SkillProxy::getSkillId() const
        {
            return skillDescription.skillId;
        }
 
        TerminatedSkillStatusUpdate
        SkillProxy::executeSkill(const std::string& executorName,
                                 const aron::data::DictPtr& params) const
        {
            ARMARX_CHECK_NOT_NULL(manager);
            skills::manager::dto::SkillExecutionRequest req;
            req.executorName = executorName;
            req.parameters = aron::data::Dict::ToAronDictDTO(params);
            req.skillId = skillDescription.skillId.toManagerIce();
 
            auto terminatingUpdateIce = manager->executeSkill(req);
            return TerminatedSkillStatusUpdate::FromIce(terminatingUpdateIce);
        }
 
        SkillExecutionID
        SkillProxy::executeSkillAsync(const std::string& executorName,
                                      const aron::data::DictPtr& params) const
        {
            ARMARX_CHECK_NOT_NULL(manager);
            skills::manager::dto::SkillExecutionRequest req;
            req.executorName = executorName;
            req.parameters = aron::data::Dict::ToAronDictDTO(params);
            req.skillId = skillDescription.skillId.toManagerIce();
 
            auto execIdIce = manager->executeSkillAsync(req);
            return SkillExecutionID::FromIce(execIdIce);
        }
 
        std::optional<TerminatedSkillStatusUpdate>
        SkillProxy::join(const SkillExecutionID& executionId) const
        {
            ARMARX_CHECK_NOT_NULL(manager);
            auto s = this->manager->getSkillExecutionStatus(executionId.toManagerIce());
 
            while (s)
            {
                auto statusUpdate = skills::SkillStatusUpdate::FromIce(*s);
 
                if (statusUpdate.hasBeenTerminated())
                {
                    break;
                }
 
                std::this_thread::sleep_for(std::chrono::milliseconds(50));
                s = this->manager->getSkillExecutionStatus(executionId.toManagerIce());
            }
 
            if (!s)
            {
                // Either the manager already removed the result (then it is unknown) or the execution id does not exist.
                return std::nullopt;
            }
 
            return TerminatedSkillStatusUpdate::FromIce(*s);
        }
 
        bool
        SkillProxy::abortSkill(const SkillExecutionID& id) const
        {
            ARMARX_CHECK_NOT_NULL(manager);
            auto r = manager->abortSkill(id.toManagerIce());
            return r.success;
        }
 
        bool
        SkillProxy::abortSkillAsync(const SkillExecutionID& id) const
        {
            ARMARX_CHECK_NOT_NULL(manager);
            auto r = manager->abortSkillAsync(id.toManagerIce());
            return r.success;
        }
 
        aron::data::DictPtr
        SkillProxy::getRootProfileParameters() const
        {
            return skillDescription.rootProfileDefaults;
        }
    } // namespace skills
} // namespace armarx