types.hxx

Go to the documentation of this file.

#pragma once
 
// Linux
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
 
// C++
#include <iosfwd>
#include <string>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/dso_export.h>
#include <cosmos/utils.hxx>
 
namespace cosmos {
 
using FollowSymlinks = NamedBool<struct follow_links_t, false>;
 
using AutoCloseFD = NamedBool<struct close_file_t, true>;
 
enum class FileNum : int {
        INVALID = -1,
        STDIN   = STDIN_FILENO,
        STDOUT  = STDOUT_FILENO,
        STDERR  = STDERR_FILENO,
        AT_CWD  = AT_FDCWD,
        MAX_FD  = ~int(0)
};
enum class FileNum : int {…};
 
enum class Inode : ino_t {
};
enum class Inode : ino_t {…};
 
enum class DeviceID : dev_t {
};
enum class DeviceID : dev_t {…};
 
enum class OpenMode : int {
        READ_ONLY  = O_RDONLY,
        WRITE_ONLY = O_WRONLY,
        READ_WRITE = O_RDWR
};
enum class OpenMode : int {…};
 
enum class OpenFlag : int {
        APPEND             = O_APPEND,
        ASYNC              = O_ASYNC,
        CLOEXEC            = O_CLOEXEC,
        CREATE             = O_CREAT,
        DIRECT             = O_DIRECT,
        DIRECTORY          = O_DIRECTORY,
        DSYNC              = O_DSYNC,
        EXCLUSIVE          = O_EXCL,
        NOATIME            = O_NOATIME,
        NO_CONTROLLING_TTY = O_NOCTTY,
        NOFOLLOW           = O_NOFOLLOW,
        NONBLOCK           = O_NONBLOCK,
        PATH               = O_PATH,
        SYNC               = O_SYNC,
        TMPFILE            = O_TMPFILE,
        TRUNCATE           = O_TRUNC
};
enum class OpenFlag : int {…};
 
using OpenFlags = BitMask<OpenFlag>;
 
 
enum class ModeT : mode_t {
        NONE      = 0,
        MODE_T_TYPE_MASK = S_IFMT, 
        MODE_T_MODE_MASK = ~static_cast<mode_t>(S_IFMT) 
};
enum class ModeT : mode_t {…};
 
inline ModeT operator&(const ModeT a, const ModeT b) {
        auto ret = static_cast<mode_t>(a) & static_cast<mode_t>(b);
        return static_cast<ModeT>(ret);
}
inline ModeT operator&(const ModeT a, const ModeT b) {…}
 
 
enum class FileModeBit : mode_t {
        SETUID      = S_ISUID, // set user-id bit
        SETGID      = S_ISGID, // set group-id bit
        STICKY      = S_ISVTX, // only has a meaning for directory, typically set on /tmp
        OWNER_READ  = S_IRUSR,
        OWNER_WRITE = S_IWUSR,
        OWNER_EXEC  = S_IXUSR,
        OWNER_ALL   = S_IRWXU,
        GROUP_READ  = S_IRGRP,
        GROUP_WRITE = S_IWGRP,
        GROUP_EXEC  = S_IXGRP,
        GROUP_ALL   = S_IRWXG,
        OTHER_READ  = S_IROTH,
        OTHER_WRITE = S_IWOTH,
        OTHER_EXEC  = S_IXOTH,
        OTHER_ALL   = S_IRWXO
};
enum class FileModeBit : mode_t {…};
 
using FileModeBits = BitMask<FileModeBit>;
 
 
class COSMOS_API FileType {
public: // types
 
 
        enum FileT : mode_t {
                NONE      = 0,
                SOCKET    = S_IFSOCK,
                LINK      = S_IFLNK, 
                REGULAR   = S_IFREG,
                BLOCKDEV  = S_IFBLK,
                DIRECTORY = S_IFDIR,
                CHARDEV   = S_IFCHR,
                FIFO      = S_IFIFO 
        };
        enum FileT : mode_t {…};
 
public:
        explicit FileType(const FileT raw) : m_raw{raw} {}
 
        explicit FileType(const ModeT raw) :
                m_raw{static_cast<FileT>(raw & ModeT::MODE_T_TYPE_MASK)}
        {}
 
        bool isRegular()   const { return m_raw == REGULAR;  }
        bool isDirectory() const { return m_raw == DIRECTORY; }
        bool isCharDev()   const { return m_raw == CHARDEV; }
        bool isBlockDev()  const { return m_raw == BLOCKDEV; }
        bool isFIFO()      const { return m_raw == FIFO; }
        bool isLink()      const { return m_raw == LINK; }
        bool isSocket()    const { return m_raw == SOCKET; }
 
        auto raw() const { return m_raw; }
 
 
        char symbolic() const;
 
        bool operator==(const FileType &other) const {
                return m_raw == other.m_raw;
        }
 
        bool operator!=(const FileType &other) const {
                return !(*this == other);
        }
 
protected: // data
 
        FileT m_raw;
};
class COSMOS_API FileType {…};
 
 
class COSMOS_API FileMode {
public:
        explicit FileMode(const FileModeBits mask) :
                m_mode{mask}
        {}
        explicit FileMode(const FileModeBits mask) : {…}
 
 
        FileMode(const ModeT raw = ModeT::NONE) :
                m_mode{static_cast<FileModeBit>(raw & ModeT::MODE_T_MODE_MASK)}
        {}
        FileMode(const ModeT raw = ModeT::NONE) : {…}
 
        bool isSetUID() const { return m_mode[FileModeBit::SETUID]; }
        bool isSetGID() const { return m_mode[FileModeBit::SETGID]; }
        bool isSticky() const { return m_mode[FileModeBit::STICKY]; }
 
        bool canOwnerRead()  const { return m_mode[FileModeBit::OWNER_READ]; }
        bool canOwnerWrite() const { return m_mode[FileModeBit::OWNER_WRITE]; }
        bool canOwnerExec()  const { return m_mode[FileModeBit::OWNER_EXEC]; }
 
        bool canGroupRead()  const { return m_mode[FileModeBit::GROUP_READ]; }
        bool canGroupWrite() const { return m_mode[FileModeBit::GROUP_WRITE]; }
        bool canGroupExec()  const { return m_mode[FileModeBit::GROUP_EXEC]; }
 
        bool canOthersRead()  const { return m_mode[FileModeBit::OTHER_READ]; }
        bool canOthersWrite() const { return m_mode[FileModeBit::OTHER_WRITE]; }
        bool canOthersExec()  const { return m_mode[FileModeBit::OTHER_EXEC]; }
 
        bool canAnyRead() const {
                return m_mode.anyOf({
                                FileModeBit::OWNER_READ,
                                FileModeBit::GROUP_READ,
                                FileModeBit::OTHER_READ});
        }
 
        bool canAnyWrite() const {
                return m_mode.anyOf({
                                FileModeBit::OWNER_WRITE,
                                FileModeBit::GROUP_WRITE,
                                FileModeBit::OTHER_WRITE});
        }
 
        bool canAnyExec() const {
                return m_mode.anyOf({
                                FileModeBit::OWNER_EXEC,
                                FileModeBit::GROUP_EXEC,
                                FileModeBit::OTHER_EXEC});
        }
 
        FileModeBits& mask() { return m_mode; }
        const FileModeBits& mask() const { return m_mode; }
 
 
        std::string symbolic() const;
 
        ModeT raw() const { return ModeT{m_mode.raw()}; }
 
        bool operator==(const FileMode &other) const {
                return m_mode == other.m_mode;
        }
 
        bool operator!=(const FileMode &other) const {
                return !(*this == other);
        }
 
protected: // data
 
        FileModeBits m_mode;
};
class COSMOS_API FileMode {…};
 
} // end ns
 
COSMOS_API std::ostream& operator<<(std::ostream &o, const cosmos::FileMode mode);
COSMOS_API std::ostream& operator<<(std::ostream &o, const cosmos::FileType type);
COSMOS_API std::ostream& operator<<(std::ostream &o, const cosmos::OpenFlags flags);