File.h

Go to the documentation of this file.

#pragma once

#include "FsBase.h"

namespace IFS
{
#define GET_FS()                                                                                                       \
    auto fs = getFileSystem();                                                                                         \
    if(fs == nullptr) {                                                                                                \
        return lastError;                                                                                              \
    }

#define GET_FS_BOOL()                                                                                                  \
    auto fs = getFileSystem();                                                                                         \
    if(fs == nullptr) {                                                                                                \
        return false;                                                                                                  \
    }

class File : public FsBase
{
public:
    using FsBase::FsBase;

    // Common flag combinations
    static constexpr OpenFlags ReadOnly{OpenFlag::Read};
    static constexpr OpenFlags WriteOnly{OpenFlag::Write};
    static constexpr OpenFlags ReadWrite{OpenFlag::Read | OpenFlag::Write};
    static constexpr OpenFlags Create{OpenFlag::Create};
    static constexpr OpenFlags Append{OpenFlag::Append};
    static constexpr OpenFlags Truncate{OpenFlag::Truncate};
    static constexpr OpenFlags CreateNewAlways{OpenFlag::Create | OpenFlag::Truncate};

    ~File()
    {
        close();
    }

    explicit operator bool() const
    {
        return handle >= 0;
    }

    bool stat(Stat& stat)
    {
        GET_FS_BOOL();
        return check(fs->fstat(handle, &stat));
    }

    int control(ControlCode code, void* buffer, size_t bufSize)
    {
        GET_FS();
        int res = fs->fcontrol(handle, code, buffer, bufSize);
        check(res);
        return res;
    }

    bool open(const String& path, OpenFlags flags = OpenFlag::Read)
    {
        GET_FS_BOOL();
        fs->close(handle);
        handle = fs->open(path.c_str(), flags);
        return check(handle);
    }

    bool open(const Stat& stat, OpenFlags flags = OpenFlag::Read)
    {
        GET_FS_BOOL();
        fs->close(handle);
        handle = fs->fopen(stat, flags);
        return check(handle);
    }

    bool close()
    {
        if(handle < 0) {
            return true;
        }
        GET_FS_BOOL();
        int res = fs->close(handle);
        handle = -1;
        return check(res);
    }

    int read(void* data, size_t size)
    {
        GET_FS();
        int res = fs->read(handle, data, size);
        check(res);
        return res;
    }

    int write(const void* data, size_t size)
    {
        GET_FS();
        int res = fs->write(handle, data, size);
        check(res);
        return res;
    }

    bool write(const String& s)
    {
        size_t len = s.length();
        return write(s.c_str(), len) == int(len);
    }

    int seek(int offset, SeekOrigin origin)
    {
        GET_FS();
        int res = fs->lseek(handle, offset, origin);
        check(res);
        return res;
    }

    bool eof()
    {
        auto fs = getFileSystem();
        if(fs == nullptr) {
            return true;
        }
        int res = fs->eof(handle);
        check(res);
        return res != FS_OK;
    }

    int32_t tell()
    {
        GET_FS();
        int res = fs->tell(handle);
        check(res);
        return res;
    }

    bool truncate(size_t new_size)
    {
        GET_FS();
        int res = fs->ftruncate(handle, new_size);
        check(res);
        return res;
    }

    bool truncate()
    {
        GET_FS();
        int res = fs->ftruncate(handle);
        check(res);
        return res;
    }

    bool flush()
    {
        GET_FS_BOOL();
        return check(fs->flush(handle));
    }

    bool setacl(const ACL& acl)
    {
        GET_FS_BOOL();
        return check(fs->setacl(handle, acl));
    }

    bool settime(time_t mtime)
    {
        GET_FS_BOOL();
        return check(fs->settime(handle, mtime));
    }

    bool setcompression(const Compression& compression)
    {
        GET_FS_BOOL();
        return check(fs->setcompression(handle, compression));
    }

    bool remove()
    {
        GET_FS_BOOL();
        int res = fs->fremove(handle);
        if(!check(res)) {
            return false;
        }
        fs->close(handle);
        handle = -1;
        return true;
    }

    uint32_t getSize()
    {
        GET_FS();
        return fs->getSize(handle);
    }

    using ReadContentCallback = FileSystem::ReadContentCallback;

    int readContent(size_t size, ReadContentCallback callback)
    {
        GET_FS();
        return fs->readContent(handle, size, callback);
    }

    int readContent(ReadContentCallback callback)
    {
        GET_FS();
        return fs->readContent(handle, callback);
    }

    String getContent()
    {
        String s;
        auto len = getSize();
        if(!s.setLength(len)) {
            return nullptr;
        }

        if(read(s.begin(), len) != int(len)) {
            return nullptr;
        }

        return s;
    }

private:
    FileHandle handle{-1};
};

}; // namespace IFS