file_search_path.hpp

Go to the documentation of this file.

#pragma once
 
// FileSearchPath — ordered list of directories to scan when resolving a
// file by relative name.
//
// Typical use: a plugin needs to locate a "preset.xml" or a font file that
// might live in any of several user-/installer-/bundle-supplied roots, and
// wants the lookup order to be controllable (and persistable into a
// settings file). FileSearchPath holds the ordered roots, finds the first
// match, optionally finds all matches across all roots, and can serialize
// to / from the platform's PATH-style separator (`:` on POSIX, `;` on
// Windows) so it round-trips through `PropertiesFile` cleanly.
//
// Order is the whole point: the FIRST root that contains the name wins, so
// callers express precedence (user override before installed default before
// bundled fallback) simply by the order in which they add roots.
 
#include <filesystem>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace pulp::runtime {
 
class FileSearchPath {
public:
    FileSearchPath() = default;

    explicit FileSearchPath(std::string_view serialized) {
        from_string(serialized);
    }

    static constexpr char separator() noexcept {
#if defined(_WIN32) || defined(_WIN64)
        return ';';
#else
        return ':';
#endif
    }

    std::size_t size() const noexcept { return paths_.size(); }

    bool empty() const noexcept { return paths_.empty(); }

    const std::filesystem::path& operator[](std::size_t i) const {
        return paths_[i];
    }

    void add(const std::filesystem::path& dir) {
        if (dir.empty()) return;
        for (const auto& existing : paths_) {
            if (existing == dir) return;
        }
        paths_.push_back(dir);
    }

    void add_at_front(const std::filesystem::path& dir) {
        if (dir.empty()) return;
        for (auto it = paths_.begin(); it != paths_.end(); ++it) {
            if (*it == dir) {
                paths_.erase(it);
                break;
            }
        }
        paths_.insert(paths_.begin(), dir);
    }

    void clear() noexcept { paths_.clear(); }

    void remove(std::size_t i) {
        if (i < paths_.size()) {
            paths_.erase(paths_.begin() + static_cast<std::ptrdiff_t>(i));
        }
    }

    const std::vector<std::filesystem::path>& paths() const noexcept {
        return paths_;
    }

    std::optional<std::filesystem::path> find(
        const std::filesystem::path& filename) const {
        if (filename.empty()) return std::nullopt;
        std::error_code ec;
        for (const auto& dir : paths_) {
            auto candidate = dir / filename;
            if (std::filesystem::exists(candidate, ec)) {
                return candidate;
            }
        }
        return std::nullopt;
    }

    std::vector<std::filesystem::path> find_all(
        const std::filesystem::path& filename) const {
        std::vector<std::filesystem::path> hits;
        if (filename.empty()) return hits;
        std::error_code ec;
        for (const auto& dir : paths_) {
            auto candidate = dir / filename;
            if (std::filesystem::exists(candidate, ec)) {
                hits.push_back(candidate);
            }
        }
        return hits;
    }

    std::string to_string() const {
        std::string out;
        const char sep = separator();
        bool first = true;
        for (const auto& p : paths_) {
            if (!first) out.push_back(sep);
            out += p.string();
            first = false;
        }
        return out;
    }

    void from_string(std::string_view serialized) {
        paths_.clear();
        const char sep = separator();
        std::size_t start = 0;
        while (start <= serialized.size()) {
            std::size_t end = serialized.find(sep, start);
            if (end == std::string_view::npos) end = serialized.size();
            if (end > start) {
                auto piece = serialized.substr(start, end - start);
                add(std::filesystem::path(std::string(piece)));
            }
            if (end == serialized.size()) break;
            start = end + 1;
        }
    }
 
    bool operator==(const FileSearchPath& other) const noexcept {
        return paths_ == other.paths_;
    }
    bool operator!=(const FileSearchPath& other) const noexcept {
        return !(*this == other);
    }
 
private:
    std::vector<std::filesystem::path> paths_;
};
 
}  // namespace pulp::runtime