public void Copy(AbsoluteDirectoryPath source, AbsoluteDirectoryPath destination) { Directory.CreateDirectory(destination.NativePath); foreach (var fileInfo in new DirectoryInfo(source.NativePath).GetFiles()) { fileInfo.CopyTo((destination / fileInfo.Name).NativePath, true); } foreach (var directoryInfo in new DirectoryInfo(source.NativePath).GetDirectories()) { var sourceDir = (source / directoryInfo.Name); var destDir = (destination / directoryInfo.Name); Copy(sourceDir, destDir); } }
static AbsoluteDirectoryPath FindCommonAncestorBalanced(AbsoluteDirectoryPath left, AbsoluteDirectoryPath right) { while (left != null && right != null) { if (left == right) { return(left); } left = left.ContainingDirectory; right = right.ContainingDirectory; } return(null); }
/// <exception cref="InvalidPath"></exception> /// <exception cref="ArgumentException"></exception> public static AbsoluteFilePath Parse(string nativePath) { if (string.IsNullOrEmpty(nativePath)) { throw new ArgumentException("nativePath"); } try { return(new AbsoluteFilePath( new FileName(Path.GetFileName(nativePath)), AbsoluteDirectoryPath.Parse(Path.GetDirectoryName(nativePath)))); } catch (Exception e) { throw new InvalidPath(nativePath, e); } }
//Unused method, but maybe someone wants it for manual testing or something? #pragma warning disable 0219 public void Execute() { var root = AbsoluteDirectoryPath.Parse("root"); var file1 = root.Combine("Templates").Combine("Projects").Combine(new FileName("example.exe")); var file2 = root / "Templates" / "Projects" / new FileName("example.exe"); IAbsolutePath absFileOrDirectory = file2; absFileOrDirectory.Do( (AbsoluteFilePath file) => Console.Out.WriteLine("File " + file), (AbsoluteDirectoryPath dir) => Console.Out.WriteLine("Dir " + dir)); IFilePath absOrRelFile = file2; absOrRelFile.Do( (AbsoluteFilePath abs) => Console.Out.WriteLine("Abs " + abs), (RelativeFilePath rel) => Console.Out.WriteLine("Rel " + rel)); var relativePath = RelativeDirectoryPath.Empty / ".." / "Programs" / "Fuse" / "Data"; var rebased = root / relativePath; var common = root / "a" / "b"; var nop = common.RelativeTo(common); var downUp = (common / "left").RelativeTo(common / "right"); var downDownUpUp = (common / "left" / "left2").RelativeTo(common / "right" / "right2"); var downDownDownUpUpUp = (common / "left" / "left2" / "left3").RelativeTo(common / "right" / "right2" / "right3"); var left = common / "lc" / "ld"; var right = common / "rc" / "rd" / "re"; var rightToLeft = left.RelativeTo(right); var leftToRight = right.RelativeTo(left); var leftToLeft = left.RelativeTo(left); var a = common / leftToLeft; var b = a == common; }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (objectType == typeof(AbsoluteFilePath)) { return(AbsoluteFilePath.Parse((string)reader.Value)); } if (objectType == typeof(RelativeFilePath)) { return(RelativeFilePath.Parse((string)reader.Value)); } if (objectType == typeof(AbsoluteDirectoryPath)) { return(AbsoluteDirectoryPath.Parse((string)reader.Value)); } if (objectType == typeof(RelativeDirectoryPath)) { return(RelativeDirectoryPath.Parse((string)reader.Value)); } throw new ArgumentException("The type '" + objectType.FullName + "' was not recognized by this converter"); }
public void SetPermission( AbsoluteDirectoryPath dir, FileSystemPermission permission, FileSystemGroup group, bool recursive) { var dInfo = new DirectoryInfo(dir.NativePath); var dSec = new DirectorySecurity(); dSec.AddAccessRule(new FileSystemAccessRule( GetIdentity(group), CreateSystemRightsFile(permission), AccessControlType.Allow)); dInfo.SetAccessControl(dSec); if (recursive) { ReplaceAllDescendantPermissionsFromObject(dInfo, dSec, permission, group); } }
public IObservable <FileSystemEventData> Watch(AbsoluteDirectoryPath path, Optional <string> filter = default(Optional <string>)) { return(Observable.Create <FileSystemEventData>(observer => { if (!Exists(path)) { observer.OnError(new FileNotFoundException("Directory not found", path.ContainingDirectory.NativePath)); return Disposable.Empty; } var fsw = filter.Select(f => new FileSystemWatcher(path.NativePath, f)).Or(new FileSystemWatcher(path.NativePath)); fsw.IncludeSubdirectories = false; fsw.NotifyFilter = NotifyFilters.CreationTime | NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.Size; var garbage = Disposable.Combine( fsw, Observable.FromEventPattern <ErrorEventArgs>(fsw, "Error") .Subscribe(_ => observer.OnError(_.EventArgs.GetException())), Observable.FromEventPattern <FileSystemEventArgs>(fsw, "Changed") .Subscribe(e => observer.OnNext(new FileSystemEventData(AbsoluteFilePath.Parse(e.EventArgs.FullPath), FileSystemEvent.Changed))), Observable.FromEventPattern <FileSystemEventArgs>(fsw, "Created") .Subscribe(e => observer.OnNext(new FileSystemEventData(AbsoluteFilePath.Parse(e.EventArgs.FullPath), FileSystemEvent.Created))), Observable.FromEventPattern <RenamedEventArgs>(fsw, "Renamed") .Subscribe(e => { observer.OnNext(new FileSystemEventData( AbsoluteFilePath.Parse(e.EventArgs.FullPath), FileSystemEvent.Renamed, AbsoluteFilePath.Parse(e.EventArgs.OldFullPath))); }), Observable.FromEventPattern <FileSystemEventArgs>(fsw, "Deleted") .Subscribe(e => observer.OnNext(new FileSystemEventData(AbsoluteFilePath.Parse(e.EventArgs.FullPath), FileSystemEvent.Removed)))); fsw.EnableRaisingEvents = true; return garbage; })); }
public void SetPermission( AbsoluteDirectoryPath dir, FileSystemPermission permission, FileSystemGroup group, bool recursive) { var permissionBits = GetPermissionBits(permission, group); Syscall.chmod(dir.NativePath, (FilePermissions)permissionBits); if (recursive) { foreach (var file in Directory.GetFiles(dir.NativePath)) { var filePermission = (int)permission & ~(int)FileSystemPermission.Execute; SetPermission(AbsoluteFilePath.Parse(file), (FileSystemPermission)filePermission, group); } foreach (var directory in Directory.GetDirectories(dir.NativePath)) { SetPermission(AbsoluteDirectoryPath.Parse(directory), permission, group, recursive); } } }
public void Create(AbsoluteDirectoryPath directory) { Directory.CreateDirectory(directory.NativePath); }
internal AbsoluteFilePath(FileName name, AbsoluteDirectoryPath containingDirectory) { ContainingDirectory = containingDirectory; Name = name; }
/// <exception cref="System.Security.SecurityException" /> public static AbsoluteDirectoryPath GetTempPath() { return(AbsoluteDirectoryPath.Parse(Path.GetTempPath())); }
public IEnumerable <AbsoluteDirectoryPath> GetDirectories(AbsoluteDirectoryPath path) { return(_shellImpl.GetDirectories(path)); }
public IEnumerable <AbsoluteDirectoryPath> GetDirectories(AbsoluteDirectoryPath path, string searchPattern) { return(_shellImpl.GetDirectories(path, searchPattern)); }
public static AbsoluteDirectoryPath FindCommonAncestor(AbsoluteDirectoryPath path1, AbsoluteDirectoryPath path2) { var orderedPaths = OrderByDepth(path1, path2); var balancedPaths = Balance(orderedPaths); if (balancedPaths == null) { return(null); } return(FindCommonAncestorBalanced(balancedPaths.Item1, balancedPaths.Item2)); }
public static AbsoluteDirectoryPath ToAbsoluteDirectoryPath(this Uri uri) { return(AbsoluteDirectoryPath.Parse(Uri.UnescapeDataString(uri.LocalPath))); }
public IEnumerable <AbsoluteDirectoryPath> GetDirectories(AbsoluteDirectoryPath path) { return(Directory.GetDirectories(path.NativePath).Select(AbsoluteDirectoryPath.Parse)); }
public static IDirectoryPath Parse(string relativeOrAbsolutePath) { return(Path.IsPathRooted(relativeOrAbsolutePath) ? (IDirectoryPath)AbsoluteDirectoryPath.Parse(relativeOrAbsolutePath) : (IDirectoryPath)RelativeDirectoryPath.Parse(relativeOrAbsolutePath)); }
public void Move(AbsoluteDirectoryPath source, AbsoluteDirectoryPath destination) { _shellImpl.Move(source, destination); }
/// <exception cref="System.UnauthorizedAccessException" /> public static AbsoluteDirectoryPath GetCurrentDirectory() { return(AbsoluteDirectoryPath.Parse(Directory.GetCurrentDirectory())); }
public static void Write(BinaryWriter writer, AbsoluteDirectoryPath path) { writer.Write(path.NativePath); }
public void OpenFolder(AbsoluteDirectoryPath path) { Process.Start((string)path.NativePath); }
public IObservable <FileSystemEventData> Watch(AbsoluteDirectoryPath path, Optional <string> filter = default(Optional <string>)) { return(_shellImpl.Watch(path, filter)); }
public void Create(AbsoluteDirectoryPath directory) { _shellImpl.Create(directory); }
public static AbsoluteFilePath ParseAndMakeAbsolute(IFilePath path, AbsoluteDirectoryPath root) { return(path as AbsoluteFilePath ?? ParseAndMakeAbsolute(((RelativeFilePath)path).NativeRelativePath, root)); }
public IEnumerable <AbsoluteDirectoryPath> GetDirectories(AbsoluteDirectoryPath path, string searchPattern) { return(Directory.GetDirectories(path.NativePath, searchPattern).Select(AbsoluteDirectoryPath.Parse)); }
public void OpenFolder(AbsoluteDirectoryPath path) { //TODO: is this needed ? ps.UpdatePathEnvironment(); _shellImpl.OpenFolder(path); }
public static AbsoluteDirectoryPath MakeUnique(this IFileSystem fileSystem, AbsoluteDirectoryPath path) { return(fileSystem.MakeUnique(path, i => path.Rename(CreateNumberName(path.Name, i)))); }
public void OpenTerminal(AbsoluteDirectoryPath containingDirectory) { _shellImpl.OpenTerminal(containingDirectory); }