SkillExecutionRequestSegment.cpp

Go to the documentation of this file.

#include "SkillExecutionRequestSegment.h"
 
#include <SimoxUtility/algorithm/string.h>
 
#include <RobotAPI/libraries/armem/core/operations.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);
    }
 
    std::size_t
    SkillExecutionRequestCoreSegment::clearAndConsolidate(armem::server::ltm::Memory& ltm,
                                                           const std::string& memoryName,
                                                           bool& consolidated)
    {
        consolidated = false;
        std::size_t snapshotCount = 0;
        auto coreSegment = this->segmentPtr;
        ARMARX_CHECK(coreSegment);
 
        coreSegment->doLockedExclusive(
            [&]()
            {
                coreSegment->forEachSnapshot(
                    [&](const armem::wm::EntitySnapshot&) { ++snapshotCount; });
 
                if (ltm.isRecording() && snapshotCount > 0)
                {
                    armem::wm::Memory slice;
                    slice.setName(memoryName);
                    slice.update(armem::toCommit(*coreSegment), true);
                    ltm.directlyStore(slice);
                    consolidated = true;
                }
 
                coreSegment->clear();
            });
 
        return snapshotCount;
    }
} // namespace armarx::skills::segment