CoreSegment.cpp

Go to the documentation of this file.

#include "CoreSegment.h"
 
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/TimeUtil.h>
 
#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
 
namespace armarx::armem::server::ltm
{
    CoreSegment::CoreSegment(const detail::mixin::Path& p,
                             const detail::mixin::MongoDBSettings& s,
 
                             const std::string& exportName,
                             const armem::MemoryID& id /* UNESCAPED */,
                             const std::shared_ptr<Processors>& filters) :
        CoreSegmentBase(exportName, id, filters),
        DiskMemoryItemMixin(p, exportName, id),
        MongoDBStorageMixin(s, exportName, id)
    {
        //start();
    }
 
    bool
    CoreSegment::forEachProviderSegment(std::function<void(ProviderSegment&)> func) const
    {
        std::lock_guard l(ltm_mutex);
 
        if (fullPathExists())
        {
            for (const auto& subdirName : getAllDirectories())
            {
                std::string segmentName = util::fs::detail::unescapeName(subdirName);
                segmentName = util::fs::detail::extractLastDirectoryFromPath(segmentName);
                ProviderSegment c(getMemoryBasePath(),
                                  getSettings(),
                                  getExportName(),
                                  id().withProviderSegmentName(segmentName),
                                  processors);
                func(c);
            }
        }
        return true;
    }
 
    bool
    CoreSegment::hasProviderSegment(const std::string& name) const
    {
        std::lock_guard l(ltm_mutex);
 
        if (fullPathExists())
        {
            auto c = ProviderSegment(getMemoryBasePath(),
                                     getSettings(),
                                     getExportName(),
                                     id().withProviderSegmentName(name),
                                     processors);
 
            return c.fullPathExists();
        }
 
        return false;
    }
 
    std::shared_ptr<ProviderSegment>
    CoreSegment::findProviderSegment(const std::string& providerSegmentName) const
    {
        std::lock_guard l(ltm_mutex);
 
        if (!hasProviderSegment(providerSegmentName))
        {
            return nullptr;
        }
 
        return std::make_shared<ProviderSegment>(getMemoryBasePath(),
                                                 getSettings(),
                                                 getExportName(),
                                                 id().withProviderSegmentName(providerSegmentName),
                                                 processors);
    }
 
    void
    CoreSegment::_loadAllReferences(armem::wm::CoreSegment& e)
    {
        std::lock_guard l(ltm_mutex);
 
        e.id() = id().getCoreSegmentID().cleanID();
 
        //ARMARX_INFO << VAROUT(id());
 
        auto& conv = processors->defaultTypeConverter;
        if (fileExists(DiskMemoryItemMixin::TYPE_FILENAME + conv.suffix))
        {
            // load and set type
            auto& conv = processors->defaultTypeConverter;
 
            auto filecontent = readDataFromFile(DiskMemoryItemMixin::TYPE_FILENAME + conv.suffix);
            auto aron = conv.convert(filecontent, "");
            e.aronType() = aron;
        }
 
        forEachProviderSegment(
            [&e](auto& x)
            {
                armem::wm::ProviderSegment s;
                x.loadAllReferences(s);
                e.addProviderSegment(s);
            });
    }
 
    void
    CoreSegment::_loadLatestNReferences(int n, armem::wm::CoreSegment& e)
    {
        std::lock_guard l(ltm_mutex);
 
        e.id() = id().getCoreSegmentID().cleanID();
 
        auto& conv = processors->defaultTypeConverter;
        if (fileExists(DiskMemoryItemMixin::TYPE_FILENAME + conv.suffix))
        {
            // load and set type
            auto& conv = processors->defaultTypeConverter;
 
            auto filecontent = readDataFromFile(DiskMemoryItemMixin::TYPE_FILENAME + conv.suffix);
            auto aron = conv.convert(filecontent, "");
            e.aronType() = aron;
        }
 
        forEachProviderSegment(
            [&e, &n](auto& x)
            {
                armem::wm::ProviderSegment s;
                x.loadLatestNReferences(n, s);
                e.addProviderSegment(s);
            });
    }
 
    void
    CoreSegment::_resolve(armem::wm::CoreSegment& c)
    {
        std::lock_guard l(ltm_mutex);
 
        if (/*(connected() && collectionExists()) ||*/ fullPathExists())
        {
            c.forEachProviderSegment(
                [&](auto& e)
                {
                    ProviderSegment c(getMemoryBasePath(),
                                      getSettings(),
                                      getExportName(),
                                      id().withProviderSegmentName(e.id().providerSegmentName),
                                      processors);
                    c.resolve(e);
                });
        }
    }
 
    void
    CoreSegment::_store(const armem::wm::CoreSegment& c)
    {
        std::lock_guard l(ltm_mutex);
 
        if (id().coreSegmentName.empty())
        {
            ARMARX_WARNING
                << "During storage of segment '" << c.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 = c.id().coreSegmentName;
        };
 
        /*if (!connected())
        {
            ARMARX_WARNING << "LTM CORE SEGMENT NOT CONNECTED ALTHOUGH ENABLED " << id().str();
            return;
        }*/
 
        // add foreign key to memory collection
        if (c.hasAronType())
        {
            auto& conv = processors->defaultTypeConverter;
 
            auto [vec, modeSuffix] = conv.convert(c.aronType());
            ARMARX_CHECK_EMPTY(modeSuffix);
 
            //std::string dataStr{vec.begin(), vec.end()};
            /*auto dataJson = nlohmann::json::parse(dataStr);
 
            writeForeignKeyToPreviousDocument(dataJson);*/
 
            ensureFullPathExists(true);
            std::string filename = (TYPE_FILENAME + conv.suffix);
            writeDataToFile(filename, vec);
        }
        else
        {
            ARMARX_INFO << "CoreSegment does not have aron type, so aron type information "
                           "cannot be exported";
            /*writeForeignKeyToPreviousDocument();*/
        }
 
        c.forEachProviderSegment(
            [&](const auto& prov)
            {
                ProviderSegment c(getMemoryBasePath(),
                                  getSettings(),
                                  getExportName(),
                                  id().withProviderSegmentName(prov.id().providerSegmentName),
                                  processors);
 
                c.store(prov);
            });
    }
} // namespace armarx::armem::server::ltm