SkillExecutionRequestSegment.cpp

Go to the documentation of this file.

#include "SkillExecutionRequestSegment.h"
 
#include <SimoxUtility/algorithm/string.h>
 
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
#include <RobotAPI/libraries/armem_skills/aron/Skill.aron.generated.h>
#include <RobotAPI/libraries/armem_skills/aron_conversions.h>
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
 
namespace armarx::skills::segment
{
 
    SkillExecutionRequestCoreSegment::SkillExecutionRequestCoreSegment(
        armem::server::MemoryToIceAdapter& iceMemory) :
        Base(iceMemory, CoreSegmentName, skills::arondto::SkillExecutionRequest::ToAronType())
    {
    }
 
    void
    SkillExecutionRequestCoreSegment::defineProperties(PropertyDefinitionsPtr defs,
                                                       const std::string& prefix)
    {
        this->setDefaultMaxHistorySize(50);
        Base::defineProperties(defs, prefix);
    }
 
    void
    SkillExecutionRequestCoreSegment::init()
    {
        Base::init();
    }
 
    skills::SkillExecutionRequest
    SkillExecutionRequestCoreSegment::convertCommit(const aron::data::dto::DictPtr& commitData)
    {
        // convert ice commitData to aron
        auto commitDataAron = std::make_shared<aron::data::Dict>(commitData);
 
        // we got a skill execution request
        skills::arondto::SkillExecutionRequest request;
        request.fromAron(commitDataAron);
 
        skills::SkillExecutionRequest info{
            .skillId = SkillID{.providerId = ProviderID{.providerName = ""}, .skillName = ""},
            .executorName = ""};
        armem::fromAron(request, info);
        return info;
    }
 
    void
    SkillExecutionRequestCoreSegment::addSkillExecutionRequest(
        const skills::SkillExecutionRequest& info)
    {
        // override directly execution to add a request to the memory
        armem::Commit comm;
 
        skills::arondto::SkillExecutionRequest request;
        armem::toAron(request, info);
 
        auto aron = request.toAron();
 
        {
            auto& entityUpdate = comm.add();
 
            armem::MemoryID skillExecutionMemID = id();
            skillExecutionMemID.providerSegmentName = request.skillId.providerId.providerName;
            skillExecutionMemID.entityName = request.skillId.skillName;
 
            entityUpdate.entityID = skillExecutionMemID;
            entityUpdate.instancesData = {aron};
            entityUpdate.confidence = 1.0;
            entityUpdate.referencedTime = armem::Time::Now();
        }
 
        {
            auto& entityUpdate = comm.add();
 
            armem::MemoryID skillExecutionMemID = id();
            skillExecutionMemID.providerSegmentName = "All Skill Execution Requests";
            skillExecutionMemID.entityName = "All Skill Execution Requests";
 
            entityUpdate.entityID = skillExecutionMemID;
            entityUpdate.instancesData = {aron};
            entityUpdate.confidence = 1.0;
            entityUpdate.referencedTime = armem::Time::Now();
        }
 
 
        iceMemory.commitLocking(comm);
    }
} // namespace armarx::skills::segment