MemoryHandler.cpp

Go to the documentation of this file.

#include "MemoryHandler.h"
 
#include <filesystem>
#include <iostream>
#include <string>
 
#include <SimoxUtility/algorithm/string/string_tools.h>
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include <RobotAPI/libraries/armem/server/ltm/Memory.h>
#include <RobotAPI/libraries/armem/server/ltm/persistence/MemoryPersistenceStrategy.h>
#include <RobotAPI/libraries/armem/server/ltm/persistence/disk/DiskPersistence.h>
#include <RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h>
#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
 
armarx::armem::gui::MemoryHandler::MemoryHandler(
    std::map<std::string, armem::client::Writer>* memoryWriters)
{
    this->memoryWriters = memoryWriters;
}
 
void
armarx::armem::gui::MemoryHandler::loadFromDisk(const std::string& directory)
{
    ARMARX_INFO << "Loading in separate class";
 
    std::filesystem::path path(directory);
 
    std::map<std::filesystem::path, wm::Memory> memoryData;
 
    if (not std::filesystem::is_directory(path))
    {
        ARMARX_WARNING << "You are trying to load data from a path which does not exist";
        return;
    }
 
    ARMARX_INFO << "Starting to load from disk";
 
    // Find out whether this is a single memory or a collection of memories by searching
    // for a data.aron.* or metadata.aron.* file at depth 5 (if 6 then it is collection of memories)
    bool isSingleMemory = false;
    for (auto i = std::filesystem::recursive_directory_iterator(path);
         i != std::filesystem::recursive_directory_iterator();
         ++i)
    {
        if (i.depth() >
            armem::server::ltm::persistence::MemoryPersistenceStrategy::DEPTH_TO_DATA_FILES + 2)
        {
            // In case we do not find any memory data in here
            ARMARX_WARNING
                << "You are trying to import a directory which does not contain memory data";
            return;
        }
 
        auto& dir = *i;
 
        // if one matches it is enough to check
        if (std::filesystem::is_regular_file(dir.path()) &&
            simox::alg::starts_with(dir.path().filename(), "data.aron"))
        {
            isSingleMemory =
                (i.depth() ==
                 armem::server::ltm::persistence::MemoryPersistenceStrategy::DEPTH_TO_DATA_FILES);
            break;
        }
    }
 
    int numLoaded = 0;
    auto loadMemory = [&](const std::filesystem::path& p)
    {
        if (std::filesystem::is_directory(p))
        {
            std::string defaultIdent = "DefaultDisk";
            std::string exportFolderName = p.parent_path().filename();
            ARMARX_INFO << "Name of the folder trying to import: " << exportFolderName;
            std::string exportName = exportFolderName;
            std::shared_ptr<armem::server::ltm::persistence::DiskPersistence> diskPersistence =
                std::make_shared<armem::server::ltm::persistence::DiskPersistence>(
                    defaultIdent, exportName, p.parent_path().parent_path());
 
            armem::server::ltm::Memory ltm(exportName, p.filename());
            if (ltm.getPersistenceStrategy())
            {
                ltm.getPersistenceStrategy()->addStrategy(diskPersistence);
            }
            else
            {
                std::shared_ptr<armem::server::ltm::persistence::RedundantPersistenceStrategy>
                    redundantPersistence = std::make_shared<
                        armem::server::ltm::persistence::RedundantPersistenceStrategy>();
 
                ltm.setPersistenceStrategy(redundantPersistence);
                ltm.getPersistenceStrategy()->addStrategy(diskPersistence);
            }
 
            armem::wm::Memory memory =
                ltm.loadAllAndResolve(); // load list of references and load data
            memoryData[p] = std::move(memory);
 
            numLoaded++;
        }
    };
 
    if (isSingleMemory)
    {
        loadMemory(path);
    }
    else
    {
        // we have to load multiple memories (each subfolder)
        for (const auto& dir : std::filesystem::directory_iterator(path))
        {
            loadMemory(dir.path());
        }
    }
 
    for (auto& [path, memory] : memoryData)
    {
        std::string name = memory.id().memoryName;
 
        if (memoryWriters && memoryWriters->count(name) > 0)
        {
            // we need to merge the current memory with the one from the disk.
            // Please note that this may ignores coresegments, if not already existent
            auto commit = armem::toCommit(memory);
            memoryWriters->at(name).commit(commit);
        }
        else
        {
            ARMARX_INFO << "No memory with name '" << name
                        << "' available for commit. Create new virtual memory.";
 
            // Please note: Here we assume that a memory server with the same name does not exist.
            // I think this assumption is ok, since nobody should use filepaths as memory name.
            // Nonetheless, we did not restrict the user to do so...
            std::string virtualMemoryName = name; // + " (at " + path.string() + ")";
            memory.id().memoryName = virtualMemoryName;
            memoryData[virtualMemoryName] = std::move(memory);
        }
    }
}