ExFatFile.h

Go to the documentation of this file.

 
#ifndef ExFatFile_h
#define ExFatFile_h
#include "../common/FmtNumber.h"
#include "../common/FsApiConstants.h"
#include "../common/FsDateTime.h"
#include "../common/FsStructs.h"
#include "ExFatConfig.h"
#include "ExFatPartition.h"
#include "ExFatTypes.h"
#include <limits.h>
#include <string.h>
 
class ExFatVolume;
 
//------------------------------------------------------------------------------
#define isDirSeparator(c) ((c) == '/')
//------------------------------------------------------------------------------
inline bool lfnLegalChar(ExChar_t c)
{
    if (c == '/' || c == '\\' || c == '"' || c == '*' || c == ':' || c == '<' || c == '>' || c == '?' || c == '|')
    {
        return false;
    }
#if USE_EXFAT_UNICODE_NAMES
    return 0X1F < c;
#else  // USE_EXFAT_UNICODE_NAMES
    return 0X1F < c && c < 0X7F;
#endif // USE_EXFAT_UNICODE_NAMES
}
//------------------------------------------------------------------------------
struct ExName_t
{
    size_t len;
    const ExChar_t *lfn;
};
//------------------------------------------------------------------------------
struct ExFatPos_t
{
    uint64_t position;
    uint32_t cluster;
};
//------------------------------------------------------------------------------
class ExFatFile
{
  public:
    ExFatFile()
    {
    }
    ExFatFile(const char *path, oflag_t oflag)
    {
        open(path, oflag);
    }
 
#if DESTRUCTOR_CLOSES_FILE
    ~ExFatFile()
    {
        if (isOpen())
        {
            close();
        }
    }
#endif // DESTRUCTOR_CLOSES_FILE
 
    operator bool()
    {
        return isOpen();
    }
    int available()
    {
        uint64_t n = available64();
        return n > INT_MAX ? INT_MAX : n;
    }
    uint64_t available64()
    {
        return isFile() ? fileSize() - curPosition() : 0;
    }
    void clearError()
    {
        m_error = 0;
    }
    void clearWriteError()
    {
        m_error &= ~WRITE_ERROR;
    }
    bool close();
    bool contiguousRange(uint32_t *bgnSector, uint32_t *endSector);
    uint64_t curPosition() const
    {
        return m_curPosition;
    }
 
    uint64_t dataLength() const
    {
        return m_dataLength;
    }
    uint32_t dirIndex() const
    {
        return m_dirPos.position / 32;
    }
    bool exists(const ExChar_t *path)
    {
        ExFatFile file;
        return file.open(this, path, O_RDONLY);
    }
    void fgetpos(fspos_t *pos) const;
    int fgets(char *str, int num, char *delim = nullptr);
    uint64_t fileSize() const
    {
        return m_validLength;
    }
    uint32_t firstSector() const;
    void fsetpos(const fspos_t *pos);
    void flush()
    {
        sync();
    }
    bool getAccessDateTime(uint16_t *pdate, uint16_t *ptime);
    bool getCreateDateTime(uint16_t *pdate, uint16_t *ptime);
    uint8_t getError() const
    {
        return isOpen() ? m_error : 0XFF;
    }
    bool getModifyDateTime(uint16_t *pdate, uint16_t *ptime);
    size_t getName(ExChar_t *name, size_t size);
    bool getWriteError() const
    {
        return isOpen() ? m_error & WRITE_ERROR : true;
    }
    bool isBusy();
    bool isContiguous() const
    {
        return m_flags & FILE_FLAG_CONTIGUOUS;
    }
    bool isDir() const
    {
        return m_attributes & FILE_ATTR_DIR;
    }
    bool isFile() const
    {
        return m_attributes & FILE_ATTR_FILE;
    }
    bool isHidden() const
    {
        return m_attributes & FILE_ATTR_HIDDEN;
    }
    bool isOpen() const
    {
        return m_attributes;
    }
    bool isReadOnly() const
    {
        return m_attributes & FILE_ATTR_READ_ONLY;
    }
    bool isRoot() const
    {
        return m_attributes & FILE_ATTR_ROOT;
    }
    bool isReadable() const
    {
        return m_flags & FILE_FLAG_READ;
    }
    bool isSubDir() const
    {
        return m_attributes & FILE_ATTR_SUBDIR;
    }
    bool isWritable() const
    {
        return m_flags & FILE_FLAG_WRITE;
    }
    bool ls(print_t *pr);
    bool ls(print_t *pr, uint8_t flags, uint8_t indent = 0);
    bool mkdir(ExFatFile *parent, const ExChar_t *path, bool pFlag = true);
    bool open(ExFatFile *dirFile, const ExChar_t *path, oflag_t oflag);
    bool open(ExFatVolume *vol, const ExChar_t *path, int oflag);
    bool open(ExFatFile *dirFile, uint32_t index, oflag_t oflag);
    bool open(const ExChar_t *path, int oflag = O_RDONLY);
    bool openNext(ExFatFile *dirFile, oflag_t oflag = O_RDONLY);
    bool openRoot(ExFatVolume *vol);
    int peek();
    bool preAllocate(uint64_t length);
    size_t printAccessDateTime(print_t *pr);
    size_t printCreateDateTime(print_t *pr);
    size_t printField(double value, char term, uint8_t prec = 2)
    {
        char buf[24];
        char *str = buf + sizeof(buf);
        if (term)
        {
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
        }
        str = fmtDouble(str, value, prec, false);
        return write(str, buf + sizeof(buf) - str);
    }
    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)
    {
        char sign = 0;
        char buf[3 * sizeof(Type) + 3];
        char *str = buf + sizeof(buf);
 
        if (term)
        {
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
        }
        if (value < 0)
        {
            value = -value;
            sign = '-';
        }
        if (sizeof(Type) < 4)
        {
            str = fmtBase10(str, (uint16_t)value);
        }
        else
        {
            str = fmtBase10(str, (uint32_t)value);
        }
        if (sign)
        {
            *--str = sign;
        }
        return write(str, &buf[sizeof(buf)] - str);
    }
    size_t printFileSize(print_t *pr);
    size_t printModifyDateTime(print_t *pr);
    size_t printName(print_t *pr);
    int read()
    {
        uint8_t b;
        return read(&b, 1) == 1 ? b : -1;
    }
    int read(void *buf, size_t count);
    bool remove();
    bool remove(const ExChar_t *path);
    bool rename(const ExChar_t *newPath);
    bool rename(ExFatFile *dirFile, const ExChar_t *newPath);
    void rewind()
    {
        seekSet(0);
    }
    bool rmdir();
    bool seekCur(int64_t offset)
    {
        return seekSet(m_curPosition + offset);
    }
    bool seekEnd(int64_t offset = 0)
    {
        return isFile() ? seekSet(m_validLength + offset) : false;
    }
    bool seekSet(uint64_t pos);
    bool sync();
    bool timestamp(uint8_t flags, uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
                   uint8_t second);
    bool truncate();
    bool truncate(uint64_t length)
    {
        return seekSet(length) && truncate();
    }
 
    uint64_t validLength() const
    {
        return m_validLength;
    }
    size_t write(const char *str)
    {
        return write(str, strlen(str));
    }
    size_t write(uint8_t b)
    {
        return write(&b, 1);
    }
    size_t write(const void *buf, size_t count);
    //============================================================================
#if USE_EXFAT_UNICODE_NAMES
    // Not Implemented when Unicode is selected.
    bool exists(const char *path);
    size_t getName(char *name, size_t size);
    bool mkdir(ExFatFile *parent, const char *path, bool pFlag = true);
    bool open(ExFatVolume *vol, const char *path, int oflag);
    bool open(ExFatFile *dir, const char *path, int oflag);
    bool open(const char *path, int oflag = O_RDONLY);
    bool remove(const char *path);
    bool rename(const char *newPath);
    bool rename(ExFatFile *dirFile, const char *newPath);
#endif // USE_EXFAT_UNICODE_NAMES
 
  private:
    friend class ExFatVolume;
    bool addCluster();
    bool addDirCluster();
    uint8_t setCount() const
    {
        return m_setCount;
    }
    bool mkdir(ExFatFile *parent, ExName_t *fname);
    bool openRootFile(ExFatFile *dir, const ExChar_t *name, uint8_t nameLength, oflag_t oflag);
    bool open(ExFatFile *dirFile, ExName_t *fname, oflag_t oflag)
    {
        return openRootFile(dirFile, fname->lfn, fname->len, oflag);
    }
    bool parsePathName(const ExChar_t *path, ExName_t *fname, const ExChar_t **ptr);
    uint32_t curCluster() const
    {
        return m_curCluster;
    }
    ExFatVolume *volume() const
    {
        return m_vol;
    }
    bool syncDir();
    //----------------------------------------------------------------------------
    static const uint8_t WRITE_ERROR = 0X1;
    static const uint8_t READ_ERROR = 0X2;
 
    static const uint8_t FILE_ATTR_CLOSED = 0;
    static const uint8_t FILE_ATTR_READ_ONLY = EXFAT_ATTRIB_READ_ONLY;
    static const uint8_t FILE_ATTR_HIDDEN = EXFAT_ATTRIB_HIDDEN;
    static const uint8_t FILE_ATTR_SYSTEM = EXFAT_ATTRIB_SYSTEM;
    static const uint8_t FILE_ATTR_FILE = 0X08;
    static const uint8_t FILE_ATTR_SUBDIR = EXFAT_ATTRIB_DIRECTORY;
    static const uint8_t FILE_ATTR_ARCHIVE = EXFAT_ATTRIB_ARCHIVE;
    static const uint8_t FILE_ATTR_ROOT = 0X40;
    static const uint8_t FILE_ATTR_DIR = FILE_ATTR_SUBDIR | FILE_ATTR_ROOT;
    static const uint8_t FILE_ATTR_COPY = EXFAT_ATTRIB_READ_ONLY | EXFAT_ATTRIB_HIDDEN | EXFAT_ATTRIB_SYSTEM |
                                          EXFAT_ATTRIB_DIRECTORY | EXFAT_ATTRIB_ARCHIVE;
 
    static const uint8_t FILE_FLAG_READ = 0X01;
    static const uint8_t FILE_FLAG_WRITE = 0X02;
    static const uint8_t FILE_FLAG_APPEND = 0X08;
    static const uint8_t FILE_FLAG_CONTIGUOUS = 0X40;
    static const uint8_t FILE_FLAG_DIR_DIRTY = 0X80;
 
 
    uint64_t m_curPosition;
    uint64_t m_dataLength;
    uint64_t m_validLength;
    uint32_t m_curCluster;
    uint32_t m_firstCluster;
    ExFatVolume *m_vol;
    DirPos_t m_dirPos;
    uint8_t m_setCount;
    uint8_t m_attributes = FILE_ATTR_CLOSED;
    uint8_t m_error = 0;
    uint8_t m_flags = 0;
};
 
#include "../common/ArduinoFiles.h"
class ExFile : public StreamFile<ExFatFile, uint64_t>
{
  public:
    ExFile openNextFile(oflag_t oflag = O_RDONLY)
    {
        ExFile tmpFile;
        tmpFile.openNext(this, oflag);
        return tmpFile;
    }
};
#endif // ExFatFile_h