EntitySnapshot.cpp

Go to the documentation of this file.

// Header
#include "EntitySnapshot.h"
 
#include <memory>
 
// ArmarX
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/TimeUtil.h>
 
#include "RobotAPI/libraries/armem/server/ltm/persistence/MemoryPersistenceStrategy.h"
#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
 
namespace armarx::armem::server::ltm
{
    EntitySnapshot::EntitySnapshot(
        const std::string& exportName,
        const armem::MemoryID& memoryId /* UNESCAPED */,
        const std::shared_ptr<Processors>& filters,
        const std::shared_ptr<persistence::MemoryPersistenceStrategy>& persistenceStrategy) :
        EntitySnapshotBase(exportName, memoryId, filters), persistenceStrategy_(persistenceStrategy)
    {
    }
 
    bool
    EntitySnapshot::_implForEachInstance(std::function<void(EntityInstance&)> func) const
    {
        ARMARX_TRACE;
 
        ARMARX_DEBUG << "For each entity instance (entity snapshot= " << id().cleanID().str()
                     << ")";
 
        for (auto& entityInstanceKey : persistenceStrategy_->getContainerKeys(id()))
        {
            std::shared_ptr<persistence::MemoryPersistenceStrategy>
                entityInstancePersistenceStrategy(persistenceStrategy_);
            MemoryID entityInstanceId = id().withInstanceIndex(std::stoi(entityInstanceKey));
            EntityInstance c(
                getExportName(), entityInstanceId, processors, entityInstancePersistenceStrategy);
 
            func(c);
        }
 
        return true;
    }
 
    bool
    EntitySnapshot::_implHasInstance(const int entityInstanceIndex) const
    {
        ARMARX_TRACE;
 
        return persistenceStrategy_->containsContainer(id(), std::to_string(entityInstanceIndex));
    }
 
    std::shared_ptr<EntityInstance>
    EntitySnapshot::_implFindInstance(const int entityInstanceIndex) const
    {
        ARMARX_TRACE;
 
        if (!_implHasInstance(entityInstanceIndex))  // Call _impl version
        {
            return nullptr;
        }
 
        return std::make_shared<EntityInstance>(getExportName(),
                                                id().withInstanceIndex(entityInstanceIndex),
                                                processors,
                                                persistenceStrategy_);
    }
 
    void
    EntitySnapshot::_loadAllReferences(armem::wm::EntitySnapshot& wmEntitySnapshot) const
    {
        ARMARX_TRACE;
 
        wmEntitySnapshot.id() = id().getEntitySnapshotID().cleanID();
 
        _implForEachInstance([&wmEntitySnapshot](armem::server::ltm::EntityInstance& ltmEntityInstance)
                             { ltmEntityInstance.loadAllReferences(wmEntitySnapshot); });
    }
 
    void
    EntitySnapshot::_resolve(armem::wm::EntitySnapshot& wmEntitySnapshot) const
    {
        ARMARX_TRACE;
 
        ARMARX_DEBUG << "Resolve entity snapshot id=" << id().cleanID().str();
 
        wmEntitySnapshot.forEachInstance(
            [&](auto& wmEntityInstance)
            {
                std::shared_ptr<persistence::MemoryPersistenceStrategy>
                    entityInstancePersistanceStrategy(persistenceStrategy_);
 
                EntityInstance ltmEntityInstance(
                    getExportName(),
                    id().withInstanceIndex(wmEntityInstance.id().instanceIndex),
                    processors,
                    entityInstancePersistanceStrategy);
                try
                {
                    ltmEntityInstance.resolve(wmEntityInstance);
                }
                catch (...)
                {
                    ARMARX_WARNING << "Could not resolve enity instance";
                }
            });
    }
 
    void
    EntitySnapshot::_store(const armem::wm::EntitySnapshot& wmEntitySnapshot)
    {
        ARMARX_TRACE;
 
        if (id().timestamp.isInvalid())
        {
            ARMARX_WARNING
                << "During storage of segment '" << wmEntitySnapshot.id().str()
                << "' I noticed that the corresponding LTM has no id set. "
                << "I set the id of the LTM to the same name, however this should not happen!";
            id().timestamp = wmEntitySnapshot.id().timestamp;
        }
 
        ARMARX_DEBUG << "Directly store entity snapshot";
 
 
        /*if (!connected())
        {
            ARMARX_WARNING << "LTM ENTITY SNAPSHOT NOT CONNECTED ALTHOUGH ENABLED " << id().str();
            return;
        }*/
 
        wmEntitySnapshot.forEachInstance(
            [&](const auto& wmEntityInstance)
            {
                std::shared_ptr<persistence::MemoryPersistenceStrategy>
                    entityInstancePersistenceStrategy(persistenceStrategy_);
 
                EntityInstance c(getExportName(),
                                 id().withInstanceIndex(wmEntityInstance.id().instanceIndex),
                                 processors,
                                 entityInstancePersistenceStrategy);
                c.store(wmEntityInstance);
 
                statistics.recordedInstances++;
            });
    }
} // namespace armarx::armem::server::ltm