path.hpp

Go to the documentation of this file.

/*
Copyright (c) 2025 acrion innovations GmbH
Authors: Stefan Zipproth, s.zipproth@acrion.ch
 
This file is part of Cbeam, see https://github.com/acrion/cbeam and https://cbeam.org
 
Cbeam is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://acrion.ch/sales. For AGPL licensing, see below.
 
AGPL licensing:
 
Cbeam is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Cbeam 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 Affero General Public License for more details.
 
You should have received a copy of the GNU Affero General Public License
along with Cbeam. If not, see <https://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include <cbeam/error/runtime_error.hpp> // for cbeam::error:runtime_error
#include <cbeam/random/generators.hpp>   // for cbeam::random::random_string
 
#include <cstddef> // for std::size_t
 
#include <algorithm>    // for std::equal
#include <exception>    // for std::exception
#include <filesystem>   // for std::filesystem::path, std::filesystem::exists, std::filesystem::operator!=, std::filesystem::is_directory, std::filesystem::operator/, std::filesystem::operator==, std::filesystem::directory_iterator
#include <list>         // for std::list
#include <regex>        // for std::regex_search, std::regex
#include <string>       // for std::allocator, std::operator+, std::operator!=, std::string_literals::operator""s, std::char_traits, std::string, std::operator==, std::basic_string, std::string_literals
#include <system_error> // for std::error_code
 
namespace cbeam::filesystem
{
    class path
    {
    public:
        explicit path(const std::filesystem::path& path)
            : _base_path(normalize(path)) {}

        operator std::filesystem::path() // NOLINT(google-explicit-constructor)
        {
            return _base_path;
        }

        std::list<std::filesystem::path> get_subdirs(const std::regex& filter = std::regex(".*"))
        {
            std::list<std::filesystem::path> directories_list;
 
            if (std::filesystem::exists(_base_path) && std::filesystem::is_directory(_base_path))
            {
                for (auto it = std::filesystem::directory_iterator(_base_path); it != std::filesystem::directory_iterator(); ++it)
                {
                    bool        is_directory = std::filesystem::is_directory(*it);
                    std::string path_str     = it->path().string();
 
                    if (is_directory && std::regex_search(path_str, filter))
                    {
                        directories_list.emplace_back(path_str);
                    }
                }
            }
 
            return directories_list;
        }

        void create_directory(bool delete_prior_creating = false) const
        {
            using namespace std::string_literals;
 
            bool        success = false;
            std::string msg     = "unknown error"s;
            try
            {
                if (delete_prior_creating)
                {
                    std::filesystem::remove_all(_base_path);
                }
 
                if (!std::filesystem::exists(_base_path))
                {
                    // According to https://en.cppreference.com/w/cpp/filesystem/create_directory this should return true
                    // if the directory was created. But in Windows SDK 10.0.19041.0, it returns false if the path ends with
                    // a '\' and its last component has been created successfully.
                    std::filesystem::create_directories(_base_path);
                }
                success = std::filesystem::exists(_base_path);
            }
            catch (std::exception& ex)
            {
                msg = ex.what();
            }
 
            if (!success)
            {
                std::string err_msg("cbeam::filesystem::path::create(\"" + _base_path.string() + "\"): " + msg);
                throw cbeam::error::runtime_error(err_msg);
            }
        }

        void copy_to(const std::filesystem::path& target) const
        {
            if (!std::filesystem::exists(_base_path) || !std::filesystem::is_directory(_base_path))
            {
                throw cbeam::error::runtime_error("cbeam::filesystem::path::copy_to: source directory " + _base_path.string() + " does not exist or is not a directory");
            }
            if (std::filesystem::exists(target))
            {
                path(target).remove();
            }
 
            std::filesystem::copy(_base_path, target, std::filesystem::copy_options::recursive);
        }

        void remove() const
        {
            std::error_code             error;
            const std::filesystem::path temp_path = std::filesystem::path(remove_trailing_directory_separators(_base_path).string() + cbeam::random::random_string(16));
 
            // We first try to rename, because under Windows, remove_all can result in a modified directory with partly deleted files in case an error occurs.
            // We deliberately do not move to a unique subdir of std::filesystem::temp_directory_path(), because this might require to actually copy the complete
            // directory tree. In contrast, we rename only the last path component, which is an atomic operation. The usage of this method implies that we
            // should have write access to rename the directory to a path next to it (if not, removing the directory would also fail).
            // Note that under Windows, a DLL inside the directory that is in use does not prevent the directory from being renamed by this method.
            std::filesystem::rename(_base_path, temp_path, error);
            if (error)
            {
                throw cbeam::error::runtime_error(error.message());
            }
            std::filesystem::remove_all(temp_path, error);
            if (error)
            {
                std::filesystem::rename(temp_path, _base_path, error); // rename back to original
                throw cbeam::error::runtime_error(error.message());
            }
        }

        bool operator==(const path& other) const
        {
            return _base_path == other._base_path;
        }

        bool operator!=(const path& other) const
        {
            return _base_path != other._base_path;
        }

        bool operator==(const std::filesystem::path& other) const
        {
            return _base_path == other;
        }

        bool operator!=(const std::filesystem::path& other) const
        {
            return _base_path != other;
        }

        static std::filesystem::path remove_trailing_directory_separators(const std::filesystem::path& p)
        {
            std::string s = p.string();
 
            // although '/' and '\' should be the only path separators, this is not defined by the C++ standard, so we check the preferred one in addition to care about potential exotic platforms
            while (!s.empty() && (s.back() == std::filesystem::path::preferred_separator || s.back() == '/' || s.back() == '\\'))
            {
                s.pop_back();
            }
            return std::filesystem::path(s);
        }
 
    private:
        static std::filesystem::path normalize(const std::filesystem::path& p)
        {
            using namespace std::string_literals;
            std::filesystem::path result;
 
            std::size_t numParent = 0;
            auto        it        = p.end();
 
            while (it != p.begin())
            {
                --it;
                if (it->string() != "/" && it->string() != "\\" && !it->empty())
                {
                    if (it->string() == "..")
                    {
                        ++numParent;
                    }
                    else if (numParent > 0)
                    {
                        --numParent;
                    }
                    else
                    {
                        std::string colon = ":"s;
                        if (std::equal(colon.rbegin(), colon.rend(), it->string().rbegin()))
                        {
#ifdef _WIN32
                            result = (it->wstring() + std::filesystem::path::preferred_separator) / result;
#else
                            result = (it->string() + std::filesystem::path::preferred_separator) / result;
#endif
                        }
                        else
                        {
                            result = *it / result;
                        }
                    }
                }
            }
 
            if (*p.begin() == "/"s)
            {
                result = *p.begin() / result;
            }
 
            return result;
        }
 
        std::filesystem::path _base_path;
    };
}