ExFatVolume.h

Go to the documentation of this file.

 
#ifndef ExFatVolume_h
#define ExFatVolume_h
#include "ExFatFile.h"
#include "ExFatPartition.h"
//==============================================================================
class ExFatVolume : public ExFatPartition
{
  public:
    ExFatVolume()
    {
    }
    bool begin(BlockDevice *dev, bool setCwv = true, uint8_t part = 1)
    {
        if (!init(dev, part))
        {
            return false;
        }
        if (!chdir())
        {
            return false;
        }
        if (setCwv || !m_cwv)
        {
            m_cwv = this;
        }
        return true;
    }
    bool chdir()
    {
        m_vwd.close();
        return m_vwd.openRoot(this);
    }
    bool chdir(const ExChar_t *path);
 
    void chvol()
    {
        m_cwv = this;
    }
 
    bool exists(const ExChar_t *path)
    {
        ExFatFile tmp;
        return tmp.open(this, path, O_RDONLY);
    }
 
    //----------------------------------------------------------------------------
    bool ls(print_t *pr, uint8_t flags = 0)
    {
        return m_vwd.ls(pr, flags);
    }
    bool ls(print_t *pr, const ExChar_t *path, uint8_t flags)
    {
        ExFatFile dir;
        return dir.open(this, path, O_RDONLY) && dir.ls(pr, flags);
    }
    bool mkdir(const ExChar_t *path, bool pFlag = true)
    {
        ExFatFile sub;
        return sub.mkdir(vwd(), path, pFlag);
    }
    ExFile open(const ExChar_t *path, oflag_t oflag = O_RDONLY)
    {
        ExFile tmpFile;
        tmpFile.open(this, path, oflag);
        return tmpFile;
    }
    bool remove(const ExChar_t *path)
    {
        ExFatFile tmp;
        return tmp.open(this, path, O_WRONLY) && tmp.remove();
    }
    bool rename(const ExChar_t *oldPath, const ExChar_t *newPath)
    {
        ExFatFile file;
        return file.open(vwd(), oldPath, O_RDONLY) && file.rename(vwd(), newPath);
    }
    bool rmdir(const ExChar_t *path)
    {
        ExFatFile sub;
        return sub.open(this, path, O_RDONLY) && sub.rmdir();
    }
    bool truncate(const ExChar_t *path, uint64_t length)
    {
        ExFatFile file;
        if (!file.open(this, path, O_WRONLY))
        {
            return false;
        }
        return file.truncate(length);
    }
#if ENABLE_ARDUINO_SERIAL
    bool ls()
    {
        return ls(&Serial);
    }
    bool ls(uint8_t flags)
    {
        return ls(&Serial, flags);
    }
    bool ls(const ExChar_t *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);
    }
    ExFile open(const String &path, oflag_t oflag = O_RDONLY)
    {
        return open(path.c_str(), oflag);
    }
    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());
    }
    bool truncate(const String &path, uint64_t length)
    {
        return truncate(path.c_str(), length);
    }
#endif // ENABLE_ARDUINO_STRING
       //============================================================================
#if USE_EXFAT_UNICODE_NAMES
    // Not implemented when Unicode is selected.
    bool exists(const char *path);
    bool mkdir(const char *path, bool pFlag = true);
    bool remove(const char *path);
    bool rename(const char *oldPath, const char *newPath);
    bool rmdir(const char *path);
#endif //  USE_EXFAT_UNICODE_NAMES
 
  private:
    friend ExFatFile;
    static ExFatVolume *cwv()
    {
        return m_cwv;
    }
    ExFatFile *vwd()
    {
        return &m_vwd;
    }
    static ExFatVolume *m_cwv;
    ExFatFile m_vwd;
};
#endif // ExFatVolume_h