FileSystemImpl.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/deps/core/file/DirectoryIterationFlags.h"
#include "mc/deps/core/file/FileAccessType.h"
#include "mc/deps/core/file/FileBufferingMode.h"
#include "mc/deps/core/file/FileType.h"
#include "mc/deps/core/file/PathBuffer.h"
#include "mc/deps/core/file/file_system/CrossStorageCopyMode.h"
#include "mc/deps/core/file/file_system/TransactionFlags.h"
#include "mc/platform/brstd/function_ref.h"
 
// auto generated forward declare list
// clang-format off
namespace Core { class FileImpl; }
namespace Core { class FileOpenMode; }
namespace Core { class FileStats; }
namespace Core { class FileStorageArea; }
namespace Core { class FlatFileManifestTracker; }
namespace Core { class PathView; }
namespace Core { class Result; }
namespace Core { struct DirectoryIterationItem; }
namespace Core { struct ExcludedPath; }
// clang-format on
 
namespace Core {
 
class FileSystemImpl {
public:
    // member variables
    // NOLINTBEGIN
    ::ll::UntypedStorage<8, 16> mUnkc9bc1f;
    ::ll::UntypedStorage<1, 1>  mUnk26049b;
    ::ll::UntypedStorage<1, 1>  mUnkf94830;
    ::ll::UntypedStorage<1, 1>  mUnk9bcf95;
    ::ll::UntypedStorage<4, 4>  mUnka1996d;
    ::ll::UntypedStorage<4, 4>  mUnk906cc5;
    ::ll::UntypedStorage<8, 64> mUnkdc96a2;
    ::ll::UntypedStorage<8, 80> mUnk3b13c8;
    ::ll::UntypedStorage<8, 24> mUnk104955;
    ::ll::UntypedStorage<8, 24> mUnkaaf50d;
    // NOLINTEND
 
public:
    // prevent constructor by default
    FileSystemImpl& operator=(FileSystemImpl const&);
    FileSystemImpl(FileSystemImpl const&);
    FileSystemImpl();
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~FileSystemImpl();
 
    virtual ::Core::Result getLastModificationTime(::Core::PathView entryPath, int64* lastModificationTime);
 
    virtual ::Core::Result copyTimeAndAccessRights(::Core::PathView sourceFilePath, ::Core::PathView targetFilePath);
 
    virtual bool shouldCommit();
 
    virtual ::Core::CrossStorageCopyMode getCrossStorageCopyMode();
 
    virtual uint64 getTransactionWriteSizeLimit() const;
 
    virtual ::Core::Result _openFile(
        ::std::unique_ptr<::Core::FileImpl>& uptFileOut,
        ::Core::PathView                     filename,
        ::Core::FileOpenMode                 fileOpenMode,
        ::Core::FileBufferingMode            bufferingMode
    ) = 0;
 
    virtual bool _fileExists(::Core::PathView filePath) = 0;
 
    virtual ::Core::Result _deleteFile(::Core::PathView path) = 0;
 
    virtual ::Core::Result _deleteFilePriority(::Core::PathView filePath);
 
    virtual ::Core::Result _getFileSize(::Core::PathView filePath, uint64* pFileSizeOut) = 0;
 
    virtual ::Core::Result _renameFile(::Core::PathView sourceFilePath, ::Core::PathView targetFilePath) = 0;
 
    virtual ::Core::Result _createEmptyFile(::Core::PathView fileName);
 
    virtual ::Core::Result _copyFile(::Core::PathView sourceFileName, ::Core::PathView targetFileName);
 
    virtual ::Core::Result _copyFileWithLimit(
        ::Core::PathView sourceFileName,
        ::Core::PathView targetFileName,
        uint64           startPosition,
        uint64&          outBytesWritten,
        uint64&          outBytesRemaining
    );
 
    virtual ::Core::Result
    _readFileData(::Core::PathView filePath, ::brstd::function_ref<void*(uint64)> data, uint64* bytesRead);
 
    virtual ::Core::Result _writeFileData(::Core::PathView filePath, void const* data, uint64 size);
 
    virtual ::Core::Result _createOneDirectory(::Core::PathView directoryPath) = 0;
 
    virtual ::Core::Result _createOneDirectoryIfNotExisting(::Core::PathView directoryPath);
 
    virtual ::Core::Result _createDirectoryRecursively(::Core::PathView directoryPath);
 
    virtual bool _directoryExists(::Core::PathView directoryPath) = 0;
 
    virtual ::Core::Result _deleteEmptyDirectory(::Core::PathView directoryPath) = 0;
 
    virtual ::Core::Result _deleteDirectoryAndContentsRecursively(::Core::PathView directoryPath);
 
    virtual ::Core::Result _deleteDirectoryContentsRecursively(::Core::PathView directoryPath);
 
    virtual ::Core::Result _deleteRecursively(::Core::PathView directoryPath, ::Core::FileType deleteFileType);
 
    virtual ::Core::Result
    _renameDirectory(::Core::PathView sourceDirectoryPath, ::Core::PathView targetDirectoryPath) = 0;
 
    virtual ::Core::Result _iterateOverDirectory(
        ::Core::PathView                                                             directoryPath,
        ::Core::DirectoryIterationFlags                                              flags,
        ::brstd::function_ref<::Core::Result(::Core::DirectoryIterationItem const&)> fx
    ) = 0;
 
    virtual ::Core::Result
    _getDirectoryFiles(::std::vector<::Core::PathBuffer<::std::string>>& files, ::Core::PathView directoryPath);
 
    virtual ::Core::Result _getDirectoryFilesRecursively(
        ::std::vector<::Core::PathBuffer<::std::string>>& filesOut,
        ::Core::PathView                                  directoryPath
    );
 
    virtual ::Core::Result _getDirectoryFilesSizeRecursively(uint64& totalSize, ::Core::PathView directoryPath);
 
    virtual ::Core::Result _getDirectoryFilesAllocatedSizeRecursively(
        uint64&          totalSize,
        uint64&          totalSizeAllocated,
        ::Core::PathView directoryPath
    );
 
    virtual ::Core::Result
    _copyDirectoryAndContentsRecursively(::Core::PathView sourceDirectoryPath, ::Core::PathView targetDirectoryPath);
 
    virtual bool _fileOrDirectoryExists(::Core::PathView entryPath) = 0;
 
    virtual ::Core::Result _getFileOrDirectorySize(::Core::PathView entryName, uint64* pFileSizeOut);
 
    virtual ::Core::Result _getEntryType(::Core::PathView entryPath, ::Core::FileType& fileTypeOut) = 0;
 
    virtual ::Core::Result _addIgnoredThrottlePath(::Core::PathView);
 
    virtual ::Core::Result _removeIgnoredThrottlePath(::Core::PathView);
 
    virtual ::Core::Result _createFlatFile(::Core::PathView sourceDirectoryPath, ::Core::PathView targetDirectoryPath);
 
    virtual bool _flatFileFileExists(::Core::PathView filePath, ::Core::PathView manifestPath);
 
    virtual bool _flatFileDirectoryExists(::Core::PathView directoryPath, ::Core::PathView manifestPath);
 
    virtual ::Core::Result _flatFileIterateOverDirectory(
        ::Core::PathView                                                             directoryPath,
        ::Core::PathView                                                             manifestPath,
        ::Core::DirectoryIterationFlags                                              flags,
        ::brstd::function_ref<::Core::Result(::Core::DirectoryIterationItem const&)> callbackFunction
    );
 
    virtual bool _isDirectoryPathAFlatFile(::Core::PathView directoryPath);
 
    virtual ::Core::Result _copyFlatFile(
        ::Core::PathView                           sourceDirectoryPath,
        ::Core::PathView                           targetDirectoryPath,
        ::std::vector<::Core::ExcludedPath> const& excludedDirectories,
        ::std::vector<::Core::ExcludedPath> const& excludedFiles
    );
 
    virtual ::Core::Result _flatFileDeleteFileOrDirectory(
        ::Core::PathView fileOrDirectoryPath,
        ::Core::PathView manifestPath,
        bool             directoryDeleteEnabled,
        bool             deleteRecursively
    );
 
    virtual ::Core::Result
    _flatFileGetFileSize(::Core::PathView filePath, ::Core::PathView manifestPath, uint64* pFileSize);
 
    virtual ::Core::Result _getLastModificationTime(::Core::PathView filePath, int64* pModificationTime) = 0;
 
    virtual ::Core::Result
    _copyTimeAndAccessRights(::Core::PathView sourceEntryPath, ::Core::PathView targetEntryPath) = 0;
 
    virtual ::Core::Result _endTransaction();
 
    virtual ::Core::Result _writeOperation(
        ::Core::PathView,
        ::Core::Result&&                                result,
        ::std::function<void(::Core::FileStorageArea*)> observerCallOrNull,
        uint64                                          numBytesWritten
    );
 
    virtual void _initializeInternal();
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCNAPI FileSystemImpl(
        ::Core::FileAccessType                             accessType,
        ::std::shared_ptr<::Core::FileStorageArea>         storageArea,
        ::std::shared_ptr<::Core::FlatFileManifestTracker> manifestTracker
    );
 
    MCNAPI FileSystemImpl(
        ::Core::FileAccessType                             accessType,
        ::std::shared_ptr<::Core::FileStorageArea>         storageArea,
        ::Core::TransactionFlags                           transactionFlags,
        ::std::shared_ptr<::Core::FlatFileManifestTracker> manifestTracker
    );
 
    MCNAPI void _addFile(::Core::FileImpl* pFile);
 
    MCNAPI ::Core::Result _readWriteOperation(
        ::Core::Result&&                                result,
        ::std::function<void(::Core::FileStorageArea*)> observerCallOrNull,
        uint64                                          numBytesRead,
        uint64                                          numBytesWritten
    );
 
    MCNAPI ::Core::Result commit();
 
    MCNAPI ::Core::Result copyFile(::Core::PathView sourceFilePath, ::Core::PathView targetFilePath);
 
    MCNAPI ::Core::Result copyFileWithLimit(
        ::Core::PathView sourceFileName,
        ::Core::PathView targetFileName,
        uint64           startPosition,
        uint64&          outBytesWritten,
        uint64&          outBytesRemaining
    );
 
    MCNAPI ::Core::Result createDirectoryRecursively(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result createEmptyFile(::Core::PathView filePath);
 
    MCNAPI ::Core::Result createOneDirectory(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result createOneDirectoryIfNotExisting(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result deleteDirectoryAndContentsRecursively(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result deleteDirectoryContentsRecursively(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result deleteEmptyDirectory(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result deleteFile(::Core::PathView filePath);
 
    MCNAPI bool directoryExists(::Core::PathView directoryPath);
 
    MCNAPI bool fileExists(::Core::PathView filePath);
 
    MCNAPI bool fileOrDirectoryExists(::Core::PathView entryPath);
 
    MCNAPI ::Core::Result getFileSize(::Core::PathView filePath, uint64* pFileSize);
 
    MCNAPI bool isDirectoryPathAFlatFile(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result iterateOverDirectory(
        ::Core::PathView                                                             directoryPath,
        ::Core::DirectoryIterationFlags                                              flags,
        ::brstd::function_ref<::Core::Result(::Core::DirectoryIterationItem const&)> callbackFunction
    );
 
    MCNAPI ::Core::Result openFile(
        ::std::unique_ptr<::Core::FileImpl>& fileOut,
        ::Core::PathView                     filePath,
        ::Core::FileOpenMode                 openMode,
        ::Core::FileBufferingMode            fileBufferingMode
    );
 
    MCNAPI ::Core::Result renameDirectory(::Core::PathView sourceDirectoryPath, ::Core::PathView targetDirectoryPath);
 
    MCNAPI ::Core::Result renameFile(::Core::PathView sourceFilePath, ::Core::PathView targetFilePath);
    // NOLINTEND
 
public:
    // static functions
    // NOLINTBEGIN
    MCNAPI static ::Core::Result isValidPath(::Core::PathView path);
    // NOLINTEND
 
public:
    // static variables
    // NOLINTBEGIN
    MCNAPI static ::Core::FileStats& sStats();
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCNAPI void* $ctor(
        ::Core::FileAccessType                             accessType,
        ::std::shared_ptr<::Core::FileStorageArea>         storageArea,
        ::std::shared_ptr<::Core::FlatFileManifestTracker> manifestTracker
    );
 
    MCNAPI void* $ctor(
        ::Core::FileAccessType                             accessType,
        ::std::shared_ptr<::Core::FileStorageArea>         storageArea,
        ::Core::TransactionFlags                           transactionFlags,
        ::std::shared_ptr<::Core::FlatFileManifestTracker> manifestTracker
    );
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCNAPI void $dtor();
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCNAPI ::Core::Result $getLastModificationTime(::Core::PathView entryPath, int64* lastModificationTime);
 
    MCNAPI ::Core::Result $copyTimeAndAccessRights(::Core::PathView sourceFilePath, ::Core::PathView targetFilePath);
 
    MCNAPI bool $shouldCommit();
 
    MCNAPI ::Core::CrossStorageCopyMode $getCrossStorageCopyMode();
 
    MCNAPI uint64 $getTransactionWriteSizeLimit() const;
 
    MCNAPI ::Core::Result $_deleteFilePriority(::Core::PathView filePath);
 
    MCNAPI ::Core::Result $_createEmptyFile(::Core::PathView fileName);
 
    MCNAPI ::Core::Result $_copyFile(::Core::PathView sourceFileName, ::Core::PathView targetFileName);
 
    MCNAPI ::Core::Result $_copyFileWithLimit(
        ::Core::PathView sourceFileName,
        ::Core::PathView targetFileName,
        uint64           startPosition,
        uint64&          outBytesWritten,
        uint64&          outBytesRemaining
    );
 
    MCNAPI ::Core::Result
    $_readFileData(::Core::PathView filePath, ::brstd::function_ref<void*(uint64)> data, uint64* bytesRead);
 
    MCNAPI ::Core::Result $_writeFileData(::Core::PathView filePath, void const* data, uint64 size);
 
    MCNAPI ::Core::Result $_createOneDirectoryIfNotExisting(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result $_createDirectoryRecursively(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result $_deleteDirectoryAndContentsRecursively(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result $_deleteDirectoryContentsRecursively(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result $_deleteRecursively(::Core::PathView directoryPath, ::Core::FileType deleteFileType);
 
    MCNAPI ::Core::Result
    $_getDirectoryFiles(::std::vector<::Core::PathBuffer<::std::string>>& files, ::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result $_getDirectoryFilesRecursively(
        ::std::vector<::Core::PathBuffer<::std::string>>& filesOut,
        ::Core::PathView                                  directoryPath
    );
 
    MCNAPI ::Core::Result $_getDirectoryFilesSizeRecursively(uint64& totalSize, ::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result $_getDirectoryFilesAllocatedSizeRecursively(
        uint64&          totalSize,
        uint64&          totalSizeAllocated,
        ::Core::PathView directoryPath
    );
 
    MCNAPI ::Core::Result
    $_copyDirectoryAndContentsRecursively(::Core::PathView sourceDirectoryPath, ::Core::PathView targetDirectoryPath);
 
    MCNAPI ::Core::Result $_getFileOrDirectorySize(::Core::PathView entryName, uint64* pFileSizeOut);
 
    MCNAPI ::Core::Result $_addIgnoredThrottlePath(::Core::PathView);
 
    MCNAPI ::Core::Result $_removeIgnoredThrottlePath(::Core::PathView);
 
    MCNAPI ::Core::Result $_createFlatFile(::Core::PathView sourceDirectoryPath, ::Core::PathView targetDirectoryPath);
 
    MCNAPI bool $_flatFileFileExists(::Core::PathView filePath, ::Core::PathView manifestPath);
 
    MCNAPI bool $_flatFileDirectoryExists(::Core::PathView directoryPath, ::Core::PathView manifestPath);
 
    MCNAPI ::Core::Result $_flatFileIterateOverDirectory(
        ::Core::PathView                                                             directoryPath,
        ::Core::PathView                                                             manifestPath,
        ::Core::DirectoryIterationFlags                                              flags,
        ::brstd::function_ref<::Core::Result(::Core::DirectoryIterationItem const&)> callbackFunction
    );
 
    MCNAPI bool $_isDirectoryPathAFlatFile(::Core::PathView directoryPath);
 
    MCNAPI ::Core::Result $_copyFlatFile(
        ::Core::PathView                           sourceDirectoryPath,
        ::Core::PathView                           targetDirectoryPath,
        ::std::vector<::Core::ExcludedPath> const& excludedDirectories,
        ::std::vector<::Core::ExcludedPath> const& excludedFiles
    );
 
    MCNAPI ::Core::Result $_flatFileDeleteFileOrDirectory(
        ::Core::PathView fileOrDirectoryPath,
        ::Core::PathView manifestPath,
        bool             directoryDeleteEnabled,
        bool             deleteRecursively
    );
 
    MCNAPI ::Core::Result
    $_flatFileGetFileSize(::Core::PathView filePath, ::Core::PathView manifestPath, uint64* pFileSize);
 
    MCNAPI ::Core::Result $_endTransaction();
 
    MCNAPI ::Core::Result $_writeOperation(
        ::Core::PathView,
        ::Core::Result&&                                result,
        ::std::function<void(::Core::FileStorageArea*)> observerCallOrNull,
        uint64                                          numBytesWritten
    );
 
    MCNAPI void $_initializeInternal();
 
 
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftable();
    // NOLINTEND
};
 
} // namespace Core