File.h

Go to the documentation of this file.

/****
 * File.h
 *
 * Copyright 2019 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the IFS Library
 *
 * This library is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, version 3 or later.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 ****/

#pragma once

#include "FsBase.h"

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

    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(false);
        return check(fs->fstat(handle, &stat));
    }

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

    template <typename T> bool open(const T& path, OpenFlags flags = OpenFlag::Read)
    {
        GET_FS(false);
        fs->close(handle);
        handle = fs->open(path, flags);
        return check(handle);
    }

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

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

    int write(const void* data, size_t size)
    {
        GET_FS(lastError);
        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);
    }

    file_offset_t seek(file_offset_t offset, SeekOrigin origin)
    {
        GET_FS(lastError);
        auto 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;
    }

    file_offset_t tell()
    {
        GET_FS(lastError);
        auto res = fs->tell(handle);
        check(res);
        return res;
    }

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

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

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

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

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

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

    template <typename... ParamTypes> bool setAttribute(AttributeTag tag, ParamTypes... params)
    {
        GET_FS(false);
        return check(fs->setAttribute(handle, tag, params...));
    }

    template <typename... ParamTypes> int getAttribute(AttributeTag tag, ParamTypes... params)
    {
        GET_FS(lastError);
        return check(fs->getAttribute(handle, tag, params...));
    }

    template <typename... ParamTypes> bool setUserAttribute(uint8_t tagValue, ParamTypes... params)
    {
        GET_FS(false);
        return check(fs->setAttribute(handle, getUserAttributeTag(tagValue), params...));
    }

    template <typename... ParamTypes> int getUserAttribute(uint8_t tagValue, ParamTypes... params)
    {
        GET_FS(lastError);
        return check(fs->getUserAttribute(handle, tagValue, params...));
    }

    String getUserAttribute(uint8_t tagValue)
    {
        GET_FS(nullptr);
        return fs->getUserAttribute(handle, tagValue);
    }

    bool removeUserAttribute(uint8_t tagValue)
    {
        GET_FS(false);
        return check(fs->removeUserAttribute(handle, tagValue));
    }

    int enumAttributes(AttributeEnumCallback callback, void* buffer, size_t bufsize)
    {
        GET_FS(lastError);
        int res = fs->fenumxattr(handle, callback, buffer, bufsize);
        check(res);
        return res;
    }

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

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

    using ReadContentCallback = FileSystem::ReadContentCallback;

    file_offset_t readContent(size_t size, ReadContentCallback callback)
    {
        GET_FS(lastError);
        auto res = fs->readContent(handle, size, callback);
        check(res);
        return res;
    }

    file_offset_t readContent(ReadContentCallback callback)
    {
        GET_FS(lastError);
        auto res = fs->readContent(handle, callback);
        check(res);
        return res;
    }

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

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

        return s;
    }

    FileHandle release()
    {
        auto res = handle;
        handle = -1;
        return res;
    }

    int getExtents(Storage::Partition* part, Extent* list, uint16_t extcount)
    {
        GET_FS(lastError);
        int res = fs->fgetextents(handle, part, list, extcount);
        check(res);
        return res;
    }

private:
    FileHandle handle{-1};
};

}; // namespace IFS