filesystem.cpp

Go to the documentation of this file.

#include "filesystem.h"
 
#include <fstream>
#include <iostream>
 
#include <SimoxUtility/algorithm/string.h>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
 
#include <RobotAPI/libraries/armem/core/MemoryID.h>
#include <RobotAPI/libraries/armem/core/error.h>
 
namespace armarx::armem::server::ltm ::util::fs
{
 
    namespace detail
    {
        std::string
        escapeName(const std::string& segmentName)
        {
            std::string ret = segmentName;
            //simox::alg::replace_all(ret, Prefix, PrefixEscaped);
            for (const auto& [s, r] : EscapeTable)
            {
                ret = simox::alg::replace_all(ret, s, r);
            }
            return ret;
        }
 
        std::string
        unescapeName(const std::string& escapedName)
        {
            std::string ret = escapedName;
            for (
                const auto& [s, r] :
                EscapeTable) // Here we assume that noone uses the replaced char usually in the segment name... TODO
            {
                ret = simox::alg::replace_all(ret, r, s);
            }
            return ret;
        }
 
        std::string
        extractLastDirectoryFromPath(const std::string& path)
        {
            size_t pos = path.rfind('/');
 
            if (pos != std::string::npos)
            {
                return path.substr(pos + 1);
            }
            else
            {
                return path;
            }
        }
 
        std::string
        toDayString(const Time& t)
        {
            return t.toDateString();
        }
 
        std::string
        toSecondsString(const Time& t)
        {
            return std::to_string(t.toSecondsSinceEpoch());
        }
 
        bool
        isNumberString(const std::string& s)
        {
            for (char const& ch : s)
            {
                if (std::isdigit(ch) == 0)
                {
                    return false;
                }
            }
            return true;
        }
 
        bool
        isDateString(const std::string& s)
        {
            auto split = simox::alg::split(s, "-");
            if (split.size() != 3)
            {
                return false;
            }
 
            return isNumberString(split[0]) && isNumberString(split[1]) && isNumberString(split[2]);
        }
    } // namespace detail
 
    std::filesystem::path
    toPath(const std::filesystem::path& base, const armem::MemoryID& id)
    {
        ARMARX_CHECK(id.isWellDefined());
 
        std::filesystem::path p = base;
        if (id.hasMemoryName())
        {
            p /= detail::escapeName(id.memoryName);
        }
        if (id.hasCoreSegmentName())
        {
            p /= detail::escapeName(id.coreSegmentName);
        }
        if (id.hasProviderSegmentName())
        {
            p /= detail::escapeName(id.providerSegmentName);
        }
        if (id.hasEntityName())
        {
            p /= detail::escapeName(id.entityName);
        }
        if (id.hasTimestamp())
        {
            p /= detail::toDayString(id.timestamp);
            p /= detail::toSecondsString(id.timestamp);
            p /= id.timestampStr();
        }
        if (id.hasInstanceIndex())
        {
            p /= id.instanceIndexStr();
        }
 
        return p;
    }
 
    bool
    directoryExists(const std::filesystem::path& p)
    {
        return std::filesystem::exists(p) and std::filesystem::is_directory(p);
    }
 
    bool
    fileExists(const std::filesystem::path& p)
    {
        return std::filesystem::exists(p) && std::filesystem::is_regular_file(p);
    }
 
    void
    ensureDirectoryExists(const std::filesystem::path& p, bool createIfNotExistent)
    {
        if (!directoryExists(p))
        {
            if (createIfNotExistent)
            {
                std::filesystem::create_directories(p);
            }
            else
            {
                throw armarx::LocalException("Directory existence cannot be ensured: " +
                                             p.string());
            }
        }
    }
 
    void
    ensureFileExists(const std::filesystem::path& p, bool createIfNotExistent)
    {
        ensureDirectoryExists(p.parent_path(), createIfNotExistent);
        if (!fileExists(p))
        {
            if (createIfNotExistent)
            {
                std::string content = "";
                writeDataToFile(p, {content.begin(), content.end()});
            }
            else
            {
                // not found
                throw armarx::LocalException("Could not find file: " + p.string());
            }
        }
    }
 
    void
    writeDataToFile(const std::filesystem::path& p, const std::vector<unsigned char>& data)
    {
        std::ofstream dataofs;
        dataofs.open(p);
        if (!dataofs)
        {
            throw armarx::LocalException("Could not write data to filesystem file '" + p.string() +
                                         "'. Skipping this file.");
        }
        dataofs.write(reinterpret_cast<const char*>(data.data()), data.size());
        dataofs.close();
    }
 
    std::vector<unsigned char>
    readDataFromFile(const std::filesystem::path& p)
    {
        std::ifstream dataifs(p);
        std::vector<unsigned char> datafilecontent((std::istreambuf_iterator<char>(dataifs)),
                                                   (std::istreambuf_iterator<char>()));
        dataifs.close();
        return datafilecontent;
    }
 
    std::vector<std::filesystem::path>
    getAllDirectories(const std::filesystem::path& p)
    {
        std::vector<std::filesystem::path> ret;
        for (const auto& subdir : std::filesystem::directory_iterator(p))
        {
            std::filesystem::path subdirPath = subdir.path();
            if (std::filesystem::is_directory(subdirPath))
            {
                ret.push_back(subdirPath);
            }
        }
        std::sort(ret.begin(),
                  ret.end(),
                  [](const std::filesystem::path& a, const std::filesystem::path& b) -> bool
                  { return a.string() < b.string(); });
        return ret;
    }
 
    std::vector<std::filesystem::path>
    getAllFiles(const std::filesystem::path& p)
    {
        std::vector<std::filesystem::path> ret;
        for (const auto& subdir : std::filesystem::directory_iterator(p))
        {
            std::filesystem::path subdirPath = subdir.path();
            if (std::filesystem::is_regular_file(subdirPath))
            {
                ret.push_back(subdirPath);
            }
        }
        std::sort(ret.begin(),
                  ret.end(),
                  [](const std::filesystem::path& a, const std::filesystem::path& b) -> bool
                  { return a.string() > b.string(); });
        return ret;
    }
} // namespace armarx::armem::server::ltm::util::fs