Core/FileSystem.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * FileSystem.h
 *
 ****/

#pragma once

#include <IFS/Helpers.h>
#include <IFS/File.h>
#include <IFS/Directory.h>
#include <spiffs_sming.h>
#include "WVector.h" 

using file_t = IFS::FileHandle;
typedef SeekOrigin SeekOriginFlags; 
using FileHandle = IFS::FileHandle;
using DirHandle = IFS::DirHandle;
using FileOpenFlag = IFS::OpenFlag;
using FileOpenFlags = IFS::OpenFlags;
using FileAttribute = IFS::FileAttribute;
using FileAttributes = IFS::FileAttributes;
using FileStat = IFS::Stat;
using FileNameStat = IFS::NameStat;
constexpr int FS_OK = IFS::FS_OK;

constexpr SeekOrigin eSO_FileStart{SeekOrigin::Start};  
constexpr SeekOrigin eSO_CurrentPos{SeekOrigin::Current}; 
constexpr SeekOrigin eSO_FileEnd{SeekOrigin::End};        

namespace SmingInternal
{
extern IFS::IFileSystem* activeFileSystem;

} // namespace SmingInternal

class File : public IFS::File
{
public:
    File() : IFS::File(SmingInternal::activeFileSystem)
    {
    }
};

class Directory : public IFS::Directory
{
public:
    Directory() : IFS::Directory(SmingInternal::activeFileSystem)
    {
    }
};

// Various file flag combinations
constexpr FileOpenFlags eFO_ReadOnly{File::ReadOnly};               
constexpr FileOpenFlags eFO_WriteOnly{File::WriteOnly};             
constexpr FileOpenFlags eFO_ReadWrite{File::ReadWrite};             
constexpr FileOpenFlags eFO_CreateIfNotExist{File::Create};         
constexpr FileOpenFlags eFO_Append{File::Append};                   
constexpr FileOpenFlags eFO_Truncate{File::Truncate};               
constexpr FileOpenFlags eFO_CreateNewAlways{File::CreateNewAlways}; 

/*
 * Boilerplate check for file function wrappers to catch undefined filesystem.
 */
#define CHECK_FS(_method)                                                                                              \
    auto fileSystem = static_cast<IFS::FileSystem*>(SmingInternal::activeFileSystem);                                  \
    if(fileSystem == nullptr) {                                                                                        \
        debug_e("ERROR in %s(): No active file system", __FUNCTION__);                                                 \
        return file_t(IFS::Error::NoFileSystem);                                                                       \
    }

inline IFS::FileSystem* getFileSystem()
{
    if(SmingInternal::activeFileSystem == nullptr) {
        debug_e("ERROR: No active file system");
    }
    return static_cast<IFS::FileSystem*>(SmingInternal::activeFileSystem);
}

void fileSetFileSystem(IFS::IFileSystem* fileSystem);

inline void fileFreeFileSystem()
{
    fileSetFileSystem(nullptr);
}

bool spiffs_mount();

bool spiffs_mount(Storage::Partition partition);

bool fwfs_mount();

bool fwfs_mount(Storage::Partition partition);

bool hyfs_mount();

bool hyfs_mount(Storage::Partition fwfsPartition, Storage::Partition spiffsPartition);

inline file_t fileOpen(const char* name, FileOpenFlags flags = File::ReadOnly)
{
    CHECK_FS(open)
    return fileSystem->open(name, flags);
}

inline file_t fileOpen(const String& name, FileOpenFlags flags = File::ReadOnly)
{
    return fileOpen(name.c_str(), flags);
}

inline file_t fileOpen(const FileStat& stat, FileOpenFlags flags = File::ReadOnly)
{
    CHECK_FS(fopen)
    return fileSystem->fopen(stat, flags);
}

inline int fileClose(file_t file)
{
    CHECK_FS(close)
    return fileSystem->close(file);
}

inline int fileWrite(file_t file, const void* data, size_t size)
{
    CHECK_FS(write);
    return fileSystem->write(file, data, size);
}

inline int fileTouch(file_t file)
{
    return fileWrite(file, nullptr, 0);
}

inline int fileRead(file_t file, void* data, size_t size)
{
    CHECK_FS(read)
    return fileSystem->read(file, data, size);
}

inline int fileSeek(file_t file, int offset, SeekOrigin origin)
{
    CHECK_FS(seek)
    return fileSystem->lseek(file, offset, origin);
}

inline bool fileIsEOF(file_t file)
{
    auto fileSystem = getFileSystem();
    return fileSystem ? (fileSystem->eof(file) != 0) : true;
}

inline int fileTell(file_t file)
{
    CHECK_FS(tell)
    return fileSystem->tell(file);
}

inline int fileFlush(file_t file)
{
    CHECK_FS(flush)
    return fileSystem->flush(file);
}

inline String fileGetErrorString(int err)
{
    auto fileSystem = getFileSystem();
    if(fileSystem == nullptr) {
        return IFS::Error::toString(err);
    }
    return fileSystem->getErrorString(err);
}

template <typename TFileName> inline int fileSetContent(const TFileName& fileName, const char* content, size_t length)
{
    CHECK_FS(setContent)
    return fileSystem->setContent(fileName, content, length);
}

template <typename TFileName, typename TContent> inline int fileSetContent(const TFileName& fileName, TContent content)
{
    CHECK_FS(setContent)
    return fileSystem->setContent(fileName, content);
}

template <typename TFileName> inline uint32_t fileGetSize(const TFileName& fileName)
{
    auto fileSystem = getFileSystem();
    return fileSystem ? fileSystem->getSize(fileName) : 0;
}

inline int fileTruncate(file_t file, size_t newSize)
{
    CHECK_FS(truncate);
    return fileSystem->ftruncate(file, newSize);
}

inline int fileTruncate(file_t file)
{
    CHECK_FS(truncate);
    return fileSystem->ftruncate(file);
}

template <typename TFileName> int fileTruncate(const TFileName& fileName, size_t newSize)
{
    CHECK_FS(truncate);
    return fileSystem->truncate(fileName, newSize);
}

inline int fileRename(const char* oldName, const char* newName)
{
    CHECK_FS(rename)
    return fileSystem->rename(oldName, newName);
}

inline int fileRename(const String& oldName, const String& newName)
{
    return fileRename(oldName.c_str(), newName.c_str());
}

Vector<String> fileList() SMING_DEPRECATED;

template <typename TFileName> String fileGetContent(const TFileName& fileName)
{
    auto fileSystem = getFileSystem();
    return fileSystem ? fileSystem->getContent(fileName) : nullptr;
}

template <typename TFileName> inline size_t fileGetContent(const TFileName& fileName, char* buffer, size_t bufSize)
{
    auto fileSystem = getFileSystem();
    return fileSystem ? fileSystem->getContent(fileName, buffer, bufSize) : 0;
}

template <typename TFileName> inline size_t fileGetContent(const TFileName& fileName, char* buffer)
{
    auto fileSystem = getFileSystem();
    return fileSystem ? fileSystem->getContent(fileName, buffer) : 0;
}

inline int fileStats(const char* fileName, FileStat& stat)
{
    CHECK_FS(stat)
    return fileSystem->stat(fileName, &stat);
}

inline int fileStats(const String& fileName, FileStat& stat)
{
    return fileStats(fileName.c_str(), stat);
}

inline int fileStats(file_t file, FileStat& stat)
{
    CHECK_FS(fstat)
    return fileSystem->fstat(file, &stat);
}

inline int fileDelete(const char* fileName)
{
    CHECK_FS(remove)
    return fileSystem->remove(fileName);
}

inline int fileDelete(const String& fileName)
{
    return fileDelete(fileName.c_str());
}

inline int fileDelete(file_t file)
{
    CHECK_FS(fremove)
    return fileSystem->fremove(file);
}

inline bool fileExist(const char* fileName)
{
    CHECK_FS(stat)
    return fileSystem->stat(fileName, nullptr) >= 0;
}

inline bool fileExist(const String& fileName)
{
    return fileExist(fileName.c_str());
}

inline int fileOpenDir(const char* dirName, DirHandle& dir)
{
    CHECK_FS(opendir)
    return fileSystem->opendir(dirName, dir);
}

inline int fileOpenDir(const String& dirName, DirHandle& dir)
{
    return fileOpenDir(dirName.c_str(), dir);
}

inline int fileOpenRootDir(DirHandle& dir)
{
    return fileOpenDir(nullptr, dir);
}

inline int fileOpenDir(const FileStat& stat, DirHandle& dir)
{
    CHECK_FS(opendir)
    return fileSystem->fopendir(&stat, dir);
}

inline int fileCloseDir(DirHandle dir)
{
    CHECK_FS(closedir)
    return fileSystem->closedir(dir);
}

inline int fileReadDir(DirHandle dir, FileStat& stat)
{
    CHECK_FS(readdir)
    return fileSystem->readdir(dir, stat);
}

inline int fileRewindDir(DirHandle dir)
{
    CHECK_FS(rewinddir)
    return fileSystem->rewinddir(dir);
}

inline int fileGetSystemInfo(IFS::IFileSystem::Info& info)
{
    CHECK_FS(getinfo)
    return fileSystem->getinfo(info);
}

IFS::IFileSystem::Type fileSystemType();

inline int fileSystemFormat()
{
    CHECK_FS(format)
    return fileSystem->format();
}

inline int fileSystemCheck()
{
    CHECK_FS(check)
    return fileSystem->check();
}

inline int fileSetACL(file_t file, const IFS::ACL& acl)
{
    CHECK_FS(setacl)
    return fileSystem->setacl(file, acl);
}

inline int fileSetAttr(const char* filename, FileAttributes attr)
{
    CHECK_FS(setattr)
    return fileSystem->setattr(filename, attr);
}

inline int fileSetAttr(const String& filename, FileAttributes attr)
{
    return fileSetAttr(filename.c_str(), attr);
}
inline int fileSetTime(file_t file, time_t mtime)
{
    CHECK_FS(settime)
    return fileSystem->settime(file, mtime);
}