util.cpp

Go to the documentation of this file.

#include "util.h"
 
#include <chrono>
#include <thread>
 
namespace armarx::armem::server::ltm::disk
{
    namespace util
    {
        // check whether a string is a number (e.g. timestamp folders)
        bool
        isNumber(const std::string& s)
        {
            for (char const& ch : s)
            {
                if (std::isdigit(ch) == 0)
                {
                    return false;
                }
            }
            return true;
        }
 
        bool
        checkIfBasePathExists(const std::filesystem::path& mPath)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                return minizip::util::checkZipFile(mPath);
            }
            return filesystem::util::checkIfFolderInFilesystemExists(mPath);
        }
 
        void
        ensureBasePathExists(const std::filesystem::path& mPath, bool createIfNotExistent)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                auto z = minizip::util::ensureZipFile(mPath, createIfNotExistent);
                zipClose(z, NULL);
                return;
            }
            return filesystem::util::ensureFolderInFilesystemExists(mPath, createIfNotExistent);
        }
 
        bool
        checkIfFolderExists(const std::filesystem::path& mPath, const std::filesystem::path& p)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                return minizip::util::checkIfFolderInZipExists(mPath, p);
            }
 
            return filesystem::util::checkIfFolderInFilesystemExists(mPath / p);
        }
 
        void
        ensureFolderExists(const std::filesystem::path& mPath,
                           const std::filesystem::path& p,
                           bool createIfNotExistent)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                return minizip::util::ensureFolderInZipExists(mPath, p, createIfNotExistent);
            }
 
            return filesystem::util::ensureFolderInFilesystemExists(mPath / p, createIfNotExistent);
        }
 
        bool
        checkIfFileExists(const std::filesystem::path& mPath, const std::filesystem::path& p)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                return minizip::util::checkIfFileInZipExists(mPath, p);
            }
 
            return filesystem::util::checkIfFileInFilesystemExists(mPath / p);
        }
 
        void
        ensureFileExists(const std::filesystem::path& mPath, const std::filesystem::path& p)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                return minizip::util::ensureFileInZipExists(mPath, p);
            }
 
            return filesystem::util::ensureFileInFilesystemExists(mPath / p);
        }
 
        void
        writeDataToFile(const std::filesystem::path& mPath,
                        const std::filesystem::path& p,
                        const std::vector<unsigned char>& data)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                return minizip::util::writeDataInFileInZipFile(mPath, p, data);
            }
 
            return filesystem::util::writeDataInFilesystemFile(mPath / p, data);
        }
 
        void
        writeDataToFileRepeated(const std::filesystem::path& mPath,
                                const std::filesystem::path& p,
                                const std::vector<unsigned char>& data,
                                const unsigned int maxTries,
                                const unsigned int sleepTimeMs)
        {
            for (unsigned int i = 0; i < maxTries; ++i)
            {
                try
                {
                    writeDataToFile(mPath, p, data);
                    return;
                }
                catch (const error::ArMemError&)
                {
                    // wait a bit to give the filesystem enough time to manage the workload
                    std::this_thread::sleep_for(std::chrono::milliseconds(sleepTimeMs));
                }
            }
 
            // even after all the tries we did not succeeded. This is very bad!
            throw error::ArMemError(
                "ATTENTION! Even after " + std::to_string(maxTries) +
                " tries, the memory was not able to store the instance at path '" + p.string() +
                "'. This means this instance will be lost!");
        }
 
        std::vector<unsigned char>
        readDataFromFile(const std::filesystem::path& mPath, const std::filesystem::path& p)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                return minizip::util::readDataFromFileInZipFile(mPath, p);
            }
 
            return filesystem::util::readDataFromFilesystemFile(mPath / p);
        }
 
        std::vector<std::string>
        getAllDirectories(const std::filesystem::path& mPath, const std::filesystem::path& p)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                return {};
            }
 
            return filesystem::util::getAllFilesystemDirectories(mPath / p);
        }
 
        std::vector<std::string>
        getAllFiles(const std::filesystem::path& mPath, const std::filesystem::path& p)
        {
            if (mPath.extension() == minizip::util::MINIZIP_SUFFIX)
            {
                return {};
            }
 
            return filesystem::util::getAllFilesystemFiles(mPath / p);
        }
    } // namespace util
} // namespace armarx::armem::server::ltm::disk