ClassReader.cpp

Go to the documentation of this file.

#include "ClassReader.h"
 
#include <RobotAPI/libraries/armem/client/query.h>
#include <RobotAPI/libraries/armem_objects/aron_conversions.h>
#include <RobotAPI/libraries/armem_objects/types.h>
 
namespace armarx::armem::obj::clazz
{
    std::optional<armem::clazz::ObjectClass>
    ClassReader::getObjectClass(const std::string& providerName, const ObjectID& id)
    {
        auto mid = armarx::armem::MemoryID();
        mid.memoryName = properties().memoryName;
        mid.coreSegmentName = properties().coreSegmentName;
        mid.providerSegmentName = providerName;
        mid.entityName = id.str();
 
        auto i = this->memoryReader().getLatestSnapshotIn(mid);
 
        if (i.has_value() && i->size() == 1)
        {
            auto& instance = i->getInstance(0);
            auto aron = instance.dataAs<armarx::armem::arondto::ObjectClass>();
 
            armem::clazz::ObjectClass objClass;
            armarx::armem::clazz::fromAron(aron, objClass);
 
            return objClass;
        }
 
        return std::nullopt;
    }
 
    std::map<ObjectID, armem::clazz::ObjectClass>
    ClassReader::getObjectClasses(const std::vector<ObjectID>& objectIDs)
    {
        armem::client::query::Builder builder;
        auto& entities = builder.coreSegments()
                             .withName(properties().coreSegmentName)
                             .providerSegments()
                             .all()
                             .entities();
 
        for (const ObjectID& objectID : objectIDs)
        {
            entities.withName(objectID.getClassID().str()).snapshots().latest();
        }
 
        const armem::client::QueryResult result = memoryReader().query(builder);
        if (not result.success)
        {
            throw armem::error::QueryFailed(result.errorMessage);
        }
 
        std::map<ObjectID, armem::clazz::ObjectClass> objectClasses;
 
        result.memory.forEachInstance(
            [&objectClasses](const armem::wm::EntityInstance& instance) -> bool
            {
                const ObjectID classID = ObjectID::FromString(instance.id().entityName);
                auto aron = instance.dataAs<armarx::armem::arondto::ObjectClass>();
                armarx::armem::clazz::fromAron(aron, objectClasses[classID]);
 
                return true;
            });
 
        return objectClasses;
    }
 
    std::map<ObjectID, armem::clazz::ObjectClass>
    ClassReader::getAllObjectClasses()
    {
        armem::client::query::Builder builder;
 
        // clang-format off
        builder
            .coreSegments().withName(properties().coreSegmentName)
            .providerSegments().all()
            .entities().all()
            .snapshots().latest();
        // clang-format on
 
        const armem::client::QueryResult result = memoryReader().query(builder);
        if (not result.success)
        {
            throw armem::error::QueryFailed(result.errorMessage);
        }
 
        std::map<ObjectID, armem::clazz::ObjectClass> objectClasses;
 
        result.memory.forEachInstance(
            [&objectClasses](const armem::wm::EntityInstance& instance) -> bool
            {
                const ObjectID classID = ObjectID::FromString(instance.id().entityName);
                auto aron = instance.dataAs<armarx::armem::arondto::ObjectClass>();
                armarx::armem::clazz::fromAron(aron, objectClasses[classID]);
 
                return true;
            });
 
        return objectClasses;
    }
 
    std::string
    ClassReader::propertyPrefix() const
    {
        return "classReader.";
    }
 
    client::util::SimpleReaderBase::Properties
    ClassReader::defaultProperties() const
    {
        client::util::SimpleReaderBase::Properties p;
        p.memoryName = "Object";
        p.coreSegmentName = "Class";
        return p;
    }
 
} // namespace armarx::armem::obj::clazz