ComposedSkillLibrarySegment.cpp

Go to the documentation of this file.

#include "ComposedSkillLibrarySegment.h"
 
#include <optional>
 
#include <SimoxUtility/algorithm/string.h>
 
#include <ArmarXCore/core/time/ice_conversions.h>
 
#include "RobotAPI/libraries/armem/client/Query.h"
#include "RobotAPI/libraries/armem/client/forward_declarations.h"
#include "RobotAPI/libraries/armem/client/query/Builder.h"
#include "RobotAPI/libraries/armem/core/wm/memory_definitions.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/datatype/DatatypeConverterVisitor.h>
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
#include <RobotAPI/libraries/skills/core/aron/FluxioSkill.aron.generated.h>
 
namespace armarx::skills::segment
{
    ComposedSkillLibraryCoreSegment::ComposedSkillLibraryCoreSegment(
        armem::server::MemoryToIceAdapter& iceMemory) :
        Base(iceMemory, CoreSegmentName, skills::manager::arondto::FluxioSkill::ToAronType())
    {
    }
 
    void
    ComposedSkillLibraryCoreSegment::defineProperties(PropertyDefinitionsPtr defs,
                                                      const std::string& prefix)
    {
        this->setDefaultMaxHistorySize(maxHistorySize);
        Base::defineProperties(defs, prefix);
    }
 
    void
    ComposedSkillLibraryCoreSegment::init()
    {
        Base::init();
    }
 
    void
    ComposedSkillLibraryCoreSegment::addSkill(const skills::manager::arondto::FluxioSkill& skill)
    {
        // add skills
        armem::MemoryID provId = id().withProviderSegmentName(skill.skillProviderId.id);
 
        armem::Commit commit;
        armem::EntityUpdate& entityUpdate = commit.add();
        entityUpdate.confidence = 1.0;
        entityUpdate.referencedTime = armem::Time::Now();
        entityUpdate.sentTime = armem::Time::Now();
        entityUpdate.arrivedTime = armem::Time::Now();
        entityUpdate.instancesData = {skill.toAron()};
        entityUpdate.entityID = provId.withEntityName(skill.id);
 
        // Commit data to memory with locking to prevent race conditions with concurrent queries.
        iceMemory.commitLocking(commit);
    }
 
    std::optional<std::vector<skills::manager::arondto::FluxioSkill>>
    ComposedSkillLibraryCoreSegment::getSkills() const
    {
        std::vector<skills::manager::arondto::FluxioSkill> ret;
        armarx::armem::client::query::Builder qb;
        qb.allLatestInCoreSegment(id());
        armem::client::QueryResult qresult = iceMemory.query(qb.buildQueryInput());
        if (!qresult.success)
        {
            ARMARX_WARNING << "Query failed: " << qresult.errorMessage;
            return std::nullopt;
        }
 
        const armem::wm::Memory& data = qresult.memory;
 
        data.forEachInstance(
            [&ret, this](const armem::wm::EntityInstance& instance)
            {
                // dataAs<>() throws on type mismatch / corrupted aron data.
                // Skip the bad entry instead of crashing getSkills().
                skills::manager::arondto::FluxioSkill skill;
                try
                {
                    skill = instance.dataAs<skills::manager::arondto::FluxioSkill>();
                }
                catch (const std::exception& e)
                {
                    ARMARX_WARNING << "Skipping malformed FluxioSkill instance: "
                                   << e.what();
                    return;
                }
                if (skill.deleted)
                {
                    return;
                }
                ret.push_back(skill);
            });
 
        return ret;
    }
 
    std::optional<std::vector<skills::manager::arondto::FluxioSkill>>
    ComposedSkillLibraryCoreSegment::getSkillsOfProvider(const std::string& providerId) const
    {
        std::vector<skills::manager::arondto::FluxioSkill> ret;
        armarx::armem::client::query::Builder qb;
        qb.allLatestInProviderSegment(id().withProviderSegmentName(providerId));
        armem::client::QueryResult qresult = iceMemory.query(qb.buildQueryInput());
        if (!qresult.success)
        {
            ARMARX_WARNING << "Query failed: " << qresult.errorMessage;
            return std::nullopt;
        }
 
        const armem::wm::Memory& data = qresult.memory;
 
        data.forEachInstance(
            [&ret, this](const armem::wm::EntityInstance& instance)
            {
                // dataAs<>() throws on type mismatch / corrupted aron data.
                // Skip the bad entry instead of crashing getSkillsOfProvider().
                skills::manager::arondto::FluxioSkill skill;
                try
                {
                    skill = instance.dataAs<skills::manager::arondto::FluxioSkill>();
                }
                catch (const std::exception& e)
                {
                    ARMARX_WARNING << "Skipping malformed FluxioSkill instance: "
                                   << e.what();
                    return;
                }
                if (skill.deleted)
                {
                    return;
                }
                ret.push_back(skill);
            });
 
        return ret;
    }
} // namespace armarx::skills::segment