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;
            try
            {
                auto filecontent = persistenceStrategy_->retrieveItem(
                    id(), persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix);
                auto aron = conv.convert(filecontent, "");
                wmProviderSegment.aronType() = aron;
            }
            catch (const nlohmann::json::type_error& e)
            {
                ARMARX_WARNING
                    << "You are trying to access aron data which is not available, skipping...";
                wmProviderSegment.aronType() = nullptr;
            }
        }
 
        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 type = wmProviderSegment.aronType();
 
            auto [vec, modeSuffix] = conv.convert(type);
            ARMARX_CHECK_EMPTY(modeSuffix);
 
            std::string key = (persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix);
            persistenceStrategy_->storeItem(id(), key, vec);
 
            ARMARX_DEBUG << "Stored type information at " << key;
        }
        else
        {
            ARMARX_DEBUG << "ProviderSegment " << wmProviderSegment.id().providerSegmentName
                         << " 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