FileSystem.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMacrosExport.h"
#ifndef SC_EXPORT_LIBRARY_FILE_SYSTEM
#define SC_EXPORT_LIBRARY_FILE_SYSTEM 0
#endif
#define SC_FILE_SYSTEM_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_FILE_SYSTEM)
 
#include "../Common/IGrowableBufferSpan.h"
#include "../Common/IGrowableBufferStringPath.h"
#include "../Common/PrimitiveDefinitions.h"
#include "../Common/Result.h"
#include "FileSystemError.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_FILE_SYSTEM_EXPORT FileSystem
{
    using AccessMode = FileSystemAccessMode;
 
    ResultFileSystem init(StringSpan initialDirectory);
 
    ResultFileSystem changeDirectory(StringSpan newDirectory);
 
    using CopyFlags = FileSystemCopyFlags;
 
    struct CopyOperation
    {
        StringSpan source;      
        StringSpan destination; 
        CopyFlags  copyFlags;   
    };
 
    ResultFileSystem copyFiles(Span<const CopyOperation> sourceDestination);
 
    ResultFileSystem copyFile(StringSpan source, StringSpan destination, CopyFlags copyFlags = CopyFlags())
    {
        return copyFiles(CopyOperation{source, destination, copyFlags});
    }
 
    ResultFileSystem copyDirectories(Span<const CopyOperation> sourceDestination);
 
    ResultFileSystem copyDirectory(StringSpan source, StringSpan destination, CopyFlags copyFlags = CopyFlags())
    {
        return copyDirectories(CopyOperation{source, destination, copyFlags});
    }
 
    ResultFileSystem rename(StringSpan path, StringSpan newPath);
 
    ResultFileSystem removeFiles(Span<const StringSpan> files);
 
    ResultFileSystem removeFile(StringSpan source) { return removeFiles({source}); }
 
    ResultFileSystem removeFileIfExists(StringSpan source);
 
    ResultFileSystem removeLinkIfExists(StringSpan source);
 
    ResultFileSystem removeDirectoriesRecursive(Span<const StringSpan> directories);
 
    ResultFileSystem removeDirectoryRecursive(StringSpan directory) { return removeDirectoriesRecursive({directory}); }
 
    ResultFileSystem removeEmptyDirectories(Span<const StringSpan> directories);
 
    ResultFileSystem removeEmptyDirectory(StringSpan directory) { return removeEmptyDirectories({directory}); }
 
    ResultFileSystem makeDirectories(Span<const StringSpan> directories);
 
    ResultFileSystem makeDirectory(StringSpan directory) { return makeDirectories({directory}); }
 
    ResultFileSystem makeDirectoriesIfNotExists(Span<const StringSpan> directories);
 
    ResultFileSystem makeDirectoryIfNotExists(StringSpan directory) { return makeDirectoriesIfNotExists({directory}); }
 
    ResultFileSystem makeDirectoriesRecursive(Span<const StringSpan> directories);
 
    ResultFileSystem makeDirectoryRecursive(StringSpan directory) { return makeDirectoriesRecursive({directory}); }
 
    ResultFileSystem createSymbolicLink(StringSpan sourceFileOrDirectory, StringSpan linkFile);
 
    ResultFileSystem createHardLink(StringSpan sourceFile, StringSpan linkFile);
 
    [[nodiscard]] bool exists(StringSpan fileOrDirectory);
    ResultFileSystem exists(StringSpan fileOrDirectory, bool& doesExist);
 
    [[nodiscard]] bool existsAndIsDirectory(StringSpan directory);
    ResultFileSystem existsAndIsDirectory(StringSpan directory, bool& isDirectory);
 
    [[nodiscard]] bool existsAndIsFile(StringSpan file);
    ResultFileSystem existsAndIsFile(StringSpan file, bool& isFile);
 
    [[nodiscard]] bool existsAndIsLink(StringSpan file);
    ResultFileSystem existsAndIsLink(StringSpan file, bool& isLink);
 
    [[nodiscard]] bool canAccess(StringSpan fileOrDirectory, AccessMode accessMode = AccessMode::Exists);
    ResultFileSystem canAccess(StringSpan fileOrDirectory, AccessMode accessMode, bool& canAccessPath);
 
    [[nodiscard]] ResultFileSystem moveDirectory(StringSpan sourceDirectory, StringSpan destinationDirectory);
 
    ResultFileSystem write(StringSpan file, Span<const char> data);
    ResultFileSystem write(StringSpan file, Span<const uint8_t> data);
 
    ResultFileSystem writeString(StringSpan file, StringSpan text);
 
    ResultFileSystem writeStringAppend(StringSpan file, StringSpan text);
 
    template <typename T>
    ResultFileSystem read(StringSpan file, T& data)
    {
        return read(file, GrowableBuffer<T>{data});
    }
 
    ResultFileSystem read(StringSpan file, IGrowableBuffer&& buffer);
 
    using FileStat = FileSystemStat;
 
    ResultFileSystem stat(StringSpan file, FileStat& fileStat);
 
    ResultFileSystem lstat(StringSpan file, FileStat& fileStat);
 
    ResultFileSystem getFileStat(StringSpan file, FileStat& fileStat);
 
    ResultFileSystem readSymbolicLink(StringSpan linkFile, StringPath& destination);
 
    ResultFileSystem chmod(StringSpan path, uint32_t mode);
 
    ResultFileSystem chown(StringSpan path, uint32_t uid, uint32_t gid);
 
    ResultFileSystem lchown(StringSpan path, uint32_t uid, uint32_t gid);
 
    ResultFileSystem lchmod(StringSpan path, uint32_t mode);
 
    ResultFileSystem setLastModifiedTime(StringSpan file, TimeMs time);
 
    struct SC_FILE_SYSTEM_EXPORT Operations
    {
        static bool             access(StringSpan path, AccessMode accessMode);
        static ResultFileSystem access(StringSpan path, AccessMode accessMode, bool& canAccessPath);
        static ResultFileSystem createSymbolicLink(StringSpan sourceFileOrDirectory, StringSpan linkFile);
        static ResultFileSystem createHardLink(StringSpan sourceFile, StringSpan linkFile);
        static ResultFileSystem makeDirectory(StringSpan dir);
        static bool             exists(StringSpan path);
        static ResultFileSystem exists(StringSpan path, bool& doesExist);
        static bool             existsAndIsDirectory(StringSpan path);
        static ResultFileSystem existsAndIsDirectory(StringSpan path, bool& isDirectory);
        static bool             existsAndIsFile(StringSpan path);
        static ResultFileSystem existsAndIsFile(StringSpan path, bool& isFile);
        static bool             existsAndIsLink(StringSpan path);
        static ResultFileSystem existsAndIsLink(StringSpan path, bool& isLink);
        static ResultFileSystem makeDirectoryRecursive(StringSpan path);
        static ResultFileSystem removeEmptyDirectory(StringSpan path);
        static ResultFileSystem moveDirectory(StringSpan source, StringSpan destination);
        static ResultFileSystem removeFile(StringSpan path);
        static ResultFileSystem copyFile(StringSpan srcPath, StringSpan destPath, FileSystemCopyFlags flags);
        static ResultFileSystem rename(StringSpan path, StringSpan newPath);
        static ResultFileSystem copyDirectory(StringSpan srcPath, StringSpan destPath, FileSystemCopyFlags flags);
        static ResultFileSystem removeDirectoryRecursive(StringSpan directory);
        static ResultFileSystem stat(StringSpan path, FileSystemStat& fileStat);
        static ResultFileSystem lstat(StringSpan path, FileSystemStat& fileStat);
        static ResultFileSystem getFileStat(StringSpan path, FileSystemStat& fileStat);
        static ResultFileSystem readSymbolicLink(StringSpan path, StringPath& destination);
        static ResultFileSystem chmod(StringSpan path, uint32_t mode);
        static ResultFileSystem chown(StringSpan path, uint32_t uid, uint32_t gid);
        static ResultFileSystem lchown(StringSpan path, uint32_t uid, uint32_t gid);
        static ResultFileSystem lchmod(StringSpan path, uint32_t mode);
        static ResultFileSystem setLastModifiedTime(StringSpan path, TimeMs time);
 
        static StringSpan getExecutablePath(StringPath& executablePath);
        static StringSpan getCurrentWorkingDirectory(StringPath& currentWorkingDirectory);
        static StringSpan getApplicationRootDirectory(StringPath& applicationRootDirectory);
 
      private:
        struct Internal;
    };
 
  private:
    static constexpr size_t WindowsPathTransportCapacity = StringPath::MaxPath + 6;
 
    [[nodiscard]] ResultFileSystem convert(const StringSpan file, StringPath& destination,
                                           StringNativeBuffer<WindowsPathTransportCapacity + 1>& transportPath,
                                           StringSpan*                                           encodedPath = nullptr);
 
    StringPath fileFormatBuffer1;
    StringPath fileFormatBuffer2;
    StringPath currentDirectory;
 
    StringNativeBuffer<WindowsPathTransportCapacity + 1> fileTransportBuffer1;
    StringNativeBuffer<WindowsPathTransportCapacity + 1> fileTransportBuffer2;
};
} // namespace SC