ProviderSegment.cpp

Go to the documentation of this file.

// Header
#include "ProviderSegment.h"
 
// ArmarX
#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
{
    ProviderSegment::ProviderSegment(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) :
        ProviderSegmentBase(exportName, id, filters),
        DiskMemoryItemMixin(p, exportName, id),
        MongoDBStorageMixin(s, exportName, id)
    {
        //start();
    }
 
    bool
    ProviderSegment::forEachEntity(std::function<void(Entity&)> func) const
    {
        std::lock_guard l(ltm_mutex);
 
        /*if (connected() && collectionExists())
        {
            for (const auto& doc : getAllDocuments())
            {
                std::string id_str = doc[FOREIGN_KEY];
                armem::MemoryID segment_id(id_str);
                Entity c(
                    getMemoryBasePath(), getSettings(), getExportName(), segment_id, processors);
                func(c);
            }
        } else */
 
        if (fullPathExists())
        {
 
            for (const auto& subdirName : getAllDirectories())
            {
 
                std::string segmentName = util::fs::detail::unescapeName(subdirName);
                Entity c(getMemoryBasePath(),
                         getSettings(),
                         getExportName(),
                         id().withEntityName(segmentName),
                         processors);
                func(c);
            }
        }
        return true;
    }
 
    bool
    ProviderSegment::hasEntity(const std::string& name) const
    {
        std::lock_guard l(ltm_mutex);
 
        /*if (connected() && collectionExists())
        {
            auto c = Entity(getMemoryBasePath(),
                            getSettings(),
                            getExportName(),
                            id().withEntityName(name),
                            processors);
            return (bool)c.collectionExists();
        }*/
 
        if (fullPathExists())
        {
            ARMARX_INFO << VAROUT(id().getEntityID());
            auto c = Entity(getMemoryBasePath(),
                            getSettings(),
                            getExportName(),
                            id().withEntityName(name),
                            processors);
            return c.fullPathExists();
        }
 
        return false;
    }
 
    std::shared_ptr<Entity>
    ProviderSegment::findEntity(const std::string& entityName) const
    {
        std::lock_guard l(ltm_mutex);
 
        if (!hasEntity(entityName))
        {
            return nullptr;
        }
        return std::make_shared<Entity>(getMemoryBasePath(),
                                        getSettings(),
                                        getExportName(),
                                        id().withEntityName(entityName),
                                        processors);
    }
 
    void
    ProviderSegment::_loadAllReferences(armem::wm::ProviderSegment& e)
    {
        std::lock_guard l(ltm_mutex);
 
        e.id() = id().getProviderSegmentID().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;
        }
 
        ARMARX_INFO << VAROUT(id());
 
        /*
 
        auto& conv = processors->defaultTypeConverter;
        auto setType = [&conv, &e](const std::vector<unsigned char>& aronJson)
        {
            auto typeAron = conv.convert(aronJson, "");
            e.aronType() = aron::type::Object::DynamicCastAndCheck(typeAron);
        };
 
        */
 
        /*if (connected() && collectionExists())
        {
            // TODO:
        } else */
 
        /*
 
        if (std::string filename = TYPE_FILENAME + conv.suffix;
            fullPathExists() && fileExists(filename))
        {
            auto typeFileContent = readDataFromFile(filename);
            setType(typeFileContent);
        }
 
        */
 
        forEachEntity(
            [&e](auto& x)
            {
                armem::wm::Entity s;
                x.loadAllReferences(s);
                e.addEntity(s);
            });
    }
 
    void
    ProviderSegment::_resolve(armem::wm::ProviderSegment& p)
    {
        std::lock_guard l(ltm_mutex);
 
        if (/*(connected() && collectionExists()) ||*/ fullPathExists())
        {
            p.forEachEntity(
                [&](auto& e)
                {
                    Entity c(getMemoryBasePath(),
                             getSettings(),
                             getExportName(),
                             id().withEntityName(e.id().entityName),
                             processors);
                    c.resolve(e);
                });
        }
    }
 
    void
    ProviderSegment::_store(const armem::wm::ProviderSegment& p)
    {
        std::lock_guard l(ltm_mutex);
 
        if (id().providerSegmentName.empty())
        {
            ARMARX_WARNING
                << "During storage of segment '" << p.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 = p.id().providerSegmentName;
        }
 
        /*if (!connected())
        {
            ARMARX_WARNING << "LTM PROVIDER SEGMENT NOT CONNECTED ALTHOUGH ENABLED " << id().str();
            return;
        }*/
 
        // add foreign key to memory collection
        if (p.hasAronType())
        {
            auto& conv = processors->defaultTypeConverter;
 
            auto [vec, modeSuffix] = conv.convert(p.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 << "ProviderSegment does not seem to have an aron type, so aron type information connot be exported";
            //writeForeignKeyToPreviousDocument();
        }
 
        p.forEachEntity(
            [&](const auto& e)
            {
                Entity c(getMemoryBasePath(),
                         getSettings(),
                         getExportName(),
                         id().withEntityName(e.id().entityName),
                         processors);
 
                c.store(e);
                statistics.recordedEntities++;
            });
        }
 
} // namespace armarx::armem::server::ltm