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.h>

using file_t = IFS::FileHandle;
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;
using File = IFS::File;
using Directory = IFS::Directory;
constexpr int FS_OK = IFS::FS_OK;

namespace SmingInternal
{
extern IFS::FileSystem* activeFileSystem;

} // namespace SmingInternal

/*
 * 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 FileHandle(IFS::Error::NoFileSystem);                                                                   \
    }

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

void fileSetFileSystem(IFS::IFileSystem* fileSystem);

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

bool fileMountFileSystem(IFS::IFileSystem* fs);

bool fwfs_mount();

bool fwfs_mount(Storage::Partition partition);

inline IFS::FileSystem* fileMountArchive(const String& filename)
{
    auto fs = getFileSystem();
    return fs ? IFS::mountArchive(*fs, filename) : nullptr;
}

template <typename T> inline FileHandle fileOpen(const T& path, FileOpenFlags flags = File::ReadOnly)
{
    CHECK_FS(open)
    return fileSystem->open(path, flags);
}

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

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

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

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

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

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

inline file_offset_t fileTell(FileHandle file)
{
    CHECK_FS(tell)
    return fileSystem->tell(file);
}

inline int fileFlush(FileHandle 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 file_size_t fileGetSize(const TFileName& fileName)
{
    auto fileSystem = getFileSystem();
    return fileSystem ? fileSystem->getSize(fileName) : 0;
}

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

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

template <typename TFileName> int fileTruncate(const TFileName& fileName, file_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());
}

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(FileHandle 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(FileHandle file)
{
    CHECK_FS(fremove)
    return fileSystem->fremove(file);
}

inline bool fileExist(const char* fileName)
{
    CHECK_FS(stat)
    FileStat stat;
    return fileSystem->stat(fileName, &stat) >= 0 && !stat.attr[FileAttribute::Directory];
}

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

inline bool dirExist(const char* dirName)
{
    CHECK_FS(stat)
    FileStat stat;
    return fileSystem->stat(dirName, &stat) >= 0 && stat.attr[FileAttribute::Directory];
}

inline bool dirExist(const String& dirName)
{
    return dirExist(dirName.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 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::FileSystem::Info& info)
{
    CHECK_FS(getinfo)
    return fileSystem->getinfo(info);
}

IFS::FileSystem::Type fileSystemType();

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

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

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

template <typename T> int fileSetAttr(const T& filename, FileAttributes attr)
{
    CHECK_FS(setattr)
    return fileSystem->setattr(filename, attr);
}

inline int fileSetTime(FileHandle file, time_t mtime)
{
    CHECK_FS(settime)
    return fileSystem->settime(file, mtime);
}

template <typename T> int createDirectory(const T& path)
{
    CHECK_FS(mkdir);
    return fileSystem->mkdir(path);
}

template <typename T> int createDirectories(const T& path)
{
    CHECK_FS(mkdir);
    return fileSystem->makedirs(path);
}