Components/IFS/src/include/IFS/FileSystem.h

Go to the documentation of this file.

#pragma once

#include "IFileSystem.h"
#include <Delegate.h>

namespace IFS
{
class FileSystem : public IFileSystem
{
public:
    static constexpr FileSystem& cast(IFileSystem& fs)
    {
        return static_cast<FileSystem&>(fs);
    }

    static constexpr FileSystem* cast(IFileSystem* fs)
    {
        return static_cast<FileSystem*>(fs);
    }

    using IFileSystem::opendir;
    int opendir(const String& path, DirHandle& dir)
    {
        return opendir(path.c_str(), dir);
    }

    int makedirs(const char* path);

    int makedirs(const String& path)
    {
        return makedirs(path.c_str());
    }

    using IFileSystem::stat;
    int stat(const String& path, Stat* s)
    {
        return stat(path.c_str(), s);
    }
    int stat(const String& path, Stat& s)
    {
        return stat(path.c_str(), &s);
    }

    using IFileSystem::fstat;
    int fstat(FileHandle file, Stat& stat)
    {
        return fstat(file, &stat);
    }

    using IFileSystem::open;
    FileHandle open(const String& path, OpenFlags flags)
    {
        return open(path.c_str(), flags);
    }

    using IFileSystem::ftruncate;
    int ftruncate(FileHandle file)
    {
        int pos = tell(file);
        return (pos < 0) ? pos : ftruncate(file, pos);
    }

    int truncate(const char* fileName, size_t newSize);

    int truncate(const String& fileName, size_t newSize)
    {
        return truncate(fileName.c_str(), newSize);
    }

    using IFileSystem::rename;
    int rename(const String& oldpath, const String& newpath)
    {
        return rename(oldpath.c_str(), newpath.c_str());
    }

    using IFileSystem::remove;
    int remove(const String& path)
    {
        return remove(path.c_str());
    }

    uint32_t getSize(FileHandle file);

    uint32_t getSize(const char* fileName);

    uint32_t getSize(const String& fileName)
    {
        return getSize(fileName.c_str());
    }

    using ReadContentCallback = Delegate<int(const char* buffer, size_t size)>;

    int readContent(FileHandle file, size_t size, ReadContentCallback callback);

    int readContent(FileHandle file, ReadContentCallback callback);

    int readContent(const String& filename, ReadContentCallback callback);

    size_t getContent(const char* fileName, char* buffer, size_t bufSize);

    size_t getContent(const String& fileName, char* buffer, size_t bufSize)
    {
        return getContent(fileName.c_str(), buffer, bufSize);
    }

    String getContent(const String& fileName);

    int setContent(const char* fileName, const void* content, size_t length);

    int setContent(const char* fileName, const char* content)
    {
        return setContent(fileName, content, (content == nullptr) ? 0 : strlen(content));
    }

    int setContent(const String& fileName, const char* content)
    {
        return setContent(fileName.c_str(), content);
    }

    int setContent(const String& fileName, const void* content, size_t length)
    {
        return setContent(fileName.c_str(), content, length);
    }

    int setContent(const String& fileName, const String& content)
    {
        return setContent(fileName.c_str(), content.c_str(), content.length());
    }

};

#ifdef ARCH_HOST
namespace Host
{
FileSystem& getFileSystem();
}
#endif

} // namespace IFS