SkillReturnDataProcessing.cpp

Go to the documentation of this file.

 
 
#include "SkillReturnDataProcessing.h"
 
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
#include <RobotAPI/libraries/aron/core/type/variant/primitive/String.h>
#include <RobotAPI/libraries/skills/provider/SpecializedSkillProxy.h>
 
namespace armarx::skills::provider
{
    SkillReturnDataProcessing::SkillReturnDataProcessing() :
        SimpleSpecializedSkill<skills::Example::DataPassingParams>(GetSkillDescription())
    {
    }
 
    SkillDescription
    SkillReturnDataProcessing::GetSkillDescription()
    {
        armarx::skills::Example::DataPassingParams root_profile_params;
        root_profile_params.have_success = true;
 
        std::string des =
            "This skill calls the ConfigurableExitStatus skill. "
            "The 'have_success' parameter determines whether the subskill succeeds or fails. "
            "In both cases, the result data returned by ConfigurableExitStatus is printed to the "
            "console. "
            "This data is expected to be an integer with the value 1234.";
 
        return SkillDescription{
            .skillId = skills::SkillID{.skillName = "SkillReturnDataProcessing"},
            .description = des,
            .rootProfileDefaults = root_profile_params.toAron(),
            .timeout = armarx::core::time::Duration::MilliSeconds(100000),
            .parametersType = armarx::skills::Example::DataPassingParams::ToAronType(),
            .resultType = armarx::skills::Example::DataPassingReturn::ToAronType()};
    }
 
    Skill::MainResult
    SkillReturnDataProcessing::main(const SpecializedMainInput& in)
    {
        ARMARX_IMPORTANT << "Hi, from the SkillReturnDataProcessing skill.\n";
 
        // Prepare ConfigurableExitStatus skill with passed parameter
        auto configurableExitStatus = [this, in]()
        {
            armarx::skills::Example::DataPassingParams params;
            params.have_success = in.parameters.have_success;
            ARMARX_IMPORTANT << "Run ConfigurableExitStatus skill with success = "
                             << params.have_success;
 
            return std::tuple{properties.dataPassingInnerSkillSkillID, params.toAron()};
        };
 
 
        auto [inner_skill, inner_skill_params] = configurableExitStatus();
        ARMARX_IMPORTANT << "call subskill";
        auto update2 = callSubskill(inner_skill, inner_skill_params);
        ARMARX_IMPORTANT << "called subskill";
 
        if (update2.has_value() and not update2->hasBeenSucceeded())
        {
            ARMARX_IMPORTANT << "ConfigurableExitStatus skill not successfull.";
            // Print keys of received dict:
            ARMARX_IMPORTANT << update2->result->getAllKeysAsString();
            // Retrieve data value and parse it to the out object. Additional step is needed,
            // as on failure the skill returns a dict with errorCode, errorMessage and data
            auto error_dict = aron::data::Dict::DynamicCastAndCheck(update2->result);
            auto result_dict = error_dict->getElement("data");
            armarx::skills::Example::DataPassingReturn out;
            out.fromAron(aron::data::Dict::DynamicCastAndCheck(result_dict));
            ARMARX_IMPORTANT << "Return value of ConfigurableExitStatus skill: "
                             << out.some_return_int;
            return {TerminatedSkillStatus::Succeeded, in.parameters.toAron()};
        }
 
        ARMARX_TRACE;
        throwIfSkillShouldTerminate();
 
 
        if (update2.has_value() and update2->hasBeenSucceeded())
        {
            ARMARX_IMPORTANT << "ConfigurableExitStatus skill successfull";
            armarx::skills::Example::DataPassingReturn out;
            // Print keys of received dict:
            ARMARX_IMPORTANT << update2->result->getAllKeysAsString();
            // Retrieve data value and parse it to the out object.
            out.fromAron(update2->result);
            ARMARX_IMPORTANT << "Return value of ConfigurableExitStatus skill: "
                             << out.some_return_int;
        }
 
        return {TerminatedSkillStatus::Succeeded, in.parameters.toAron()};
    }
 
 
} // namespace armarx::skills::provider