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/system/ArmarXDataPath.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);
 
        return current_base_path;
    }
 
    void
    DiskMemoryItemMixin::setMixinExportName(const std::string& n)
    {
        ARMARX_DEBUG << "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
    {
        std::string p = [&](){
            if(memoryBasePathString.empty()){
                return memoryBasePath.string();
            } 
            
            return memoryBasePathString;
        }();
 
        ArmarXDataPath::ReplaceEnvVars(p);
 
        return p;
    }
 
    Path
    DiskMemoryItemMixin::getFullPath() const
    {
        auto p = getMemoryBasePath() / exportName;
        //p = this->addDateToMemoryBasePath(p);
        //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
 
        auto fullPath = util::fs::toPath(p, cleanID);
 
        //inform user about change:
        ARMARX_DEBUG << "Full path is " << fullPath;
 
        return fullPath;
    }
 
    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