FileSystem.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Internal/IGrowableBuffer.h"
#include "../Foundation/PrimitiveTypes.h"
#include "../Foundation/Result.h"
#include "../Foundation/StringPath.h"
 
namespace SC
{
 
 
enum class FileSystemEntryType : uint8_t
{
    Unknown,
    File,
    Directory,
    SymbolicLink,
    Other,
};
 
struct FileSystemStat
{
    FileSystemEntryType entryType = FileSystemEntryType::Unknown; 
 
    size_t fileSize      = 0; 
    size_t hardLinkCount = 0; 
    TimeMs creationTime;      
    TimeMs accessedTime;      
    TimeMs modifiedTime;      
 
    struct
    {
        uint32_t mode          = 0; 
        uint32_t uid           = 0; 
        uint32_t gid           = 0; 
        uint64_t inode         = 0; 
        uint64_t device        = 0; 
        uint64_t specialDevice = 0; 
        uint64_t blocks        = 0; 
        uint64_t blockSize     = 0; 
    } posix;
 
    struct
    {
        uint32_t attributes         = 0; 
        uint32_t reparseTag         = 0; 
        uint32_t volumeSerialNumber = 0; 
        uint64_t fileIndex          = 0; 
    } windows;
};
 
enum class FileSystemAccessMode : uint8_t
{
    Exists,  
    Read,    
    Write,   
    Execute, 
};
 
struct FileSystemCopyFlags
{
    FileSystemCopyFlags()
    {
        overwrite           = false;
        useCloneIfSupported = true;
    }
 
    FileSystemCopyFlags& setOverwrite(bool value)
    {
        overwrite = value;
        return *this;
    }
 
    FileSystemCopyFlags& setUseCloneIfSupported(bool value)
    {
        useCloneIfSupported = value;
        return *this;
    }
 
    bool overwrite;           
    bool useCloneIfSupported; 
};
 
struct SC_COMPILER_EXPORT FileSystem
{
    bool preciseErrorMessages = false; 
 
    using AccessMode = FileSystemAccessMode;
 
    Result init(StringSpan initialDirectory);
 
    Result changeDirectory(StringSpan newDirectory);
 
    using CopyFlags = FileSystemCopyFlags;
 
    struct CopyOperation
    {
        StringSpan source;      
        StringSpan destination; 
        CopyFlags  copyFlags;   
    };
 
    Result copyFiles(Span<const CopyOperation> sourceDestination);
 
    Result copyFile(StringSpan source, StringSpan destination, CopyFlags copyFlags = CopyFlags())
    {
        return copyFiles(CopyOperation{source, destination, copyFlags});
    }
 
    Result copyDirectories(Span<const CopyOperation> sourceDestination);
 
    Result copyDirectory(StringSpan source, StringSpan destination, CopyFlags copyFlags = CopyFlags())
    {
        return copyDirectories(CopyOperation{source, destination, copyFlags});
    }
 
    Result rename(StringSpan path, StringSpan newPath);
 
    Result removeFiles(Span<const StringSpan> files);
 
    Result removeFile(StringSpan source) { return removeFiles({source}); }
 
    Result removeFileIfExists(StringSpan source);
 
    Result removeLinkIfExists(StringSpan source);
 
    Result removeDirectoriesRecursive(Span<const StringSpan> directories);
 
    Result removeDirectoryRecursive(StringSpan directory) { return removeDirectoriesRecursive({directory}); }
 
    Result removeEmptyDirectories(Span<const StringSpan> directories);
 
    Result removeEmptyDirectory(StringSpan directory) { return removeEmptyDirectories({directory}); }
 
    Result makeDirectories(Span<const StringSpan> directories);
 
    Result makeDirectory(StringSpan directory) { return makeDirectories({directory}); }
 
    Result makeDirectoriesIfNotExists(Span<const StringSpan> directories);
 
    Result makeDirectoryIfNotExists(StringSpan directory) { return makeDirectoriesIfNotExists({directory}); }
 
    Result makeDirectoriesRecursive(Span<const StringSpan> directories);
 
    Result makeDirectoryRecursive(StringSpan directory) { return makeDirectoriesRecursive({directory}); }
 
    Result createSymbolicLink(StringSpan sourceFileOrDirectory, StringSpan linkFile);
 
    Result createHardLink(StringSpan sourceFile, StringSpan linkFile);
 
    [[nodiscard]] bool exists(StringSpan fileOrDirectory);
 
    [[nodiscard]] bool existsAndIsDirectory(StringSpan directory);
 
    [[nodiscard]] bool existsAndIsFile(StringSpan file);
 
    [[nodiscard]] bool existsAndIsLink(StringSpan file);
 
    [[nodiscard]] bool canAccess(StringSpan fileOrDirectory, AccessMode accessMode = AccessMode::Exists);
 
    [[nodiscard]] bool moveDirectory(StringSpan sourceDirectory, StringSpan destinationDirectory);
 
    Result write(StringSpan file, Span<const char> data);
    Result write(StringSpan file, Span<const uint8_t> data);
 
    Result writeString(StringSpan file, StringSpan text);
 
    Result writeStringAppend(StringSpan file, StringSpan text);
 
    template <typename T>
    Result read(StringSpan file, T& data)
    {
        return read(file, GrowableBuffer<T>{data});
    }
 
    Result read(StringSpan file, IGrowableBuffer&& buffer);
 
    using FileStat = FileSystemStat;
 
    Result stat(StringSpan file, FileStat& fileStat);
 
    Result lstat(StringSpan file, FileStat& fileStat);
 
    Result getFileStat(StringSpan file, FileStat& fileStat);
 
    Result readSymbolicLink(StringSpan linkFile, StringPath& destination);
 
    Result chmod(StringSpan path, uint32_t mode);
 
    Result chown(StringSpan path, uint32_t uid, uint32_t gid);
 
    Result lchown(StringSpan path, uint32_t uid, uint32_t gid);
 
    Result lchmod(StringSpan path, uint32_t mode);
 
    Result setLastModifiedTime(StringSpan file, TimeMs time);
 
    struct SC_COMPILER_EXPORT Operations
    {
        static Result access(StringSpan path, AccessMode accessMode);
        static Result createSymbolicLink(StringSpan sourceFileOrDirectory, StringSpan linkFile);
        static Result createHardLink(StringSpan sourceFile, StringSpan linkFile);
        static Result makeDirectory(StringSpan dir);
        static Result exists(StringSpan path);
        static Result existsAndIsDirectory(StringSpan path);
        static Result existsAndIsFile(StringSpan path);
        static Result existsAndIsLink(StringSpan path);
        static Result makeDirectoryRecursive(StringSpan path);
        static Result removeEmptyDirectory(StringSpan path);
        static Result moveDirectory(StringSpan source, StringSpan destination);
        static Result removeFile(StringSpan path);
        static Result copyFile(StringSpan srcPath, StringSpan destPath, FileSystemCopyFlags flags);
        static Result rename(StringSpan path, StringSpan newPath);
        static Result copyDirectory(StringSpan srcPath, StringSpan destPath, FileSystemCopyFlags flags);
        static Result removeDirectoryRecursive(StringSpan directory);
        static Result stat(StringSpan path, FileSystemStat& fileStat);
        static Result lstat(StringSpan path, FileSystemStat& fileStat);
        static Result getFileStat(StringSpan path, FileSystemStat& fileStat);
        static Result readSymbolicLink(StringSpan path, StringPath& destination);
        static Result chmod(StringSpan path, uint32_t mode);
        static Result chown(StringSpan path, uint32_t uid, uint32_t gid);
        static Result lchown(StringSpan path, uint32_t uid, uint32_t gid);
        static Result lchmod(StringSpan path, uint32_t mode);
        static Result setLastModifiedTime(StringSpan path, TimeMs time);
 
        static StringSpan getExecutablePath(StringPath& executablePath);
        static StringSpan getCurrentWorkingDirectory(StringPath& currentWorkingDirectory);
        static StringSpan getApplicationRootDirectory(StringPath& applicationRootDirectory);
 
      private:
        struct Internal;
    };
 
  private:
    [[nodiscard]] bool convert(const StringSpan file, StringPath& destination, StringSpan* encodedPath = nullptr);
 
    StringPath fileFormatBuffer1;
    StringPath fileFormatBuffer2;
    StringPath currentDirectory;
 
    char errorMessageBuffer[256] = {0};
 
    Result formatError(int errorNumber, StringSpan item, bool isWindowsNativeError);
    struct Internal;
};
} // namespace SC