memory_conversions.cpp

Go to the documentation of this file.

#include "memory_conversions.h"
 
#include <ArmarXCore/core/logging/Logging.h>
 
namespace armarx::armem::wm
{
    void
    toMemory(Memory& m, const std::vector<CoreSegment>& e)
    {
        m.clear();
        for (const auto& s : e)
        {
            m.addCoreSegment(s);
        }
    }
 
    void
    toMemory(Memory& m, const std::vector<ProviderSegment>& e)
    {
        m.clear();
        for (const auto& s : e)
        {
            if (!m.hasCoreSegment(s.id().coreSegmentName))
            {
                m.addCoreSegment(s.id().coreSegmentName);
            }
            auto* c = m.findCoreSegment(s.id().coreSegmentName);
            c->addProviderSegment(s);
        }
    }
 
    void
    toMemory(Memory& m, const std::vector<Entity>& e)
    {
        m.clear();
        for (const auto& s : e)
        {
            if (!m.hasCoreSegment(s.id().coreSegmentName))
            {
                m.addCoreSegment(s.id().coreSegmentName);
            }
            auto* c = m.findCoreSegment(s.id().coreSegmentName);
 
            if (!c->hasProviderSegment(s.id().providerSegmentName))
            {
                c->addProviderSegment(s.id().providerSegmentName);
            }
            auto* p = c->findProviderSegment(s.id().providerSegmentName);
            p->addEntity(s);
        }
    }
 
    void
    toMemory(Memory& m, const std::vector<EntitySnapshot>& e)
    {
        m.clear();
 
        for (const auto& s : e)
        {
            if (!m.hasCoreSegment(s.id().coreSegmentName))
            {
                m.addCoreSegment(s.id().coreSegmentName);
            }
            auto* c = m.findCoreSegment(s.id().coreSegmentName);
 
            if (!c->hasProviderSegment(s.id().providerSegmentName))
            {
                c->addProviderSegment(s.id().providerSegmentName);
            }
            auto* p = c->findProviderSegment(s.id().providerSegmentName);
 
            if (!p->hasEntity(s.id().entityName))
            {
                p->addEntity(s.id().entityName);
            }
            auto* en = p->findEntity(s.id().entityName);
            en->addSnapshot(s);
        }
    }
 
    void
    toMemory(Memory& m, const std::vector<EntityInstance>& e)
    {
        m.clear();
        for (const auto& s : e)
        {
            if (!m.hasCoreSegment(s.id().coreSegmentName))
            {
                m.addCoreSegment(s.id().coreSegmentName);
            }
            auto* c = m.findCoreSegment(s.id().coreSegmentName);
 
            if (!c->hasProviderSegment(s.id().providerSegmentName))
            {
                c->addProviderSegment(s.id().providerSegmentName);
            }
            auto* p = c->findProviderSegment(s.id().providerSegmentName);
 
            if (!p->hasEntity(s.id().entityName))
            {
                p->addEntity(s.id().entityName);
            }
            auto* en = p->findEntity(s.id().entityName);
 
            if (!en->hasSnapshot(s.id().timestamp))
            {
                en->addSnapshot(s.id().timestamp);
            }
            auto* sn = p->findSnapshot(s.id());
 
            sn->addInstance(s);
        }
    }
 
    void
    toMemory(Memory& m,
             const armarx::armem::server::wm::Memory& structure,
             const std::vector<EntitySnapshot>& e)
    {
        // create an empty working memory:
        m.clear();
 
        for (const auto& s : e)
        {
            //get name of the core segment:
            auto coreSegmentName = s.id().coreSegmentName;
            auto* coreStructure = structure.findCoreSegment(coreSegmentName);
 
            // The structure memory may not know about this core segment
            // (version skew, partial load, snapshot from a different
            // schema, ...). Skip the snapshot with a warning instead of
            // dereferencing a nullptr below.
            if (coreStructure == nullptr)
            {
                ARMARX_WARNING << "Cannot convert snapshot " << s.id().str()
                               << ": core segment '" << coreSegmentName
                               << "' is not part of the structure memory. Skipping.";
                continue;
            }
 
            //if m does not have this core segment yet add the segment but copy the structure from the server wm:
            if (!m.hasCoreSegment(coreSegmentName))
            {
                m.addCoreSegment(coreSegmentName, coreStructure->aronType());
            }
            auto* c = m.findCoreSegment(coreSegmentName);
 
            //get name of provider segment:
            auto providerSegmentName = s.id().providerSegmentName;
            auto* providerStructure = coreStructure->findProviderSegment(providerSegmentName);
 
            // Same defensive check for the provider segment.
            if (providerStructure == nullptr)
            {
                ARMARX_WARNING << "Cannot convert snapshot " << s.id().str()
                               << ": provider segment '" << providerSegmentName
                               << "' is not part of the structure memory under core segment '"
                               << coreSegmentName << "'. Skipping.";
                continue;
            }
 
            if (!c->hasProviderSegment(providerSegmentName))
            {
                c->addProviderSegment(providerSegmentName, providerStructure->aronType());
            }
            auto* p = c->findProviderSegment(providerSegmentName);
 
            if (!p->hasEntity(s.id().entityName))
            {
                p->addEntity(s.id().entityName);
            }
            auto* en = p->findEntity(s.id().entityName);
            en->addSnapshot(s);
        }
    }
 
} // namespace armarx::armem::wm