SimpleSpecializedSkill.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include <ArmarXCore/core/logging/LogSender.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/util/StringHelpers.h>
 
#include <RobotAPI/libraries/skills/core/Skill.h>
#include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
#include <RobotAPI/libraries/skills/provider/SpecializedSkill.h>
 
namespace armarx
{
    namespace skills
    {
        template <class AronT>
        class SimpleSpecializedSkill : public SpecializedSkill<AronT>
        {
        public:
            using Base = SpecializedSkill<AronT>;
            using ParamType = AronT;
 
            using Base::Base;
 
            struct SpecializedInitInput
            {
                std::string executorName;
                AronT parameters;
            };
 
            struct SpecializedMainInput
            {
                std::string executorName;
                AronT parameters;
                Skill::CallbackT callback;
            };
 
            struct SpecializedExitInput
            {
                std::string executorName;
                AronT parameters;
            };
 
        protected:
            // legacy methods
            virtual Skill::InitResult
            init(const SpecializedInitInput& /*in*/)
            {
                return Skill::InitResult{.status = TerminatedSkillStatus::Succeeded};
            }
 
            virtual Skill::MainResult
            main(const SpecializedMainInput& /*in*/)
            {
                ARMARX_IMPORTANT << "Dummy executing skill '" << this->description.skillId
                                 << "'. Please overwrite this method.";
                return Skill::MainResult{.status = TerminatedSkillStatus::Succeeded,
                                         .data = nullptr};
            }
 
            virtual Skill::ExitResult
            exit(const SpecializedExitInput& /*in*/)
            {
                return Skill::ExitResult{.status = TerminatedSkillStatus::Succeeded};
            }
 
            Skill::InitResult
            init() final
            {
                ARMARX_VERBOSE << "Entered SimpleSpecializedSkill<T>::init().";
                SpecializedInitInput i;
                i.executorName = this->executorName;
                i.parameters = this->getParameters();
                auto ret = this->init(i);
                ARMARX_VERBOSE << "Exiting SimpleSpecializedSkill<T>::init() ...";
                return ret;
            }
 
            Skill::MainResult
            main() final
            {
                ARMARX_VERBOSE << "Entered SimpleSpecializedSkill<T>::main().";
                SpecializedMainInput i;
                i.executorName = this->executorName;
                i.callback = this->callback;
                i.parameters = this->getParameters();
                auto ret = this->main(i);
                ARMARX_VERBOSE << "Exiting SimpleSpecializedSkill<T>::main() ...";
                return ret;
            }
 
            Skill::ExitResult
            exit() final
            {
                ARMARX_VERBOSE << "Entered SimpleSpecializedSkill<T>::exit().";
                SpecializedExitInput i;
                i.executorName = this->executorName;
                i.parameters = this->getParameters();
                auto ret = this->exit(i);
                ARMARX_VERBOSE << "Exiting SimpleSpecializedSkill<T>::exit() ...";
                return ret;
            }
        };
    } // namespace skills
} // namespace armarx