FsVolume.h

Go to the documentation of this file.

 
#ifndef FsVolume_h
#define FsVolume_h
#include "../ExFatLib/ExFatLib.h"
#include "../FatLib/FatLib.h"
#include "FsNew.h"
 
class FsFile;
class FsVolume
{
  public:
    FsVolume()
    {
    }
 
    ~FsVolume()
    {
        end();
    }
 
    bool begin(BlockDevice *blockDev);
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    // Use sectorsPerCluster(). blocksPerCluster() will be removed in the future.
    uint32_t blocksPerCluster() __attribute__((deprecated))
    {
        return sectorsPerCluster();
    }  // NOLINT
#endif // DOXYGEN_SHOULD_SKIP_THIS
    uint32_t bytesPerCluster() const
    {
        return m_fVol ? m_fVol->bytesPerCluster() : m_xVol ? m_xVol->bytesPerCluster() : 0;
    }
    bool chdir()
    {
        return m_fVol ? m_fVol->chdir() : m_xVol ? m_xVol->chdir() : false;
    }
    bool chdir(const char *path)
    {
        return m_fVol ? m_fVol->chdir(path) : m_xVol ? m_xVol->chdir(path) : false;
    }
    void chvol()
    {
        m_cwv = this;
    }
    uint32_t clusterCount() const
    {
        return m_fVol ? m_fVol->clusterCount() : m_xVol ? m_xVol->clusterCount() : 0;
    }
    uint32_t dataStartSector() const
    {
        return m_fVol ? m_fVol->dataStartSector() : m_xVol ? m_xVol->clusterHeapStartSector() : 0;
    }
    void end()
    {
        m_fVol = nullptr;
        m_xVol = nullptr;
    }
    bool exists(const char *path)
    {
        return m_fVol ? m_fVol->exists(path) : m_xVol ? m_xVol->exists(path) : false;
    }
    uint32_t fatStartSector() const
    {
        return m_fVol ? m_fVol->fatStartSector() : m_xVol ? m_xVol->fatStartSector() : 0;
    }
    uint8_t fatType() const
    {
        return m_fVol ? m_fVol->fatType() : m_xVol ? m_xVol->fatType() : 0;
    }
    uint32_t freeClusterCount() const
    {
        return m_fVol ? m_fVol->freeClusterCount() : m_xVol ? m_xVol->freeClusterCount() : 0;
    }
    bool isBusy()
    {
        return m_fVol ? m_fVol->isBusy() : m_xVol ? m_xVol->isBusy() : false;
    }
    bool ls(print_t *pr)
    {
        return m_fVol ? m_fVol->ls(pr) : m_xVol ? m_xVol->ls(pr) : false;
    }
    bool ls(print_t *pr, uint8_t flags)
    {
        return m_fVol ? m_fVol->ls(pr, flags) : m_xVol ? m_xVol->ls(pr, flags) : false;
    }
    bool ls(print_t *pr, const char *path, uint8_t flags);
    bool mkdir(const char *path, bool pFlag = true)
    {
        return m_fVol ? m_fVol->mkdir(path, pFlag) : m_xVol ? m_xVol->mkdir(path, pFlag) : false;
    }
    FsFile open(const char *path, oflag_t oflag = O_RDONLY);
    bool remove(const char *path)
    {
        return m_fVol ? m_fVol->remove(path) : m_xVol ? m_xVol->remove(path) : false;
    }
    bool rename(const char *oldPath, const char *newPath)
    {
        return m_fVol ? m_fVol->rename(oldPath, newPath) : m_xVol ? m_xVol->rename(oldPath, newPath) : false;
    }
    bool rmdir(const char *path)
    {
        return m_fVol ? m_fVol->rmdir(path) : m_xVol ? m_xVol->rmdir(path) : false;
    }
    uint32_t sectorsPerCluster() const
    {
        return m_fVol ? m_fVol->sectorsPerCluster() : m_xVol ? m_xVol->sectorsPerCluster() : 0;
    }
#if ENABLE_ARDUINO_SERIAL
    bool ls()
    {
        return ls(&Serial);
    }
    bool ls(uint8_t flags)
    {
        return ls(&Serial, flags);
    }
    bool ls(const char *path, uint8_t flags = 0)
    {
        return ls(&Serial, path, flags);
    }
#endif // ENABLE_ARDUINO_SERIAL
#if ENABLE_ARDUINO_STRING
    bool chdir(const String &path)
    {
        return chdir(path.c_str());
    }
    bool exists(const String &path)
    {
        return exists(path.c_str());
    }
    bool mkdir(const String &path, bool pFlag = true)
    {
        return mkdir(path.c_str(), pFlag);
    }
    FsFile open(const String &path, oflag_t oflag = O_RDONLY);
    bool remove(const String &path)
    {
        return remove(path.c_str());
    }
    bool rename(const String &oldPath, const String &newPath)
    {
        return rename(oldPath.c_str(), newPath.c_str());
    }
    bool rmdir(const String &path)
    {
        return rmdir(path.c_str());
    }
#endif // ENABLE_ARDUINO_STRING
 
  protected:
    newalign_t m_volMem[FS_ALIGN_DIM(ExFatVolume, FatVolume)];
 
  private:
    friend class FsBaseFile;
    static FsVolume *cwv()
    {
        return m_cwv;
    }
    FsVolume(const FsVolume &from);
    FsVolume &operator=(const FsVolume &from);
 
    static FsVolume *m_cwv;
    FatVolume *m_fVol = nullptr;
    ExFatVolume *m_xVol = nullptr;
    BlockDevice *m_blockDev;
};
#endif // FsVolume_h