filepath.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <filesystem>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/result.h>
#include <promeki/error.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class FilePath {
        public:
                FilePath() = default;
 
                FilePath(const String &path) : _path(path.str()) {}
 
                FilePath(const char *path) : _path(path) {}
 
                FilePath(const std::filesystem::path &path) : _path(path) {}
 
                bool isEmpty() const { return _path.empty(); }
 
                String fileName() const { return _path.filename().string(); }
 
                String baseName() const { return _path.stem().string(); }
 
                String suffix() const {
                        auto ext = _path.extension().string();
                        if (ext.size() > 1) return ext.substr(1);
                        return String();
                }
 
                String completeSuffix() const {
                        String fn = _path.filename().string();
                        auto   pos = fn.find('.');
                        if (pos == String::npos || pos == 0) return String();
                        return fn.substr(pos + 1);
                }
 
                FilePath parent() const { return FilePath(_path.parent_path()); }
 
                FilePath join(const FilePath &other) const { return FilePath(_path / other._path); }
 
                FilePath operator/(const FilePath &other) const { return join(other); }
 
                FilePath operator/(const String &other) const {
                        return FilePath(_path / std::filesystem::path(other.str()));
                }
 
                FilePath operator/(const char *other) const { return FilePath(_path / std::filesystem::path(other)); }
 
                bool exists() const {
                        std::error_code ec;
                        return std::filesystem::exists(_path, ec);
                }
 
                bool isAbsolute() const { return _path.is_absolute(); }
 
                bool isRelative() const { return _path.is_relative(); }
 
                FilePath absolutePath() const {
                        std::error_code ec;
                        return FilePath(std::filesystem::absolute(_path, ec));
                }
 
                Result<FilePath> canonicalPath() const {
                        std::error_code ec;
                        auto            r = std::filesystem::canonical(_path, ec);
                        if (ec) return Result<FilePath>(*this, Error::Invalid);
                        return Result<FilePath>(FilePath(r), Error::Ok);
                }
 
                Result<FilePath> relativeTo(const FilePath &base) const {
                        std::error_code ec;
                        auto            r = std::filesystem::relative(_path, base._path, ec);
                        if (ec || r.empty()) return Result<FilePath>(*this, Error::Invalid);
                        return Result<FilePath>(FilePath(r), Error::Ok);
                }
 
 
                static constexpr size_t kPseudoSymlinkMaxBytes = 4096;
 
                static constexpr const char *kPseudoSymlinkMagic = "#!/promeki/symlink";
 
                bool isSymlink() const {
                        std::error_code ec;
                        auto            st = std::filesystem::symlink_status(_path, ec);
                        if (ec) return false;
                        return std::filesystem::is_symlink(st);
                }
 
                bool isPseudoSymlink() const;
 
                bool isLink() const { return isSymlink() || isPseudoSymlink(); }
 
                Result<FilePath> readSymlink() const {
                        std::error_code ec;
                        auto            t = std::filesystem::read_symlink(_path, ec);
                        if (ec) return Result<FilePath>(*this, Error::Invalid);
                        return Result<FilePath>(FilePath(t), Error::Ok);
                }
 
                Result<FilePath> readPseudoSymlink() const;
 
                Error writePseudoSymlink(const FilePath &target) const;
 
                Result<FilePath> readLink() const {
                        if (isSymlink()) return readSymlink();
                        if (isPseudoSymlink()) return readPseudoSymlink();
                        return Result<FilePath>(*this, Error::Invalid);
                }
 
                Result<FilePath> resolveLink(int maxHops = 16) const;
 
 
                String toString() const { return _path.string(); }
 
                const std::filesystem::path &toStdPath() const { return _path; }
 
                bool operator==(const FilePath &other) const { return _path == other._path; }
 
                bool operator!=(const FilePath &other) const { return _path != other._path; }
 
                bool operator<(const FilePath &other) const { return _path < other._path; }
 
        private:
                std::filesystem::path _path;
};
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::FilePath);
 
#endif // PROMEKI_ENABLE_CORE