FileSystem.h

Go to the documentation of this file.

#pragma once
 
#include "io/Path.h"
#include "objects/containers/Array.h"
#include "objects/wrappers/Expected.h"
#include "objects/wrappers/Flags.h"
#include "objects/wrappers/Outcome.h"
#include <dirent.h>
 
NAMESPACE_SPH_BEGIN
 
namespace FileSystem {
 
std::string readFile(const Path& path);
 
bool pathExists(const Path& path);
 
Size fileSize(const Path& path);
 
bool isPathWritable(const Path& path);
 
Expected<Path> getHomeDirectory();
 
Path getAbsolutePath(const Path& relativePath);
 
enum class PathType {
    FILE,      
    DIRECTORY, 
    SYMLINK,   
    OTHER,     
};
 
Expected<PathType> pathType(const Path& path);
 
 
enum class CreateDirectoryFlag {
    ALLOW_EXISTING = 1 << 0
};
 
Outcome createDirectory(const Path& path,
    const Flags<CreateDirectoryFlag> flags = CreateDirectoryFlag::ALLOW_EXISTING);
 
enum class RemovePathFlag {
    RECURSIVE = 1 << 1
};
 
Outcome removePath(const Path& path, const Flags<RemovePathFlag> flags = EMPTY_FLAGS);
 
Outcome copyFile(const Path& from, const Path& to);
 
Outcome copyDirectory(const Path& from, const Path& to);
 
void setWorkingDirectory(const Path& path);
 
class ScopedWorkingDirectory {
private:
    Path originalDir;
 
public:
    ScopedWorkingDirectory(const Path& path) {
        originalDir = Path::currentPath();
        setWorkingDirectory(path);
    }
 
    ~ScopedWorkingDirectory() {
        setWorkingDirectory(originalDir);
    }
};
 
class DirectoryIterator {
    friend class DirectoryAdapter;
 
private:
    DIR* dir;
    dirent* entry = nullptr;
 
public:
    DirectoryIterator& operator++();
 
    Path operator*() const;
 
    bool operator==(const DirectoryIterator& other) const;
 
    bool operator!=(const DirectoryIterator& other) const;
 
private:
    DirectoryIterator(DIR* dir);
};
 
class DirectoryAdapter : public Noncopyable {
private:
    DIR* dir;
 
public:
    DirectoryAdapter(const Path& directory);
 
    DirectoryAdapter(DirectoryAdapter&& other);
 
    ~DirectoryAdapter();
 
    DirectoryIterator begin() const;
 
    DirectoryIterator end() const;
};
 
DirectoryAdapter iterateDirectory(const Path& directory);
 
Array<Path> getFilesInDirectory(const Path& directory);
 
class FileLock {
private:
    int handle;
 
public:
    explicit FileLock(const Path& path);
 
    void lock();
 
    void unlock();
};
 
bool isFileLocked(const Path& path);
 
} // namespace FileSystem
 
NAMESPACE_SPH_END