protected override Result CommitImpl() { lock (Locker) { if (!IsPersistentSaveData) { return(Result.Success); } if (OpenWritableFileCount > 0) { // All files must be closed before commiting save data. return(ResultFs.WriteModeFileNotClosed.Log()); } // Get rid of the previous commit by renaming the folder Result rc = BaseFs.RenameDirectory(CommittedDirectoryPath, SynchronizingDirectoryPath); if (rc.IsFailure()) { return(rc); } // If something goes wrong beyond this point, the commit will be // completed the next time the savedata is opened rc = SynchronizeDirectory(SynchronizingDirectoryPath, WorkingDirectoryPath); if (rc.IsFailure()) { return(rc); } return(BaseFs.RenameDirectory(SynchronizingDirectoryPath, CommittedDirectoryPath)); } }
protected override Result DoGetTotalSpaceSize(out long totalSpace, U8Span path) { return(BaseFs.GetTotalSpaceSize(out totalSpace, path)); // FS does: // return ResultFs.UnsupportedOperationReadOnlyFileSystemGetSpace.Log(); }
protected override Result DoRenameFile(U8Span oldPath, U8Span newPath) { FsPath fullCurrentPath; FsPath fullNewPath; unsafe { _ = &fullCurrentPath; } // workaround for CS0165 unsafe { _ = &fullNewPath; } // workaround for CS0165 Result rc = ResolveFullPath(fullCurrentPath.Str, oldPath); if (rc.IsFailure()) { return(rc); } rc = ResolveFullPath(fullNewPath.Str, newPath); if (rc.IsFailure()) { return(rc); } lock (Locker) { return(BaseFs.RenameFile(fullCurrentPath, fullNewPath)); } }
protected override Result DoGetFileTimeStampRaw(out FileTimeStampRaw timeStamp, U8Span path) { return(BaseFs.GetFileTimeStampRaw(out timeStamp, path)); // FS does: // return ResultFs.NotImplemented.Log(); }
/// <summary> /// Creates the destination directory if needed and copies the source directory to it. /// </summary> /// <param name="destPath">The path of the destination directory.</param> /// <param name="sourcePath">The path of the source directory.</param> /// <returns>The <see cref="Result"/> of the operation.</returns> private Result SynchronizeDirectory(U8Span destPath, U8Span sourcePath) { // Delete destination dir and recreate it. Result rc = BaseFs.DeleteDirectoryRecursively(destPath); // Nintendo returns error unconditionally because SynchronizeDirectory is always called in situations // where a PathNotFound error would mean the save directory was in an invalid state. // We'll ignore PathNotFound errors to be more user-friendly to users who might accidentally // put the save directory in an invalid state. if (rc.IsFailure() && !ResultFs.PathNotFound.Includes(rc)) { return(rc); } rc = BaseFs.CreateDirectory(destPath); if (rc.IsFailure()) { return(rc); } // Get a work buffer to work with. using (var buffer = new RentedArray <byte>(IdealWorkBufferSize)) { return(Utility.CopyDirectoryRecursively(BaseFs, destPath, sourcePath, buffer.Span)); } }
protected override Result GetEntryTypeImpl(out DirectoryEntryType entryType, string path) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { return(BaseFs.GetEntryType(out entryType, fullPath)); } }
protected override Result OpenDirectoryImpl(out IDirectory directory, string path, OpenDirectoryMode mode) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { return(BaseFs.OpenDirectory(out directory, fullPath, mode)); } }
protected override Result DeleteFileImpl(string path) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { return(BaseFs.DeleteFile(fullPath)); } }
protected override Result CleanDirectoryRecursivelyImpl(string path) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { return(BaseFs.CleanDirectoryRecursively(fullPath)); } }
protected override Result CreateDirectoryImpl(string path) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { return(BaseFs.CreateDirectory(fullPath)); } }
public void DeleteFile(string path) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { BaseFs.DeleteFile(fullPath); } }
public DirectoryEntryType GetEntryType(string path) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { return(BaseFs.GetEntryType(fullPath)); } }
public void CleanDirectoryRecursively(string path) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { BaseFs.CleanDirectoryRecursively(fullPath); } }
public void CreateDirectory(string path) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { BaseFs.CreateDirectory(fullPath); } }
public void CreateFile(string path, long size, CreateFileOptions options) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { BaseFs.CreateFile(fullPath, size, options); } }
public bool FileExists(string path) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { return(BaseFs.FileExists(fullPath)); } }
public IDirectory OpenDirectory(string path, OpenDirectoryMode mode) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { return(BaseFs.OpenDirectory(fullPath, mode)); } }
protected override Result CreateFileImpl(string path, long size, CreateFileOptions options) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { return(BaseFs.CreateFile(fullPath, size, options)); } }
public void RenameFile(string srcPath, string dstPath) { string fullSrcPath = GetFullPath(PathTools.Normalize(srcPath)); string fullDstPath = GetFullPath(PathTools.Normalize(dstPath)); lock (Locker) { BaseFs.RenameFile(fullSrcPath, fullDstPath); } }
protected override Result RenameFileImpl(string oldPath, string newPath) { string fullOldPath = GetFullPath(PathTools.Normalize(oldPath)); string fullNewPath = GetFullPath(PathTools.Normalize(newPath)); lock (Locker) { return(BaseFs.RenameFile(fullOldPath, fullNewPath)); } }
public void Commit() { if (OpenWritableFileCount > 0) { throw new InvalidOperationException("All files must be closed before commiting save data."); } SynchronizeDirectory(SyncDir, WorkingDir); BaseFs.DeleteDirectoryRecursively(CommittedDir); BaseFs.RenameDirectory(SyncDir, CommittedDir); }
private void SynchronizeDirectory(string dest, string src) { if (BaseFs.DirectoryExists(dest)) { BaseFs.DeleteDirectoryRecursively(dest); } BaseFs.CreateDirectory(dest); IDirectory sourceDir = BaseFs.OpenDirectory(src, OpenDirectoryMode.All); IDirectory destDir = BaseFs.OpenDirectory(dest, OpenDirectoryMode.All); sourceDir.CopyDirectory(destDir); }
protected override Result DoCreateFile(U8Span path, long size, CreateFileOptions options) { Unsafe.SkipInit(out FsPath fullPath); Result rc = ResolveFullPath(fullPath.Str, path); if (rc.IsFailure()) { return(rc); } lock (Locker) { return(BaseFs.CreateFile(fullPath, size, options)); } }
protected override Result DoDeleteFile(U8Span path) { Unsafe.SkipInit(out FsPath fullPath); Result rc = ResolveFullPath(fullPath.Str, path); if (rc.IsFailure()) { return(rc); } lock (Locker) { return(BaseFs.DeleteFile(fullPath)); } }
protected override Result DoCleanDirectoryRecursively(U8Span path) { Unsafe.SkipInit(out FsPath fullPath); Result rc = ResolveFullPath(fullPath.Str, path); if (rc.IsFailure()) { return(rc); } lock (Locker) { return(BaseFs.CleanDirectoryRecursively(fullPath)); } }
public IFile OpenFile(string path, OpenMode mode) { string fullPath = GetFullPath(PathTools.Normalize(path)); lock (Locker) { IFile baseFile = BaseFs.OpenFile(fullPath, mode); var file = new DirectorySaveDataFile(this, baseFile); if (mode.HasFlag(OpenMode.Write)) { OpenWritableFileCount++; } return(file); } }
protected override Result DoOpenDirectory(out IDirectory directory, U8Span path, OpenDirectoryMode mode) { Unsafe.SkipInit(out FsPath fullPath); Result rc = ResolveFullPath(fullPath.Str, path); if (rc.IsFailure()) { UnsafeHelpers.SkipParamInit(out directory); return(rc); } lock (Locker) { return(BaseFs.OpenDirectory(out directory, fullPath, mode)); } }
protected override Result DoGetEntryType(out DirectoryEntryType entryType, U8Span path) { Unsafe.SkipInit(out FsPath fullPath); Result rc = ResolveFullPath(fullPath.Str, path); if (rc.IsFailure()) { UnsafeHelpers.SkipParamInit(out entryType); return(rc); } lock (Locker) { return(BaseFs.GetEntryType(out entryType, fullPath)); } }
private Result SynchronizeDirectory(string dest, string src) { Result rc = BaseFs.DeleteDirectoryRecursively(dest); if (rc.IsFailure() && rc != ResultFs.PathNotFound) { return(rc); } rc = BaseFs.CreateDirectory(dest); if (rc.IsFailure()) { return(rc); } return(BaseFs.CopyDirectory(BaseFs, src, dest)); }
protected override Result DoDeleteFile(U8Span path) { FsPath fullPath; unsafe { _ = &fullPath; } // workaround for CS0165 Result rc = ResolveFullPath(fullPath.Str, path); if (rc.IsFailure()) { return(rc); } lock (Locker) { return(BaseFs.DeleteFile(fullPath)); } }