FsFile.h

Go to the documentation of this file.

#ifndef FsFile_h
#define FsFile_h
#include "ExFatLib/ExFatLib.h"
#include "FatLib/FatLib.h"
#include "FsNew.h"
class FsBaseFile
{
  public:
    FsBaseFile()
    {
    }

    FsBaseFile(const char *path, oflag_t oflag)
    {
        open(path, oflag);
    }
 
    ~FsBaseFile()
    {
        close();
    }

    FsBaseFile(const FsBaseFile &from);
    FsBaseFile &operator=(const FsBaseFile &from);
    operator bool() const
    {
        return isOpen();
    }

    int available() const
    {
        return m_fFile ? m_fFile->available() : m_xFile ? m_xFile->available() : 0;
    }

    uint64_t available64() const
    {
        return m_fFile ? m_fFile->available32() : m_xFile ? m_xFile->available64() : 0;
    }

    void clearWriteError()
    {
        if (m_fFile)
            m_fFile->clearWriteError();
        if (m_xFile)
            m_xFile->clearWriteError();
    }

    bool close();
    bool contiguousRange(uint32_t *bgnSector, uint32_t *endSector)
    {
        return m_fFile   ? m_fFile->contiguousRange(bgnSector, endSector)
               : m_xFile ? m_xFile->contiguousRange(bgnSector, endSector)
                         : false;
    }

    uint64_t curPosition() const
    {
        return m_fFile ? m_fFile->curPosition() : m_xFile ? m_xFile->curPosition() : 0;
    }

    uint32_t dirIndex() const
    {
        return m_fFile ? m_fFile->dirIndex() : m_xFile ? m_xFile->dirIndex() : 0;
    }

    bool exists(const char *path)
    {
        return m_fFile ? m_fFile->exists(path) : m_xFile ? m_xFile->exists(path) : false;
    }

    void fgetpos(fspos_t *pos) const
    {
        if (m_fFile)
            m_fFile->fgetpos(pos);
        if (m_xFile)
            m_xFile->fgetpos(pos);
    }

    int fgets(char *str, int num, char *delim = nullptr)
    {
        return m_fFile ? m_fFile->fgets(str, num, delim) : m_xFile ? m_xFile->fgets(str, num, delim) : -1;
    }

    uint64_t fileSize() const
    {
        return m_fFile ? m_fFile->fileSize() : m_xFile ? m_xFile->fileSize() : 0;
    }

    uint32_t firstSector() const
    {
        return m_fFile ? m_fFile->firstSector() : m_xFile ? m_xFile->firstSector() : 0;
    }

    void flush()
    {
        sync();
    }

    void fsetpos(const fspos_t *pos)
    {
        if (m_fFile)
            m_fFile->fsetpos(pos);
        if (m_xFile)
            m_xFile->fsetpos(pos);
    }

    bool getAccessDateTime(uint16_t *pdate, uint16_t *ptime)
    {
        return m_fFile   ? m_fFile->getAccessDateTime(pdate, ptime)
               : m_xFile ? m_xFile->getAccessDateTime(pdate, ptime)
                         : false;
    }

    bool getCreateDateTime(uint16_t *pdate, uint16_t *ptime)
    {
        return m_fFile   ? m_fFile->getCreateDateTime(pdate, ptime)
               : m_xFile ? m_xFile->getCreateDateTime(pdate, ptime)
                         : false;
    }

    uint8_t getError() const
    {
        return m_fFile ? m_fFile->getError() : m_xFile ? m_xFile->getError() : 0XFF;
    }

    bool getModifyDateTime(uint16_t *pdate, uint16_t *ptime)
    {
        return m_fFile   ? m_fFile->getModifyDateTime(pdate, ptime)
               : m_xFile ? m_xFile->getModifyDateTime(pdate, ptime)
                         : false;
    }

    size_t getName(char *name, size_t len)
    {
        *name = 0;
        return m_fFile ? m_fFile->getName(name, len) : m_xFile ? m_xFile->getName(name, len) : 0;
    }

    bool getWriteError() const
    {
        return m_fFile ? m_fFile->getWriteError() : m_xFile ? m_xFile->getWriteError() : true;
    }

    bool isBusy()
    {
        return m_fFile ? m_fFile->isBusy() : m_xFile ? m_xFile->isBusy() : true;
    }

    bool isContiguous() const
    {
#if USE_FAT_FILE_FLAG_CONTIGUOUS
        return m_fFile ? m_fFile->isContiguous() : m_xFile ? m_xFile->isContiguous() : false;
#else  // USE_FAT_FILE_FLAG_CONTIGUOUS
        return m_xFile ? m_xFile->isContiguous() : false;
#endif // USE_FAT_FILE_FLAG_CONTIGUOUS
    }

    bool isDir() const
    {
        return m_fFile ? m_fFile->isDir() : m_xFile ? m_xFile->isDir() : false;
    }

    bool isDirectory() const
    {
        return isDir();
    }

    bool isFile() const
    {
        return m_fFile ? m_fFile->isFile() : m_xFile ? m_xFile->isFile() : false;
    }

    bool isHidden() const
    {
        return m_fFile ? m_fFile->isHidden() : m_xFile ? m_xFile->isHidden() : false;
    }

    bool isOpen() const
    {
        return m_fFile || m_xFile;
    }

    bool isReadable() const
    {
        return m_fFile ? m_fFile->isReadable() : m_xFile ? m_xFile->isReadable() : false;
    }

    bool isReadOnly() const
    {
        return m_fFile ? m_fFile->isReadOnly() : m_xFile ? m_xFile->isReadOnly() : false;
    }

    bool isSubDir() const
    {
        return m_fFile ? m_fFile->isSubDir() : m_xFile ? m_xFile->isSubDir() : false;
    }

    bool isWritable() const
    {
        return m_fFile ? m_fFile->isWritable() : m_xFile ? m_xFile->isWritable() : false;
    }
#if ENABLE_ARDUINO_SERIAL
    bool ls(uint8_t flags)
    {
        return ls(&Serial, flags);
    }

    bool ls()
    {
        return ls(&Serial);
    }
#endif // ENABLE_ARDUINO_SERIAL
    bool ls(print_t *pr)
    {
        return m_fFile ? m_fFile->ls(pr) : m_xFile ? m_xFile->ls(pr) : false;
    }

    bool ls(print_t *pr, uint8_t flags)
    {
        return m_fFile ? m_fFile->ls(pr, flags) : m_xFile ? m_xFile->ls(pr, flags) : false;
    }

    bool mkdir(FsBaseFile *dir, const char *path, bool pFlag = true);
    const char *name() const
    {
        return "use getName()";
    }

    bool open(FsBaseFile *dir, const char *path, oflag_t oflag = O_RDONLY);
    bool open(FsBaseFile *dir, uint32_t index, oflag_t oflag);
    bool open(FsVolume *vol, const char *path, oflag_t oflag);
    bool open(const char *path, oflag_t oflag = O_RDONLY)
    {
        return FsVolume::m_cwv && open(FsVolume::m_cwv, path, oflag);
    }

    bool openNext(FsBaseFile *dir, oflag_t oflag = O_RDONLY);
    bool openRoot(FsVolume *vol);
    uint64_t position() const
    {
        return curPosition();
    }

    int peek()
    {
        return m_fFile ? m_fFile->peek() : m_xFile ? m_xFile->peek() : -1;
    }

    bool preAllocate(uint64_t length)
    {
        return m_fFile   ? length < (1ULL << 32) && m_fFile->preAllocate(length)
               : m_xFile ? m_xFile->preAllocate(length)
                         : false;
    }

    size_t printAccessDateTime(print_t *pr)
    {
        return m_fFile ? m_fFile->printAccessDateTime(pr) : m_xFile ? m_xFile->printAccessDateTime(pr) : 0;
    }

    size_t printCreateDateTime(print_t *pr)
    {
        return m_fFile ? m_fFile->printCreateDateTime(pr) : m_xFile ? m_xFile->printCreateDateTime(pr) : 0;
    }

    size_t printField(double value, char term, uint8_t prec = 2)
    {
        return m_fFile ? m_fFile->printField(value, term, prec) : m_xFile ? m_xFile->printField(value, term, prec) : 0;
    }

    size_t printField(float value, char term, uint8_t prec = 2)
    {
        return printField(static_cast<double>(value), term, prec);
    }

    template <typename Type> size_t printField(Type value, char term)
    {
        return m_fFile ? m_fFile->printField(value, term) : m_xFile ? m_xFile->printField(value, term) : 0;
    }

    size_t printFileSize(print_t *pr)
    {
        return m_fFile ? m_fFile->printFileSize(pr) : m_xFile ? m_xFile->printFileSize(pr) : 0;
    }

    size_t printModifyDateTime(print_t *pr)
    {
        return m_fFile ? m_fFile->printModifyDateTime(pr) : m_xFile ? m_xFile->printModifyDateTime(pr) : 0;
    }

    size_t printName(print_t *pr)
    {
        return m_fFile ? m_fFile->printName(pr) : m_xFile ? m_xFile->printName(pr) : 0;
    }

    int read()
    {
        uint8_t b;
        return read(&b, 1) == 1 ? b : -1;
    }

    int read(void *buf, size_t count)
    {
        return m_fFile ? m_fFile->read(buf, count) : m_xFile ? m_xFile->read(buf, count) : -1;
    }

    bool remove();
    bool remove(const char *path)
    {
        return m_fFile ? m_fFile->remove(path) : m_xFile ? m_xFile->remove(path) : false;
    }

    bool rename(const char *newPath)
    {
        return m_fFile ? m_fFile->rename(newPath) : m_xFile ? m_xFile->rename(newPath) : false;
    }

    bool rename(FsBaseFile *dirFile, const char *newPath)
    {
        return m_fFile   ? m_fFile->rename(dirFile->m_fFile, newPath)
               : m_xFile ? m_xFile->rename(dirFile->m_xFile, newPath)
                         : false;
    }

    void rewind()
    {
        if (m_fFile)
            m_fFile->rewind();
        if (m_xFile)
            m_xFile->rewind();
    }

    void rewindDirectory()
    {
        if (isDir())
            rewind();
    }

    bool rmdir();
    bool seek(uint64_t pos)
    {
        return seekSet(pos);
    }

    bool seekCur(int64_t offset)
    {
        return seekSet(curPosition() + offset);
    }

    bool seekEnd(int64_t offset = 0)
    {
        return seekSet(fileSize() + offset);
    }

    bool seekSet(uint64_t pos)
    {
        return m_fFile ? pos < (1ULL << 32) && m_fFile->seekSet(pos) : m_xFile ? m_xFile->seekSet(pos) : false;
    }

    uint64_t size() const
    {
        return fileSize();
    }

    bool sync()
    {
        return m_fFile ? m_fFile->sync() : m_xFile ? m_xFile->sync() : false;
    }

    bool timestamp(uint8_t flags, uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
                   uint8_t second)
    {
        return m_fFile   ? m_fFile->timestamp(flags, year, month, day, hour, minute, second)
               : m_xFile ? m_xFile->timestamp(flags, year, month, day, hour, minute, second)
                         : false;
    }

    bool truncate()
    {
        return m_fFile ? m_fFile->truncate() : m_xFile ? m_xFile->truncate() : false;
    }

    bool truncate(uint64_t length)
    {
        return m_fFile   ? length < (1ULL << 32) && m_fFile->truncate(length)
               : m_xFile ? m_xFile->truncate(length)
                         : false;
    }

    size_t write(uint8_t b)
    {
        return write(&b, 1);
    }

    size_t write(const void *buf, size_t count)
    {
        return m_fFile ? m_fFile->write(buf, count) : m_xFile ? m_xFile->write(buf, count) : 0;
    }
 
  private:
    newalign_t m_fileMem[FS_ALIGN_DIM(ExFatFile, FatFile)];
    FatFile *m_fFile = nullptr;
    ExFatFile *m_xFile = nullptr;
};

class FsFile : public StreamFile<FsBaseFile, uint64_t>
{
  public:
    FsFile openNextFile(oflag_t oflag = O_RDONLY)
    {
        FsFile tmpFile;
        tmpFile.openNext(this, oflag);
        return tmpFile;
    }
};
#endif // FsFile_h