FileStatus.hxx

#pragma once
 
// Linux
#include <sys/stat.h>
 
// C++
#include <cstring>
#include <string_view>
 
// cosmos
#include <cosmos/SysString.hxx>
#include <cosmos/dso_export.h>
#include <cosmos/fs/DirFD.hxx>
#include <cosmos/fs/FileDescriptor.hxx>
#include <cosmos/fs/types.hxx>
#include <cosmos/time/types.hxx>
#include <cosmos/types.hxx>
 
namespace cosmos {
 
 
class COSMOS_API FileStatus {
public: // functions
 
        FileStatus() {
                reset();
        }
 
        explicit FileStatus(const SysString path, const FollowSymlinks follow = FollowSymlinks{false}) {
                updateFrom(path, follow);
        }
 
        explicit FileStatus(const FileDescriptor fd) {
                updateFrom(fd);
        }
 
        explicit FileStatus(const DirFD fd, const SysString path, const FollowSymlinks follow = FollowSymlinks{false}) {
                updateFrom(fd, path, follow);
        }
 
 
        void updateFrom(const SysString path, const FollowSymlinks follow = FollowSymlinks{false});
 
 
        void updateFrom(const FileDescriptor fd);
 
 
        void updateFrom(const DirFD fd, const SysString path, const FollowSymlinks follow = FollowSymlinks{false});
 
        void reset() {
                // we identify an invalid stat structure by clearing the mode
                // field only. Due to the file type bits it should never be
                // zero for any valid struct stat.
                m_st.st_mode = 0;
        }
 
        bool valid() const {
                return m_st.st_mode != 0;
        }
 
        ModeT rawMode() const {
                return ModeT{m_st.st_mode};
        }
 
        FileMode mode() const {
                return FileMode{rawMode()};
        }
 
        FileType type() const {
                return FileType{rawMode()};
        }
 
        DeviceID device() const {
                return DeviceID{m_st.st_dev};
        }
 
 
        Inode inode() const {
                return Inode{m_st.st_ino};
        }
 
        nlink_t numLinks() const {
                return m_st.st_nlink;
        }
 
        UserID uid() const {
                return UserID{m_st.st_uid};
        }
 
        GroupID gid() const {
                return GroupID{m_st.st_gid};
        }
 
 
        off_t size() const {
                switch (type().raw()) {
                        case FileType::REGULAR:
                        case FileType::LINK:
                        case FileType::DIRECTORY:
                                return m_st.st_size;
                        default:
                                throwBadType("invalid type for st_size");
                                return 0;
                }
        };
 
 
        DeviceID representedDevice() const;
 
 
        blksize_t blockSize() const {
                return m_st.st_blksize;
        }
 
 
        blkcnt_t allocatedBlocks() const {
                return m_st.st_blocks;
        }
 
        // NOTE: the TimeSpec timestamp fields are POSIX 2008, before we only
        // had second resolution integers in st_mtime, st_ctime, st_atime.
 
        const RealTime& modTime() const {
                // This is a bit dirty, casting the struct timespec to its
                // wrapper type. Should work as long as we don't change the
                // object size (is checked in the compilation unit for
                // TimeSpec). This saves us some copying since struct timespec
                // is 16 bytes in size.
                return *reinterpret_cast<const RealTime*>(&m_st.st_mtim);
        }
 
 
        const RealTime& statusTime() const {
                return *reinterpret_cast<const RealTime*>(&m_st.st_ctim);
        }
 
 
        const RealTime& accessTime() const {
                return *reinterpret_cast<const RealTime*>(&m_st.st_atim);
        }
 
 
        bool isSameFile(const FileStatus &other) const {
                return this->inode() == other.inode() &&
                        this->device() == other.device();
        }
 
 
        bool operator==(const FileStatus &other) {
                return std::memcmp(&m_st, &other.m_st, sizeof(m_st)) == 0;
        }
 
        bool operator!=(const FileStatus &other) {
                return !(*this == other);
        }
 
protected: // functions
 
        void throwBadType(const std::string_view context) const;
 
protected: // data
 
        struct stat m_st;
};
 
} // end ns