DirEntry.hxx

#pragma once
 
// C++
#include <cstring>
#include <string_view>
 
// Linux
#include <dirent.h>
#include <stddef.h>
 
// cosmos
#include <cosmos/dso_export.h>
#include <cosmos/fs/types.hxx>
 
namespace cosmos {
 
 
class COSMOS_API DirEntry {
        friend class DirStream;
        friend class DirIterator;
 
public: // types
 
 
        enum class DirPos : off_t {};
 
        enum class Type : unsigned char {
                BLOCK_DEVICE = DT_BLK,
                CHAR_DEVICE  = DT_CHR,
                DIRECTORY    = DT_DIR,
                FIFO         = DT_FIFO,
                SYMLINK      = DT_LNK,
                REGULAR      = DT_REG,
                UNIX_SOCKET  = DT_SOCK,
                UNKNOWN      = DT_UNKNOWN
        };
 
protected: // functions
 
        // Only allow the Directory type to create this.
        explicit DirEntry(const struct dirent *entry)
                : m_entry{entry}
        {}
 
 
public: // functions
 
        auto raw() const { return m_entry; }
 
 
        Inode inode() const { return Inode{m_entry->d_ino}; }
 
 
        DirPos dirPos() const { return DirPos{m_entry->d_off}; }
 
 
        size_t nameLength() const {
                // this actually involves padding, so look from a 8-byte
                // offset from the end forwards, still faster for long strings.
                auto len = m_entry->d_reclen - offsetof(struct dirent, d_name) - 1;
 
                len = len < 8 ? 0 : len - 8;
                auto endp = name() + len;
 
                for (size_t i = 0; i < 8; i++) {
                        if (*(endp++) == '\0')
                                return endp - name() - 1;
                }
 
                // unclear how this should ever happen
                return std::strlen(this->name());
        }
 
 
        auto type() const { return Type{m_entry->d_type}; }
 
        const char* name() const { return m_entry->d_name; }
 
        std::string_view view() const { return std::string_view{m_entry->d_name, nameLength()}; }
 
        auto isDotEntry() const {
                auto name = this->name();
                if (name[0] != '.')
                        return false;
                else if (name[1] == '\0')
                        return true;
                else if (name[1] != '.')
                        return false;
 
                return name[2] == '\0';
        }
 
protected: // data
 
        const struct dirent *m_entry;
};
 
} // end ns