SkillImplementationWrapper.h

Go to the documentation of this file.

#pragma once
 
#include <experimental/memory>
#include <mutex>
 
#include <RobotAPI/interface/skills/SkillProviderInterface.h>
#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
#include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
#include <RobotAPI/libraries/skills/provider/SkillFactory.h>
 
namespace armarx
{
    namespace skills
    {
        namespace detail
        {
            class SkillRuntime
            {
            private:
                const std::experimental::observer_ptr<const skills::SkillBlueprint> factory;
 
                std::unique_ptr<Skill> skill;
                mutable std::mutex executionMutex;
 
            public:
                // Current execution statuses. Changes during execution
                // The status also holds the used parameterization
                mutable std::mutex skillStatusesMutex;
                SkillStatusUpdate statusUpdate;
 
                // Set exteranally to store the execution somewhere
                std::thread execution;
 
                // ctor
                SkillRuntime(const skills::SkillBlueprint* fac,
                             const skills::SkillExecutionID&,
                             const aron::data::DictPtr&,
                             const skills::callback::dti::SkillProviderCallbackInterfacePrx&);
 
                // execute a skill. The parameterization is copied. T
                // the return type additionally contains the input configuration (similar to the status updates used in callbacks)
                TerminatedSkillStatusUpdate executeSkill();
 
                // ask a skill to stop. Must be concurrent to execute skill
                void stopSkill();
 
                // add parameters to a skill. Must be concurrent to execute skill
                void updateSkillParameters(const aron::data::DictPtr& i);
            };
        } // namespace detail
    } // namespace skills
} // namespace armarx