fileinfo.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <optional>
#include <promeki/optional.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/filepath.h>
#include <promeki/datetime.h>
#include <promeki/error.h>
#include <promeki/result.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class FileInfo {
        public:
                using Status = std::filesystem::file_status;
 
                FileInfo(const String &filePath) : _path(filePath.str()) {}
 
                FileInfo(const char *filePath) : _path(filePath) {}
 
                FileInfo(const FilePath &fp) : _path(fp.toStdPath()) {}
 
                FilePath filePath() const { return FilePath(_path); }
 
                bool exists() const { return std::filesystem::exists(status()); }
 
                String fileName() const { return _path.filename().string(); }
 
                String baseName() const { return _path.stem().string(); }
 
                String suffix() const {
                        auto ext = _path.extension().string();
                        if (ext.empty()) return String();
                        return ext.substr(1); // Remove leading '.'
                }
 
                String absolutePath() const { return _path.parent_path().string(); }
 
                String absoluteFilePath() const { return std::filesystem::absolute(_path).string(); }
 
                bool isFile() const { return std::filesystem::is_regular_file(status()); }
 
                bool isDirectory() const { return std::filesystem::is_directory(status()); }
 
 
                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 { return FilePath(_path).isPseudoSymlink(); }
 
                bool isLink() const { return isSymlink() || isPseudoSymlink(); }
 
 
                void updateStatus(bool force = false) const {
                        if (!_status.hasValue() || force) {
                                _status = std::filesystem::status(_path);
                        }
                        return;
                }
 
                Status status(bool forceUpdate = false) const {
                        updateStatus(forceUpdate);
                        return _status.value();
                }
 
                Result<int64_t> size() const {
                        if (!isFile()) return makeError<int64_t>(Error::NotExist);
                        std::error_code ec;
                        auto            sz = std::filesystem::file_size(_path, ec);
                        if (ec) return makeError<int64_t>(Error::syserr(ec));
                        return makeResult(static_cast<int64_t>(sz));
                }
 
                bool isReadable() const { return ownerHasPerm(std::filesystem::perms::owner_read); }
 
                bool isWritable() const { return ownerHasPerm(std::filesystem::perms::owner_write); }
 
                bool isExecutable() const { return ownerHasPerm(std::filesystem::perms::owner_exec); }
 
                DateTime lastModified() const {
                        std::error_code ec;
                        auto            t = std::filesystem::last_write_time(_path, ec);
                        if (ec) return DateTime();
                        // file_time_type is not directly convertible to
                        // system_clock::time_point in pre-C++20 stdlibs,
                        // and clock_cast (C++20) is not yet ubiquitous in
                        // the libstdc++/libc++ versions in our matrix.
                        // Shift the file_clock instant onto system_clock
                        // by anchoring both clocks at "now" and applying
                        // the delta — accurate to one tick of either
                        // clock, which is plenty for HTTP semantics.
                        const auto now_fc = decltype(t)::clock::now();
                        const auto now_sc = std::chrono::system_clock::now();
                        const auto sc =
                                std::chrono::time_point_cast<std::chrono::system_clock::duration>(t - now_fc + now_sc);
                        return DateTime(sc);
                }
 
        private:
                std::filesystem::path         _path;
                mutable Optional<Status> _status;
 
                bool ownerHasPerm(std::filesystem::perms bit) const {
                        std::error_code ec;
                        auto            perms = std::filesystem::status(_path, ec).permissions();
                        if (ec) return false;
                        return (perms & bit) != std::filesystem::perms::none;
                }
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE