private FileResolveResult ResolveDestinationFile([NotNull] FileCopyArguments arguments)
{
var destinationResolver = new FileResolver(Container)
{
ErrorFileFoundAsDirectory = ErrorFactory.System.TargetIsNotFile
};
return(destinationResolver.TryResolveFile(arguments.DestinationPath));
}
public override object Handle(FileDeleteArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
var resolver = new FileResolver(Root);
FileResolveResult resolveResult = resolver.TryResolveFile(arguments.Path);
if (resolveResult.ExistingFileOrNull != null)
{
DeleteFile(resolveResult.ExistingFileOrNull, resolveResult.ContainingDirectory, arguments);
}
return(Missing.Value);
}
public override bool Handle(EntryExistsArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
if (arguments.Path == null)
{
return(false);
}
var resolver = new FileResolver(Container);
FileResolveResult resolveResult = resolver.TryResolveFile(arguments.Path);
return(resolveResult.ExistingFileOrNull != null);
}
public override bool Handle(DirectoryOrFileExistsArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
if (arguments.Path == null)
{
return(false);
}
var resolver = new FileResolver(Root);
(DirectoryEntry _, FileEntry existingFileOrNull, string _) = resolver.TryResolveFile(arguments.Path);
return(existingFileOrNull != null);
}
public override IFileStream Handle(FileOpenArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
FileAccess fileAccess = DetectFileAccess(arguments);
AssertValidCombinationOfModeWithAccess(arguments.Mode, fileAccess);
var resolver = new FileResolver(Root);
FileResolveResult resolveResult = resolver.TryResolveFile(arguments.Path);
return(resolveResult.ExistingFileOrNull != null
? HandleExistingFile(resolveResult.ExistingFileOrNull, fileAccess, arguments)
: HandleNewFile(resolveResult.FileName, resolveResult.ContainingDirectory, fileAccess, arguments));
}
public override object Handle(FileDeleteArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
var resolver = new FileResolver(Root);
(DirectoryEntry containingDirectory, FileEntry existingFileOrNull, string _) =
resolver.TryResolveFile(arguments.Path);
if (existingFileOrNull != null)
{
DeleteFile(existingFileOrNull, containingDirectory, arguments);
}
return(Missing.Value);
}
public override IFileStream Handle(FileCreateArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
AssertValidCreationOptions(arguments);
var resolver = new FileResolver(Root);
FileResolveResult resolveResult = resolver.TryResolveFile(arguments.Path);
AssertIsNotHiddenOrReadOnly(resolveResult.ExistingFileOrNull, arguments.Path);
FileEntry file = resolveResult.ExistingFileOrNull ??
resolveResult.ContainingDirectory.CreateFile(resolveResult.FileName);
if ((arguments.Options & FileOptions.DeleteOnClose) != 0)
{
file.EnableDeleteOnClose();
}
return(file.Open(FileMode.Create, FileAccess.ReadWrite, arguments.Path));
}
private FileEntry ResolveDestinationFile([NotNull] AbsolutePath destinationPath, bool overwrite,
[NotNull] FileEntry sourceFile)
{
var destinationResolver = new FileResolver(Root)
{
ErrorFileFoundAsDirectory = ErrorFactory.System.TargetIsNotFile
};
FileResolveResult resolveResult = destinationResolver.TryResolveFile(destinationPath);
DateTime utcNow = Root.SystemClock.UtcNow();
FileEntry destinationFile;
if (resolveResult.ExistingFileOrNull != null)
{
AssertCanOverwriteFile(overwrite, destinationPath);
AssertIsNotHiddenOrReadOnly(resolveResult.ExistingFileOrNull, destinationPath);
destinationFile = resolveResult.ContainingDirectory.Files[resolveResult.FileName];
}
else
{
destinationFile = resolveResult.ContainingDirectory.CreateFile(resolveResult.FileName);
destinationFile.CreationTimeUtc = utcNow;
}
using (IFileStream createStream = destinationFile.Open(FileMode.Truncate, FileAccess.Write, destinationPath))
{
createStream.SetLength(sourceFile.Size);
}
destinationFile.Attributes = sourceFile.Attributes;
destinationFile.LastAccessTimeUtc = utcNow;
destinationFile.LastWriteTimeUtc = sourceFile.LastWriteTimeUtc;
return(destinationFile);
}