DiskStorageMixin.cpp

Go to the documentation of this file.

// Header
#include "DiskStorageMixin.h"
 
// STD/STL
#include <algorithm>
#include <fstream>
#include <iostream>
 
// Simox
#include <SimoxUtility/algorithm/string.h>
 
// ArmarX
#include <ArmarXCore/core/exceptions/LocalException.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/TimeUtil.h>
 
namespace armarx::armem::server::ltm::detail::mixin
{
    DiskMemoryItemMixin::DiskMemoryItemMixin(const Path& memoryParentPath,
                                             const std::string& exportName,
                                             const armem::MemoryID& id) :
        memoryBasePath(memoryParentPath), exportName(exportName), _id(id)
    {
    }
 
    Path
    DiskMemoryItemMixin::addDateToMemoryBasePath(const Path& n) const
    {       
        //set path to include date of creation as prefix:
        auto current_date = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
        std::tm* localTime = std::localtime(&current_date);
 
        // convert current time into string:
        std::stringstream ss;
        ss << std::put_time(localTime, "%Y_%m_%d");
        std::string dateString = ss.str();
 
        // change memory base path to include current date (date of memory creation)
        std::filesystem::path current_base_path = n;
        current_base_path.append(dateString);
 
        //inform user about change:
        ARMARX_DEBUG << "Changed memory base path to include current date of "
                    << dateString
                    << " to "
                    << this->getMemoryBasePath()
                       ;
 
        return current_base_path;
    }
 
    void
    DiskMemoryItemMixin::setMixinExportName(const std::string& n)
    {
        ARMARX_INFO << "Currently setting export name to: " << n;
        exportName = n;
    }
 
    void
    DiskMemoryItemMixin::setMixinMemoryID(const MemoryID& n)
    {
        ARMARX_CHECK_NOT_EMPTY(_id.memoryName) << " The full id was: " << _id.str();
 
        _id = n;
    }
 
    void
    DiskMemoryItemMixin::configureMixin(const nlohmann::json& json)
    {
        if (json.find("DiskMemory.memoryParentPath") != json.end())
        {
            //memoryBasePath = Path(json.at("DiskMemory.memoryParentPath"));
        }
    }
 
    Path
    DiskMemoryItemMixin::getMemoryBasePath() const
    {
        if(memoryBasePathString.empty()){
            return memoryBasePath;
        } else {
            std::filesystem::path newPath;
            newPath.assign(memoryBasePathString);
            return this->addDateToMemoryBasePath(newPath);
        }
    }
 
    Path
    DiskMemoryItemMixin::getFullPath() const
    {
        auto p = getMemoryBasePath() / exportName;
        //ARMARX_INFO << VAROUT(_id);
        //ARMARX_INFO << VAROUT(_id.cleanID());
        auto cleanID = _id.cleanID(); //somehow, the iDs are jumbled when loading the LTM from disk, this solves it for now
 
        return util::fs::toPath(p, cleanID);
    }
 
    bool
    DiskMemoryItemMixin::memoryBasePathExists() const
    {
        return util::fs::directoryExists(getMemoryBasePath());
    }
 
    bool
    DiskMemoryItemMixin::fullPathExists() const
    {
        auto p = getFullPath();
        return util::fs::directoryExists(p);
    }
 
    bool
    DiskMemoryItemMixin::fileExists(const std::string& filename) const
    {
        auto p = getFullPath() / filename;
        return util::fs::fileExists(p);
    }
 
    void
    DiskMemoryItemMixin::ensureMemoryBasePathExists(bool createIfNotExistent) const
    {
        util::fs::ensureDirectoryExists(getMemoryBasePath(), createIfNotExistent);
    }
 
    void
    DiskMemoryItemMixin::ensureFullPathExists(bool createIfNotExistent) const
    {
        auto p = getFullPath();
        util::fs::ensureDirectoryExists(p, createIfNotExistent);
    }
 
    void
    DiskMemoryItemMixin::ensureFileExists(const std::string& filename,
                                          bool createIfNotExistent) const
    {
        auto p = getFullPath() / filename;
        util::fs::ensureFileExists(p, createIfNotExistent);
    }
 
    void
    DiskMemoryItemMixin::writeDataToFile(const std::string& filename,
                                         const std::vector<unsigned char>& data) const
    {
        auto p = getFullPath() / filename;
        util::fs::writeDataToFile(p, data);
    }
 
    std::vector<unsigned char>
    DiskMemoryItemMixin::readDataFromFile(const std::string& filename) const
    {
        auto p = getFullPath() / filename;
        return util::fs::readDataFromFile(p);
    }
 
    std::vector<Path>
    DiskMemoryItemMixin::getAllDirectories() const
    {
        auto p = getFullPath();
        return util::fs::getAllDirectories(p);
    }
 
    std::vector<Path>
    DiskMemoryItemMixin::getAllFiles() const
    {
        auto p = getFullPath();
        return util::fs::getAllFiles(p);
    }
 
    void DiskMemoryItemMixin::createPropertyDefinitions(PropertyDefinitionsPtr &defs, const std::string &prefix)
    {
        defs->optional(memoryBasePathString, prefix + "exportPath");
    }
} // namespace armarx::armem::server::ltm::detail::mixin