IFileSystem.h

Go to the documentation of this file.

#pragma once

#include "Stat.h"
#include "OpenFlags.h"
#include <Storage/Partition.h>
#include "Error.h"
#include "Control.h"
#include <Data/Stream/SeekOrigin.h>

#define FILESYSTEM_TYPE_MAP(XX)                                                                                        \
    XX(Unknown, NULL, "Unknown")                                                                                       \
    XX(FWFS, FWFS, "Firmware File System")                                                                             \
    XX(SPIFFS, SPIF, "SPI Flash File System (SPIFFS)")                                                                 \
    XX(Hybrid, HYFS, "Hybrid File System")                                                                             \
    XX(Host, HOST, "Host File System")

#define FILE_SYSTEM_ATTR_MAP(XX)                                                                                       \
    XX(Mounted, "Filing system is mounted and in use")                                                                 \
    XX(ReadOnly, "Writing not permitted to this volume")                                                               \
    XX(Virtual, "Virtual filesystem, doesn't host files directly")                                                     \
    XX(Check, "Volume check recommended")                                                                              \
    XX(NoMeta, "Metadata unsupported")

namespace IFS
{
class IFileSystem;

/*
 * Opaque structure for directory reading
 */
using DirHandle = struct FileDir*;

time_t fsGetTimeUTC();

#if DEBUG_BUILD
#define debug_ifserr(err, func, ...)                                                                                   \
    do {                                                                                                               \
        int errorCode = err;                                                                                           \
        (void)errorCode;                                                                                               \
        debug_e(func ": %s (%d)", ##__VA_ARGS__, getErrorString(errorCode).c_str(), err);                              \
    } while(0)
#else
#define debug_ifserr(err, func, ...)                                                                                   \
    do {                                                                                                               \
    } while(0)
#endif

class IFileSystem
{
public:
    enum class Type {
#define XX(_name, _tag, _desc) _name,
        FILESYSTEM_TYPE_MAP(XX)
#undef XX
            MAX
    };

    enum class Attribute {
#define XX(_tag, _comment) _tag,
        FILE_SYSTEM_ATTR_MAP(XX)
#undef XX
            MAX
    };

    // The set of attributes
    using Attributes = BitSet<uint8_t, Attribute, size_t(Attribute::MAX)>;

    struct Info {
        Type type{};          
        Attributes attr{};  
        size_t maxNameLength; 
        size_t maxPathLength; 
        Storage::Partition partition;
        uint32_t volumeID{0};   
        NameBuffer name;        
        uint32_t volumeSize{0}; 
        uint32_t freeSpace{0};  

        Info()
        {
        }

        Info(char* namebuf, unsigned buflen) : name(namebuf, buflen)
        {
        }

        Info& operator=(const Info& rhs)
        {
            type = rhs.type;
            partition = rhs.partition;
            attr = rhs.attr;
            volumeID = rhs.volumeID;
            name.copy(rhs.name);
            volumeSize = rhs.volumeSize;
            freeSpace = rhs.freeSpace;
            return *this;
        }

        void clear()
        {
            *this = Info{};
        }
    };

    virtual ~IFileSystem()
    {
    }

    virtual int mount() = 0;

    virtual int getinfo(Info& info) = 0;

    virtual String getErrorString(int err)
    {
        return Error::toString(err);
    }

    virtual int opendir(const char* path, DirHandle& dir) = 0;

    virtual int fopendir(const Stat* stat, DirHandle& dir)
    {
        return opendir(stat == nullptr ? nullptr : stat->name.buffer, dir);
    }

    virtual int readdir(DirHandle dir, Stat& stat) = 0;

    virtual int rewinddir(DirHandle dir) = 0;

    virtual int closedir(DirHandle dir) = 0;

    virtual int mkdir(const char* path) = 0;

    virtual int stat(const char* path, Stat* stat) = 0;

    virtual int fstat(FileHandle file, Stat* stat) = 0;

    virtual int fcontrol(FileHandle file, ControlCode code, void* buffer, size_t bufSize)
    {
        return Error::NotSupported;
    }

    virtual FileHandle open(const char* path, OpenFlags flags) = 0;

    virtual FileHandle fopen(const Stat& stat, OpenFlags flags) = 0;

    virtual int close(FileHandle file) = 0;

    virtual int read(FileHandle file, void* data, size_t size) = 0;

    virtual int write(FileHandle file, const void* data, size_t size) = 0;

    virtual int lseek(FileHandle file, int offset, SeekOrigin origin) = 0;

    virtual int eof(FileHandle file) = 0;

    virtual int32_t tell(FileHandle file) = 0;

    virtual int ftruncate(FileHandle file, size_t new_size) = 0;

    virtual int flush(FileHandle file) = 0;

    virtual int setacl(FileHandle file, const ACL& acl) = 0;

    virtual int setattr(const char* path, FileAttributes attr) = 0;

    virtual int settime(FileHandle file, time_t mtime) = 0;

    virtual int setcompression(FileHandle file, const Compression& compression) = 0;

    virtual int rename(const char* oldpath, const char* newpath) = 0;

    virtual int remove(const char* path) = 0;

    virtual int fremove(FileHandle file) = 0;

    virtual int format() = 0;

    virtual int check()
    {
        return Error::NotImplemented;
    }
};

} // namespace IFS

String toString(IFS::IFileSystem::Type type);

String toString(IFS::IFileSystem::Attribute attr);