CoreSegment.cpp

Go to the documentation of this file.

#include "CoreSegment.h"
 
#include <memory>
 
#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
{
 
    CoreSegment::CoreSegment(
        const std::string& exportName,
        const armem::MemoryID& id /* UNESCAPED */,
        const std::shared_ptr<Processors>& filters,
        const std::shared_ptr<persistence::MemoryPersistenceStrategy>& persistenceStrategy) :
        CoreSegmentBase(exportName, id, filters), persistenceStrategy_(persistenceStrategy)
    {
    }
 
    bool
    CoreSegment::_implForEachProviderSegment(std::function<void(ProviderSegment&)> func) const
    {
        ARMARX_TRACE;
 
        ARMARX_DEBUG << "For each provider segment (core segment id=" << id().cleanID().str()
                     << ")";
        ARMARX_DEBUG << "Has strategy="
                     << (persistenceStrategy_ !=
                         nullptr); // Should be very true otherwise we will blow up already here
        ARMARX_DEBUG << "Strategy identifier=" << persistenceStrategy_->getIdentifier();
        ARMARX_DEBUG << "Strategy export name=" << persistenceStrategy_->getExportName();
 
        for (auto& providerSegmentKey : persistenceStrategy_->getContainerKeys(id()))
        {
            std::shared_ptr<persistence::MemoryPersistenceStrategy>
                providerSegmentPersistenceStrategy(persistenceStrategy_);
 
            ProviderSegment c(getExportName(),
                              id().withProviderSegmentName(providerSegmentKey),
                              processors,
                              providerSegmentPersistenceStrategy);
            func(c);
        }
 
        return true;
    }
 
    bool
    CoreSegment::_implHasProviderSegment(const std::string& providerSegmentName) const
    {
        ARMARX_TRACE;
 
        return persistenceStrategy_->containsContainer(id(), providerSegmentName);
    }
 
    std::shared_ptr<ProviderSegment>
    CoreSegment::_implFindProviderSegment(const std::string& providerSegmentName) const
    {
        ARMARX_TRACE;
 
        if (!_implHasProviderSegment(providerSegmentName))  // Call _impl version
        {
            return nullptr;
        }
 
 
        return std::make_shared<ProviderSegment>(getExportName(),
                                                 id().withProviderSegmentName(providerSegmentName),
                                                 processors,
                                                 persistenceStrategy_);
    }
 
    void
    CoreSegment::_loadAllReferences(armem::wm::CoreSegment& wmCoreSegment)
    {
        ARMARX_TRACE;
 
        wmCoreSegment.id() = id().getCoreSegmentID().cleanID();
 
        auto& conv = processors->defaultTypeConverter;
 
        if (persistenceStrategy_->containsItem(
                id(), persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix))
        {
            auto& conv = processors->defaultTypeConverter;
            try
            {
                auto filecontent = persistenceStrategy_->retrieveItem(
                    id(), persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix);
                auto aron = conv.convert(filecontent, "");
                wmCoreSegment.aronType() = aron;
            }
            catch (const nlohmann::json::type_error& e)
            {
                ARMARX_WARNING << "You are trying to access aron data in a CoreSegment which is "
                                  "not available, skipping...";
                wmCoreSegment.aronType() = nullptr;
            }
        }
 
        _implForEachProviderSegment(  // Call _impl version
            [&wmCoreSegment](auto& ltmProviderSegment)
            {
                armem::wm::ProviderSegment wmProviderSegment;
                ltmProviderSegment.loadAllReferences(wmProviderSegment);
 
                // Because there might be multiple LTMs with the same provider segment
                if (wmCoreSegment.hasProviderSegment(wmProviderSegment.name()))
                {
                    armem::wm::ProviderSegment existingWmProviderSegment =
                        wmCoreSegment.getProviderSegment(wmProviderSegment.name());
                    existingWmProviderSegment.append(wmProviderSegment);
                }
                else
                {
                    wmCoreSegment.addProviderSegment(wmProviderSegment);
                }
            });
    }
 
    void
    CoreSegment::_loadLatestNReferences(int n, armem::wm::CoreSegment& wmCoreSegment)
    {
        ARMARX_TRACE;
 
        wmCoreSegment.id() = id().getCoreSegmentID().cleanID();
 
        auto& conv = processors->defaultTypeConverter;
 
        ARMARX_INFO << "Before type conversion";
 
        if (persistenceStrategy_->containsItem(
                id(), persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix))
        {
            auto& conv = processors->defaultTypeConverter;
 
            try
            {
                auto filecontent = persistenceStrategy_->retrieveItem(
                    id(), persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix);
                auto aron = conv.convert(filecontent, "");
                wmCoreSegment.aronType() = aron;
            }
            catch (const nlohmann::json::type_error& e)
            {
                ARMARX_WARNING
                    << "You are trying to access aron data which is not available, skipping...";
                wmCoreSegment.aronType() = nullptr;
            }
        }
 
        ARMARX_INFO << "After type conversion";
 
        _implForEachProviderSegment(  // Call _impl version
            [&wmCoreSegment, &n](auto& ltmProviderSegment)
            {
                armem::wm::ProviderSegment wmProviderSegment;
                ltmProviderSegment.loadLatestNReferences(n, wmProviderSegment);
 
                // Because there might be multiple LTMs with the same provider segment
                if (wmCoreSegment.hasProviderSegment(wmProviderSegment.name()))
                {
                    armem::wm::ProviderSegment existingWmProviderSegment =
                        wmCoreSegment.getProviderSegment(wmProviderSegment.name());
                    existingWmProviderSegment.append(wmProviderSegment);
                }
                else
                {
                    wmCoreSegment.addProviderSegment(wmProviderSegment);
                }
            });
    }
 
    void
    CoreSegment::_resolve(armem::wm::CoreSegment& wmCoreSegment)
    {
        ARMARX_TRACE;
 
        ARMARX_DEBUG << "Resolve core segment id=" << id().cleanID().str();
 
        wmCoreSegment.forEachProviderSegment(
            [&](auto& wmProviderSegment)
            {
                std::shared_ptr<persistence::MemoryPersistenceStrategy>
                    providerSegmentPersistenceStrategy(persistenceStrategy_);
 
                ProviderSegment ltmProviderSegment(
                    getExportName(),
                    id().withProviderSegmentName(wmProviderSegment.id().providerSegmentName),
                    processors,
                    providerSegmentPersistenceStrategy);
 
                ltmProviderSegment.resolve(wmProviderSegment);
            });
    }
 
    void
    CoreSegment::_store(const armem::wm::CoreSegment& wmCoreSegment, bool simulatedVersion)
    {
        ARMARX_TRACE;
 
        if (id().coreSegmentName.empty())
        {
            ARMARX_WARNING
                << "During storage of segment '" << wmCoreSegment.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().coreSegmentName = wmCoreSegment.id().coreSegmentName;
        };
 
        ARMARX_DEBUG << "Store core seg";
 
        // add foreign key to memory collection
        if (wmCoreSegment.hasAronType())
        {
            auto& conv = processors->defaultTypeConverter;
 
            auto [vec, modeSuffix] = conv.convert(wmCoreSegment.aronType());
            ARMARX_CHECK_EMPTY(modeSuffix);
 
            std::string key = persistence::MemoryPersistenceStrategy::TYPE_FILENAME + conv.suffix;
 
            // Only write type file if it doesn't already exist
            if (!persistenceStrategy_->containsItem(id(), key))
            {
                persistenceStrategy_->storeItem(id(), key, vec);
                ARMARX_DEBUG << "Stored type information for CoreSegment "
                             << wmCoreSegment.id().coreSegmentName;
            }
        }
        else
        {
            ARMARX_DEBUG << "CoreSegment does not have aron type, so aron type information "
                            "cannot be exported";
            /*writeForeignKeyToPreviousDocument();*/
        }
 
        wmCoreSegment.forEachProviderSegment(
            [&](const auto& wmProviderSegment)
            {
                std::shared_ptr<persistence::MemoryPersistenceStrategy>
                    providerSegmentPersistenceStrategy(persistenceStrategy_);
 
                ProviderSegment ltmProviderSegment(
                    getExportName(),
                    id().withProviderSegmentName(wmProviderSegment.id().providerSegmentName),
                    processors,
                    providerSegmentPersistenceStrategy);
 
                ltmProviderSegment.store(wmProviderSegment, simulatedVersion);
            });
    }
} // namespace armarx::armem::server::ltm