SkillEventSegment.cpp

Go to the documentation of this file.

#include "SkillEventSegment.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
{
 
    SkillEventCoreSegment::SkillEventCoreSegment(armem::server::MemoryToIceAdapter& iceMemory) :
        Base(iceMemory,
             CoreSegmentName,
             armarx::skills::arondto::SkillExecutionRequest::ToAronType())
    {
    }
 
    void
    SkillEventCoreSegment::defineProperties(PropertyDefinitionsPtr defs, const std::string& prefix)
    {
        this->setDefaultMaxHistorySize(300);
        Base::defineProperties(defs, prefix);
    }
 
    void
    SkillEventCoreSegment::init()
    {
        Base::init();
    }
 
    void
    SkillEventCoreSegment::addSkillUpdateEvent(const skills::SkillStatusUpdate& update)
    {
        // create commit about new update
        armarx::skills::arondto::SkillStatusUpdate event;
        armem::toAron(event, update);
 
        armem::MemoryID commitId = id();
        commitId.providerSegmentName = event.skillId.providerId.providerName;
        commitId.entityName = event.skillId.skillName;
 
        auto aron = event.toAron();
 
        armem::Commit comm;
        auto& entityUpdate = comm.add();
        entityUpdate.confidence = 1.0;
        entityUpdate.referencedTime = armem::Time::Now();
        entityUpdate.instancesData = {aron};
        entityUpdate.entityID = commitId;
 
        iceMemory.commitLocking(comm);
    }
 
    std::map<skills::SkillExecutionID, skills::SkillStatusUpdate>
    SkillEventCoreSegment::getSkillStatusUpdates()
    {
        std::map<skills::SkillExecutionID, skills::SkillStatusUpdate> ret;
        auto coreSegment = this->segmentPtr;
        ARMARX_CHECK(coreSegment);
 
        coreSegment->doLocked(
            [&]()
            {
                coreSegment->forEachInstance(
                    [&](const armem::wm::EntityInstance& i)
                    {
                        auto event = i.dataAs<armarx::skills::arondto::SkillStatusUpdate>();
                        skills::SkillStatusUpdate up;
                        armem::fromAron(event, up);
 
                        if (auto it = ret.find(up.executionId); it != ret.end() && up < it->second)
                        {
                            return;
                        }
 
                        // set or replace
                        ret[up.executionId] = up;
                    });
            });
 
        //        for (const auto& [k, v] : ret)
        //        {
        //            ARMARX_IMPORTANT << "Skill " << k.skillId << " has stati: " << int(v.status);
        //        }
 
        return ret;
    }
 
    std::optional<skills::SkillStatusUpdate>
    SkillEventCoreSegment::getSkillStatusUpdate(const skills::SkillExecutionID& id)
    {
        std::optional<skills::SkillStatusUpdate> ret = std::nullopt;
        auto coreSegment = this->segmentPtr;
        ARMARX_CHECK(coreSegment);
 
        coreSegment->doLocked(
            [&]()
            {
                coreSegment->forEachInstance(
                    [&](const armem::wm::EntityInstance& i)
                    {
                        auto event = i.dataAs<armarx::skills::arondto::SkillStatusUpdate>();
                        skills::SkillStatusUpdate up;
                        armem::fromAron(event, up);
 
                        if (up.executionId == id)
                        {
                            if (!ret || (ret.has_value() && *ret < up))
                            {
                                ret = up;
                            }
                        }
                    });
            });
        return ret;
    }
} // namespace armarx::skills::segment