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::forEachInstance(std::function<void(EntityInstance&)> func) const
    {
        std::lock_guard l(ltm_mutex);
 
        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::hasInstance(const int entityInstanceIndex) const
    {
        std::lock_guard l(ltm_mutex);
 
        ARMARX_TRACE;
 
        return persistenceStrategy_->containsContainer(id(), std::to_string(entityInstanceIndex));
    }
 
    std::shared_ptr<EntityInstance>
    EntitySnapshot::findInstance(const int entityInstanceIndex) const
    {
        std::lock_guard l(ltm_mutex);
 
        ARMARX_TRACE;
 
        if (!hasInstance(entityInstanceIndex))
        {
            return nullptr;
        }
 
        return std::make_shared<EntityInstance>(getExportName(),
                                                id().withInstanceIndex(entityInstanceIndex),
                                                processors,
                                                persistenceStrategy_);
    }
 
    void
    EntitySnapshot::_loadAllReferences(armem::wm::EntitySnapshot& wmEntitySnapshot) const
    {
        std::lock_guard l(ltm_mutex);
 
        ARMARX_TRACE;
 
        wmEntitySnapshot.id() = id().getEntitySnapshotID().cleanID();
 
        forEachInstance([&wmEntitySnapshot](armem::server::ltm::EntityInstance& ltmEntityInstance) { ltmEntityInstance.loadAllReferences(wmEntitySnapshot); });
    }
 
    void
    EntitySnapshot::_resolve(armem::wm::EntitySnapshot& wmEntitySnapshot) const
    {
        std::lock_guard l(ltm_mutex);
 
        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);
                    // ARMARX_INFO << "Default Origin:=" << wmEntityInstance.metadata().origin;
                    ltmEntityInstance.resolve(wmEntityInstance);
                    // We get the correct origin, but at some point in time it vanishes. My guess would be that
                    // the meta data struct is somewhere copied and does not copy the origin, because it was newly added.
                    // ARMARX_INFO << "After resolve origin=" << wmEntityInstance.metadata().origin;
                });
    }
 
    void
    EntitySnapshot::_store(const armem::wm::EntitySnapshot& wmEntitySnapshot)
    {
 
        std::lock_guard l(ltm_mutex);
 
        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