FileSystem.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2020 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version in addition to the terms of any
 *  licences already herein identified.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * FileSystem.hpp
 *
 * Namespace for global file system helper functions.
 *
 *  Created on: Dec 10, 2018
 *      Author: ans
 */

#ifndef HELPER_FILESYSTEM_HPP_
#define HELPER_FILESYSTEM_HPP_

#include "../Main/Exception.hpp"

#include "Portability/filesystem.h"

#include <algorithm>    // std::equal
#include <cstdint>      // std::uintmax_t
#include <iterator>     // std::distance
#include <string>       // std::string
#include <string_view>  // std::string_view
#include <vector>       // std::vector

namespace crawlservpp::Helper::FileSystem {

    /*
     * DECLARATION
     */


    bool exists(std::string_view path);
    bool isValidDirectory(std::string_view path);
    bool isValidFile(std::string_view path);


    char getPathSeparator();
    std::vector<std::string> listFilesInPath(
            std::string_view pathToDir,
            std::string_view fileExtension
    );
    bool contains(std::string_view pathToDir, std::string_view pathToCheck);
    void createDirectory(std::string_view pathToDir);
    void createDirectoryIfNotExists(std::string_view pathToDir);
    void clearDirectory(std::string_view pathToDir);


    std::uintmax_t getFreeSpace(std::string_view path);


    /*
     * CLASS FOR FILE SYSTEM EXCEPTIONS
     */


    MAIN_EXCEPTION_CLASS();

    /*
     * IMPLEMENTATION
     */


    inline bool exists(std::string_view path) {
        try {
            return stdfs::exists(path);
        }
        catch(const stdfs::filesystem_error& e) {
            std::string exceptionString{"Could not check the existence of the path '"};

            exceptionString += path;
            exceptionString += "': ";
            exceptionString += e.what();

            throw Exception(exceptionString);
        }
    }


    inline bool isValidDirectory(std::string_view path) {
        const stdfs::path dir(path);

        try {
            return stdfs::exists(dir) && stdfs::is_directory(dir);
        }
        catch(const stdfs::filesystem_error& e) {
            std::string exceptionString{"Could not check the existence of the directory '"};

            exceptionString += path;
            exceptionString += "': ";
            exceptionString += e.what();

            throw Exception(exceptionString);
        }
    }


    inline bool isValidFile(std::string_view path) {
        const stdfs::path file(path);

        try {
            return stdfs::exists(file) && stdfs::is_regular_file(file);
        }
        catch(const stdfs::filesystem_error& e) {
            std::string exceptionString{"Could not check the validity of the file '"};

            exceptionString += path;
            exceptionString += "': ";
            exceptionString += e.what();

            throw Exception(exceptionString);
        }
    }


    inline char getPathSeparator() {
        return stdfs::path::preferred_separator;
    }


    inline std::vector<std::string> listFilesInPath(
            std::string_view pathToDir,
            std::string_view fileExtension
    ) {
        std::vector<std::string> result;

        // open path
        const stdfs::path path(pathToDir);

        if(!stdfs::exists(path)) {
            std::string exceptionString{"'"};

            exceptionString += pathToDir;
            exceptionString += "' does not exist";

            throw Exception(exceptionString);
        }

        if(!stdfs::is_directory(path)) {
            std::string exceptionString{"'"};

            exceptionString += pathToDir;
            exceptionString += "' is not a directory";

            throw Exception(exceptionString);
        }

        // iterate through items
        try {
            for(const auto& it: stdfs::recursive_directory_iterator(path)) {
                if(fileExtension.empty() || it.path().extension().string() == fileExtension) {
                    result.emplace_back(it.path().string());
                }
            }
        }
        catch(const stdfs::filesystem_error& e) {
            std::string exceptionString{"Could not iterate over the files in '"};

            exceptionString += pathToDir;
            exceptionString += "': ";
            exceptionString += e.what();

            throw Exception(exceptionString);
        }

        return result;
    }


    inline bool contains(std::string_view pathToDir, std::string_view pathToCheck) {
        if(!FileSystem::isValidDirectory(pathToDir)) {
            std::string exceptionString{"'"};

            exceptionString += pathToDir;
            exceptionString += "' is not a valid directory";

            throw Exception(exceptionString);
        }

        // make paths absolute
        try {
            const auto absPathToDir{
                stdfs::canonical(pathToDir)
            };

#ifndef INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
            // create weakly canonical path
            auto absPathToCheck{
                stdfs::weakly_canonical(pathToCheck)
            };
#else
            // create approximate canonical path – no symlinks supported!
            auto completePathToCheck{
                stdfs::absolute(pathToCheck)
            };

            stdfs::path absPathToCheck;

            for(const auto& segment : completePathToCheck) {
                if(segment == "..") {
                    absPathToCheck = absPathToCheck.parent_path();
                }
                else if(segment == ".") {
                    continue;
                }
                else {
                    absPathToCheck /= segment;
                }

                if(stdfs::is_symlink(absPathToCheck)) {
                    std::string exceptionString{
                        "Path contains unsupported symlink: '"
                    };

                    exceptionString += absPathToCheck;
                    exceptionString += "'";

                    throw Exception(exceptionString);
                }
            }
#endif

            // remove filename if necessary
            if(absPathToCheck.has_filename()) {
                absPathToCheck.remove_filename();
            }

            // compare number of path components
            if(
                    std::distance(absPathToDir.begin(), absPathToDir.end())
                    > std::distance(absPathToCheck.begin(), absPathToCheck.end())
            ) {
                // pathToCheck cannot be contained in a path with more components
                return false;
            }

            // compare as many components as there are in pathToDir
            return std::equal(absPathToDir.begin(), absPathToDir.end(), absPathToCheck.begin());
        }
        catch(const stdfs::filesystem_error& e) {
            std::string exceptionString{
                "Could not make paths absolute: '"
            };

            exceptionString += pathToDir;
            exceptionString += "' and '";
            exceptionString += pathToCheck;
            exceptionString += "': ";
            exceptionString += e.what();

            throw Exception(exceptionString);
        }
    }


    inline void createDirectory(std::string_view pathToDir) {
        try {
            stdfs::create_directory(pathToDir);
        }
        catch(const stdfs::filesystem_error& e) {
            std::string exceptionString{"Could not create directory '"};

            exceptionString += pathToDir;
            exceptionString += "': ";
            exceptionString += e.what();

            throw Exception(exceptionString);
        }
    }


    inline void createDirectoryIfNotExists(std::string_view pathToDir) {
        if(!FileSystem::isValidDirectory(pathToDir)) {
            FileSystem::createDirectory(pathToDir);
        }
    }


    inline void clearDirectory(std::string_view pathToDir) {
        if(!FileSystem::isValidDirectory(pathToDir)) {
            std::string exceptionString{"'"};

            exceptionString += pathToDir;
            exceptionString += "' is not a valid directory";

            throw Exception(exceptionString);
        }

        const stdfs::path dir(pathToDir);

        for(stdfs::directory_iterator it(pathToDir), endIt; it != endIt; ++it) {
            try {
                stdfs::remove_all(it->path());
            }
            catch(const stdfs::filesystem_error& e) {
                std::string exceptionString{"Could not remove '"};

                exceptionString += it->path();
                exceptionString += "' with all its subdirectories: ";
                exceptionString += e.what();

                throw Exception(exceptionString);
            }
        }
    }


    inline std::uintmax_t getFreeSpace(std::string_view path) {
        try {
            return stdfs::space(path).available;
        }
        catch(const stdfs::filesystem_error& e) {
            std::string exceptionString{"Could not get the available disk space at '"};

            exceptionString += path;
            exceptionString += "': ";
            exceptionString += e.what();

            throw Exception(exceptionString);
        }
    }

} /* namespace crawlservpp::Helper::FileSystem */

#endif /* HELPER_FILESYSTEM_HPP_ */