path.h

#pragma once
 
#include <algorithm>
#include <filesystem>
#include <vector>
 
namespace pixelbullet::filesystem
{
[[nodiscard]] inline std::filesystem::path normalized_path(const std::filesystem::path& path)
{
    std::filesystem::path normalized = path.lexically_normal();
    while (!normalized.empty() && !normalized.has_filename())
    {
        const std::filesystem::path parent = normalized.parent_path();
        if (parent.empty() || parent == normalized)
        {
            break;
        }
        normalized = parent;
    }
    return normalized;
}
 
[[nodiscard]] inline bool paths_equal(const std::filesystem::path& lhs, const std::filesystem::path& rhs)
{
    return normalized_path(lhs) == normalized_path(rhs);
}
 
[[nodiscard]] inline bool path_is_within(const std::filesystem::path& path, const std::filesystem::path& directory)
{
    if (path.empty() || directory.empty())
    {
        return false;
    }
 
    const std::filesystem::path normalized_target = normalized_path(path);
    const std::filesystem::path normalized_directory = normalized_path(directory);
    auto target_it = normalized_target.begin();
    for (auto directory_it = normalized_directory.begin(); directory_it != normalized_directory.end(); ++directory_it, ++target_it)
    {
        if (target_it == normalized_target.end() || *target_it != *directory_it)
        {
            return false;
        }
    }
 
    return true;
}
 
inline void normalize_sort_unique_paths(std::vector<std::filesystem::path>& paths)
{
    for (std::filesystem::path& path : paths)
    {
        path = normalized_path(path);
    }
 
    std::sort(paths.begin(), paths.end());
    paths.erase(std::unique(paths.begin(), paths.end()), paths.end());
}
} // namespace pixelbullet::filesystem