ProviderSegment.cpp

Go to the documentation of this file.

// Header
#include "ProviderSegment.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/armem/server/wm/memory_definitions.h>
 
namespace armarx::armem::server::ltm
{
    ProviderSegment::ProviderSegment(const std::string& exportName,
                                     const armem::MemoryID& memoryId /* UNESCAPED */,
                                     const std::shared_ptr<Processors>& filters,
                                     const std::shared_ptr<persistence::MemoryPersistenceStrategy>& persistenceStrategy) :
        ProviderSegmentBase(exportName, memoryId, filters),
        persistenceStrategy_(persistenceStrategy)
    {
        //start();
    }
 
    bool
    ProviderSegment::forEachEntity(std::function<void(Entity&)> func) const
    {
        std::lock_guard l(ltm_mutex);
 
        ARMARX_TRACE;
 
        ARMARX_DEBUG << "For each entity (provider segment id=" << id().cleanID().str();
 
        for (std::string& entityName : persistenceStrategy_->getContainerKeys(id())) 
        {
            ARMARX_DEBUG << "Found entity=" << entityName;
 
            std::shared_ptr<persistence::MemoryPersistenceStrategy> entityPersistenceStrategy(persistenceStrategy_);
 
            Entity ltmEntity(getExportName(),
                     id().withEntityName(entityName),
                     processors,
                     entityPersistenceStrategy);
                     
            func(ltmEntity);
        }
 
        return true;
    }
 
    bool
    ProviderSegment::hasEntity(const std::string& entityName) const
    {
        std::lock_guard l(ltm_mutex);
 
        ARMARX_TRACE;
 
        return persistenceStrategy_->containsContainer(id(), entityName);
    }
 
    std::shared_ptr<Entity>
    ProviderSegment::findEntity(const std::string& entityName) const
    {
        std::lock_guard l(ltm_mutex);
 
        ARMARX_TRACE;
 
        if (!hasEntity(entityName))
        {
            return nullptr;
        }
 
        return std::make_shared<Entity>(getExportName(),
                                        id().withEntityName(entityName),
                                        processors,
                                        persistenceStrategy_);
    }
 
    void
    ProviderSegment::_loadAllReferences(armem::wm::ProviderSegment& wmProviderSegment)
    {
        std::lock_guard l(ltm_mutex);
 
        ARMARX_TRACE;
 
        wmProviderSegment.id() = id().getProviderSegmentID().cleanID();
 
        auto& conv = processors->defaultTypeConverter;
        if (persistenceStrategy_->containsItem(id(), persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix))
        {
            // load and set type
            auto& conv = processors->defaultTypeConverter;
 
            auto filecontent = persistenceStrategy_->retrieveItem(id(), persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix);
            auto aron = conv.convert(filecontent, "");
            wmProviderSegment.aronType() = aron;
        }
 
        forEachEntity(
            [&wmProviderSegment](auto& ltmEntity)
            {
                armem::wm::Entity wmEntity;
                ltmEntity.loadAllReferences(wmEntity);
 
                // Because there might be multiple LTMs with the same entity
                if (wmProviderSegment.hasEntity(wmEntity.name()))
                {
                    armem::wm::Entity existingWmEntity = wmProviderSegment.getEntity(wmEntity.name());
                    existingWmEntity.append(wmEntity);
                }
                else
                {
                    wmProviderSegment.addEntity(wmEntity);
                }            
            });
    }
 
    void
    ProviderSegment::_loadLatestNReferences(int n, armem::wm::ProviderSegment& wmProviderSegment)
    {
        std::lock_guard l(ltm_mutex);
        
        ARMARX_TRACE;
 
        wmProviderSegment.id() = id().getProviderSegmentID().cleanID();
 
        auto& conv = processors->defaultTypeConverter;
        
        if (persistenceStrategy_->containsItem(id(), persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix))
        {
            // load and set type
            auto& conv = processors->defaultTypeConverter;
 
            auto filecontent = persistenceStrategy_->retrieveItem(id(), persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix);
            auto aron = conv.convert(filecontent, "");
            wmProviderSegment.aronType() = aron;
        }
 
        forEachEntity(
            [&wmProviderSegment, &n](auto& ltmEntity)
            {
                armem::wm::Entity wmEntity;
                ltmEntity.loadLatestNReferences(n, wmEntity);
 
                // Because there might be multiple LTMs with the same entity
                if (wmProviderSegment.hasEntity(wmEntity.name()))
                {
                    armem::wm::Entity existingWmEntity = wmProviderSegment.getEntity(wmEntity.name());
                    existingWmEntity.append(wmEntity);
                }
                else
                {
                    wmProviderSegment.addEntity(wmEntity);
                }
            });
    }
 
    void
    ProviderSegment::_resolve(armem::wm::ProviderSegment& wmProviderSegment)
    {
        std::lock_guard l(ltm_mutex);
 
        ARMARX_TRACE;
        
        ARMARX_DEBUG << "Resolve provider segment id=" << id().cleanID().str();
 
        wmProviderSegment.forEachEntity(
            [&](auto& wmEntity)
            {
                std::shared_ptr<persistence::MemoryPersistenceStrategy> entityPersistenceStrategy(persistenceStrategy_);
 
                Entity ltmEntity(getExportName(),
                         id().withEntityName(wmEntity.id().entityName),
                         processors,
                         entityPersistenceStrategy);
                ltmEntity.resolve(wmEntity);
            });
    }
 
    void
    ProviderSegment::_store(const armem::wm::ProviderSegment& wmProviderSegment, bool simulatedVersion)
    {
        std::lock_guard l(ltm_mutex);
 
        ARMARX_TRACE;
 
        if (id().providerSegmentName.empty())
        {
            ARMARX_WARNING
                << "During storage of segment '" << wmProviderSegment.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().providerSegmentName = wmProviderSegment.id().providerSegmentName;
        }
 
        ARMARX_DEBUG << "Store provider segment id=" << id().cleanID().str();
 
        if (wmProviderSegment.hasAronType())
        {
            auto& conv = processors->defaultTypeConverter;
 
            auto [vec, modeSuffix] = conv.convert(wmProviderSegment.aronType());
            ARMARX_CHECK_EMPTY(modeSuffix);
 
            std::string key = (persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix);
            persistenceStrategy_->storeItem(id(), key, vec);
        }
        else
        {
            ARMARX_DEBUG << "ProviderSegment does not seem to have an aron type, so aron type "
                            "information connot be exported";
            //writeForeignKeyToPreviousDocument();
        }
 
        wmProviderSegment.forEachEntity(
            [&](const auto& wmEntity)
            {
                std::shared_ptr<persistence::MemoryPersistenceStrategy> entityPersistenceStrategy(persistenceStrategy_);
 
                Entity ltmEntity(getExportName(),
                         id().withEntityName(wmEntity.id().entityName),
                         processors,
                         entityPersistenceStrategy);
 
                ltmEntity.store(wmEntity, simulatedVersion);
                statistics.recordedEntities++;
            });
    }
 
} // namespace armarx::armem::server::ltm