Filesystem.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <string>
#include <string_view>
#include <vector>
 
#include "common/Capability.h"
#include "common/Exception.h"
#include "common/Module.h"
#include "common/Result.h"
#include "common/ServiceInterfaces.h"
#include "common/config.h"
#include "filesystem/File.h"
#include "filesystem/FileData.h"
 
#include <cstdint>
 
#ifdef EVENGINE_WINDOWS
#define EVENGINE_APPDATA_PREFIX ""
#define EVENGINE_APPDATA_FOLDER "EVE"
#define EVENGINE_PATH_SEPARATOR "/"
#define EVENGINE_MAX_PATH _MAX_PATH
#else
#if defined(EVENGINE_MACOSX) || defined(EVENGINE_IOS)
#define EVENGINE_APPDATA_PREFIX ""
#define EVENGINE_APPDATA_FOLDER "EVE"
#elif defined(EVENGINE_LINUX)
#define EVENGINE_APPDATA_PREFIX ""
#define EVENGINE_APPDATA_FOLDER "eve"
#else
#define EVENGINE_APPDATA_PREFIX "."
#define EVENGINE_APPDATA_FOLDER "eve"
#endif
#define EVENGINE_PATH_SEPARATOR "/"
#define EVENGINE_MAX_PATH MAXPATHLEN
#endif
 
namespace eve::filesystem {
 
class EVENGINE_API_FOUNDATION Filesystem : public Module, public eve::service::IFileSystem {
public:
    Module_REG(Filesystem);
 
    struct Info {
        // Numbers will be -1 if they cannot be determined.
        int64_t     size;
        int64_t     modtime;
        std::string type;  // file, directory, symlink, other
    };
 
    Filesystem() { eve::cap::provide<eve::service::IFileSystem>(this); }
    virtual ~Filesystem() {}
 
    bool readFile(const std::string &path, std::vector<uint8_t> &out) override {
        try {
            FileData *fd = read(path);
            if (!fd) return false;
            const auto *data = static_cast<const uint8_t *>(fd->getData());
            out.assign(data, data + fd->getSize());
            delete fd;
            return true;
        } catch (const eve::Exception &) {
            return false;
        }
    }
 
    bool writeFile(const std::string &path, const void *data, size_t size) override {
        try {
            write(path, data, int64_t(size));
            return true;
        } catch (const eve::Exception &) {
            return false;
        }
    }
 
    bool fileExists(const std::string &path) override {
        Info info;
        return getInfo(path, info);
    }
 
    virtual void init(const char* arg0) = 0;
 
    virtual void setFused(bool fused) = 0;
    virtual bool isFused() const      = 0;
 
    virtual bool setupWriteDirectory() = 0;
 
    virtual void setAndroidSaveExternal(bool external = false) { this->useExternal = external; }
 
    virtual bool isAndroidSaveExternal() const { return useExternal; }
 
    virtual bool        setIdentity(std::string ident, bool appendToPath = false) = 0;
    virtual std::string getIdentity() const                                       = 0;
 
    virtual bool setSource(std::string source) = 0;
 
    virtual bool setSourceFromMemory(const void* data, size_t size) = 0;
 
    virtual std::string getSource() const = 0;
 
    virtual bool mount(std::string archive, std::string mountpoint, bool appendToPath = false)                 = 0;
    virtual bool mount(Data *data, std::string archivename, std::string mountpoint, bool appendToPath = false) = 0;
 
    virtual bool mountRealDirectory(std::string realDir, std::string mountpoint, bool appendToPath = false) = 0;
 
    virtual bool unmountRealDirectory(std::string realDir) = 0;
 
    virtual bool unmount(std::string archive) = 0;
    virtual bool unmount(Data *data)          = 0;
 
    virtual File *newFile(std::string filename) const = 0;
 
    virtual FileData *newFileData(const void *data, std::string filename, size_t size) const;
 
    virtual std::string getWorkingDirectory() = 0;
 
    virtual std::string getUserDirectory() = 0;
 
    virtual std::string getAppdataDirectory() = 0;
 
    virtual std::string getSaveDirectory() = 0;
 
    virtual std::string getSourceBaseDirectory() const = 0;
 
    virtual std::string getRealDirectory(std::string filename) const = 0;
 
    virtual bool getInfo(std::string filepath, Info &info) const = 0;
 
    virtual bool createDirectory(std::string dir) = 0;
 
    virtual bool remove(std::string file) = 0;
 
    virtual FileData *read(std::string filename, int64_t size = File::ALL) const = 0;
 
    virtual void write(std::string filename, const void *data, int64_t size) const = 0;
 
    virtual void append(std::string filename, const void *data, int64_t size) const = 0;
 
    bool writeText(const std::string &filename, const std::string &text) const;
 
    [[nodiscard]] eve::Result<void> writeTextAtomic(std::string_view filename,
                                                    std::string_view text);
 
    std::string readText(const std::string &filename) const;
 
    virtual std::vector<std::string> getDirectoryItems(std::string dir) = 0;
 
    virtual void setSymlinksEnabled(bool enable) = 0;
 
    virtual bool areSymlinksEnabled() const = 0;
 
    // Require path accessors
    // Not const because it's R/W
    virtual std::vector<std::string> &getRequirePath()  = 0;
    virtual std::vector<std::string> &getCRequirePath() = 0;
 
    virtual void allowMountingForPath(const std::string &path) = 0;
 
    bool mountExternalReadOnly(const std::string &path, const std::string &mountpoint);
 
    virtual bool isRealDirectory(const std::string &path) const;
 
    virtual std::string getExecutablePath() const;
 
    // --- File watch (backend-specific; main-thread poll) ---
 
    virtual bool watch(std::string path) = 0;
 
    [[nodiscard]] virtual eve::Result<void> watchRealDirectory(std::string realDir,
                                                               std::string reportPath) = 0;
 
    virtual bool unwatch(std::string path) = 0;
    virtual void unwatchAll() = 0;
    virtual int getWatchCount() const = 0;
 
    virtual std::string pollWatch() = 0;
    virtual std::string getLastWatchPath() const = 0;
    virtual std::string getLastWatchRealPath() const = 0;
 
private:
    // Should we save external or internal for Android
    bool useExternal = false;
};  // Filesystem
 
}  // namespace eve::filesystem