FileSystem.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Buffer.h"
#include "../Foundation/Result.h"
#include "../Strings/String.h"
#include "../Time/Time.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT FileSystem;
struct StringConverter;
} // namespace SC
 
 
 
struct SC::FileSystem
{
  private:
    StringNative<512> currentDirectory = StringEncoding::Native;
 
  public:
    bool preciseErrorMessages = false; 
 
    Result init(StringView initialDirectory);
 
    Result changeDirectory(StringView newDirectory);
 
    struct CopyFlags
    {
        CopyFlags()
        {
            overwrite           = false;
            useCloneIfSupported = true;
        }
 
        CopyFlags& setOverwrite(bool value)
        {
            overwrite = value;
            return *this;
        }
 
        CopyFlags& setUseCloneIfSupported(bool value)
        {
            useCloneIfSupported = value;
            return *this;
        }
 
      private:
        friend struct FileSystem;
        bool overwrite;
        bool useCloneIfSupported;
    };
 
    struct CopyOperation
    {
        StringView source;      
        StringView destination; 
        CopyFlags  copyFlags;   
    };
 
    [[nodiscard]] Result copyFiles(Span<const CopyOperation> sourceDestination);
 
    [[nodiscard]] Result copyFile(StringView source, StringView destination, CopyFlags copyFlags = CopyFlags())
    {
        return copyFiles(CopyOperation{source, destination, copyFlags});
    }
 
    [[nodiscard]] Result copyDirectories(Span<const CopyOperation> sourceDestination);
 
    [[nodiscard]] Result copyDirectory(StringView source, StringView destination, CopyFlags copyFlags = CopyFlags())
    {
        return copyDirectories(CopyOperation{source, destination, copyFlags});
    }
 
    [[nodiscard]] Result removeFiles(Span<const StringView> files);
 
    [[nodiscard]] Result removeFile(StringView source) { return removeFiles({source}); }
 
    [[nodiscard]] Result removeFileIfExists(StringView source);
 
    [[nodiscard]] Result removeLinkIfExists(StringView source);
 
    [[nodiscard]] Result removeDirectoriesRecursive(Span<const StringView> directories);
 
    [[nodiscard]] Result removeDirectoryRecursive(StringView directory)
    {
        return removeDirectoriesRecursive({directory});
    }
 
    [[nodiscard]] Result removeEmptyDirectories(Span<const StringView> directories);
 
    [[nodiscard]] Result removeEmptyDirectory(StringView directory) { return removeEmptyDirectories({directory}); }
 
    [[nodiscard]] Result removeEmptyDirectoriesRecursive(Span<const StringView> directories);
 
    [[nodiscard]] Result removeEmptyDirectoryRecursive(StringView directory)
    {
        return removeEmptyDirectoriesRecursive({directory});
    }
 
    [[nodiscard]] Result makeDirectories(Span<const StringView> directories);
 
    [[nodiscard]] Result makeDirectory(StringView directory) { return makeDirectories({directory}); }
 
    [[nodiscard]] Result makeDirectoriesIfNotExists(Span<const StringView> directories);
 
    [[nodiscard]] Result makeDirectoryIfNotExists(StringView directory)
    {
        return makeDirectoriesIfNotExists({directory});
    }
 
    [[nodiscard]] Result makeDirectoriesRecursive(Span<const StringView> directories);
 
    [[nodiscard]] Result makeDirectoryRecursive(StringView directory) { return makeDirectoriesRecursive({directory}); }
 
    [[nodiscard]] Result createSymbolicLink(StringView sourceFileOrDirectory, StringView linkFile);
 
    [[nodiscard]] bool exists(StringView fileOrDirectory);
 
    [[nodiscard]] bool existsAndIsDirectory(StringView directory);
 
    [[nodiscard]] bool existsAndIsFile(StringView file);
 
    [[nodiscard]] bool existsAndIsLink(StringView file);
 
    [[nodiscard]] bool moveDirectory(StringView sourceDirectory, StringView destinationDirectory);
 
    [[nodiscard]] Result write(StringView file, Span<const char> data);
    [[nodiscard]] Result write(StringView file, Span<const uint8_t> data);
 
    [[nodiscard]] Result read(StringView file, Buffer& data);
 
    [[nodiscard]] Result writeString(StringView file, StringView text);
 
    [[nodiscard]] Result writeStringAppend(StringView file, StringView text);
 
    [[nodiscard]] Result read(StringView file, String& data, StringEncoding encoding);
 
    struct FileStat
    {
        size_t         fileSize     = 0;
        Time::Realtime modifiedTime = 0; 
    };
    [[nodiscard]] Result getFileStat(StringView file, FileStat& fileStat);
 
    [[nodiscard]] Result setLastModifiedTime(StringView file, Time::Realtime time);
 
  private:
    [[nodiscard]] bool convert(const StringView file, String& destination, StringView* encodedPath = nullptr);
 
    StringNative<128> fileFormatBuffer1  = StringEncoding::Native;
    StringNative<128> fileFormatBuffer2  = StringEncoding::Native;
    StringNative<128> errorMessageBuffer = StringEncoding::Native;
 
    Result formatError(int errorNumber, StringView item, bool isWindowsNativeError);
    struct Internal;
 
    // Fallbacks
    [[nodiscard]] static Result fallbackCopyDirectory(String& sourceDirectory, String& destinationDirectory,
                                                      FileSystem::CopyFlags options);
    [[nodiscard]] static Result fallbackRemoveDirectoryRecursive(String& sourceDirectory);
};