Timerix/DTLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

IOPath

Browse Source
This commit is contained in:
Timerix22 2023-02-08 02:02:55 +06:00
parent fe980d5a82
commit 563eabb6c4
6 changed files with 328 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
DTLib.Tests/Program.cs
View File

@ -30,16 +30,13 @@ public static class Program
try
{
string path = "file";
string path2 = path + "_temp";
// Ensure that the target does not exist.
File.Delete(path2);
// Copy the file.
File.Copy(path, path2);
IOPath path = "file";
IOPath path2 = "dir/"+ path + "_temp";
File.Create(path);
File.Copy(path, path2, true);
System.Console.WriteLine("{0} was copied to {1}.", path, path2);
// Delete the newly created file.
File.Delete(path2);
System.Console.WriteLine("{0} was successfully deleted.", path2);
Directory.Copy(path2.ParentDir(), "dir2/c/", true);
System.Console.WriteLine($"dir/c/:\n"+Directory.GetAllFiles("dir2\\c").MergeToString("\n\t"));
return;
new LaunchArgumentParser().WithNoExit().ParseAndHandle(args);

6
DTLib/DependencyResolver.cs
View File

@ -29,10 +29,10 @@ public static class DependencyResolver
_ => throw new Exception($"unsupported platform {RuntimeInformation.ProcessArchitecture}")
};
string[] possibleLibDirs =
IOPath[] possibleLibDirs = new []
{
Path.Concat("runtimes", $"{os}"),
Path.Concat("runtimes", $"{os}", "native"),
Path.Concat("runtimes", os),
Path.Concat("runtimes", os, "native"),
Path.Concat("runtimes", $"{os}-{arch}"),
Path.Concat("runtimes", $"{os}-{arch}", "native")
};

126
DTLib/Filesystem/Directory.cs
View File

@ -2,125 +2,101 @@
public static class Directory
{
public static bool Exists(string dir, bool separatorsFixed)
{
if(!separatorsFixed)
dir = Path.FixSeparators(dir);
return System.IO.Directory.Exists(dir);
}
public static bool Exists(IOPath dir) => System.IO.Directory.Exists(dir.Str);
/// создает папку, если её не существует
public static void Create(string dir, bool separatorsFixed)
public static void Create(IOPath dir)
{
if(!separatorsFixed)
dir = Path.FixSeparators(dir);
if (!Exists(dir))
if (Exists(dir)) return;
// creation of parent directories
if (dir.Contains(Path.Sep))
{
// проверяет существование папки, в которой нужно создать dir
if (dir.Contains(Path.Sep))
{
string parentDir = dir.Remove(dir.LastIndexOf(Path.Sep));
if(!Exists(parentDir,true))
Create(parentDir,true);
}
else System.IO.Directory.CreateDirectory(dir);
var parentDir = dir.ParentDir();
if(!Exists(parentDir))
Create(parentDir);
}
System.IO.Directory.CreateDirectory(dir.Str);
}
/// копирует все файлы и папки
public static void Copy(string source_dir, string new_dir, bool owerwrite)
public static void Copy(IOPath sourceDir, IOPath newDir, bool owerwrite)
{
Copy_internal(source_dir, new_dir, owerwrite, null);
Copy_internal(sourceDir, newDir, owerwrite, null);
}
/// копирует все файлы и папки и выдаёт список конфликтующих файлов
public static void Copy(string source_dir, string new_dir, bool owerwrite, out List<string> conflicts)
public static void Copy(IOPath sourceDir, IOPath newDir, bool owerwrite, out List<IOPath> conflicts)
{
conflicts = new List<string>();
Copy_internal(source_dir, new_dir, owerwrite, conflicts);
conflicts = new List<IOPath>();
Copy_internal(sourceDir, newDir, owerwrite, conflicts);
}
private static void Copy_internal(string source_dir, string new_dir, bool owerwrite, List<string> conflicts)
private static void Copy_internal(IOPath sourceDir, IOPath newDir, bool owerwrite, List<IOPath> conflicts)
{
bool countConflicts = conflicts is null;
List<string> files = GetAllFiles(source_dir);
Create(new_dir);
bool countConflicts = conflicts is not null;
List<IOPath> files = GetAllFiles(sourceDir);
Create(newDir);
for (int i = 0; i < files.Count; i++)
{
string newfile = Path.ReplaceBase(files[i], source_dir, new_dir);
var newfile = files[i].ReplaceBase(sourceDir, newDir);
if (countConflicts && File.Exists(newfile))
conflicts!.Add(newfile);
conflicts.Add(newfile);
File.Copy(files[i], newfile, owerwrite);
}
}
/// удаляет папку со всеми подпапками и файлами
public static void Delete(string dir, bool separatorsFixed)
{
if(!separatorsFixed)
dir = Path.FixSeparators(dir);
System.IO.Directory.Delete(dir, true);
}
public static void Delete(IOPath dir) =>
System.IO.Directory.Delete(dir.Str, true);
public static string[] GetFiles(string dir, bool separatorsFixed)
{
if (!separatorsFixed)
dir = Path.FixSeparators(dir);
return System.IO.Directory.GetFiles(dir);
}
public static IOPath[] GetFiles(IOPath dir) =>
IOPath.ArrayCast(System.IO.Directory.GetFiles(dir.Str));
public static string[] GetFiles(string dir, string searchPattern, bool separatorsFixed)
{
if (!separatorsFixed)
dir = Path.FixSeparators(dir);
return System.IO.Directory.GetFiles(dir, searchPattern);
}
public static IOPath[] GetFiles(IOPath dir, string searchPattern) =>
IOPath.ArrayCast(System.IO.Directory.GetFiles(dir.Str, searchPattern));
public static string[] GetDirectories(string dir, bool separatorsFixed)
{
if (!separatorsFixed)
dir = Path.FixSeparators(dir);
return System.IO.Directory.GetDirectories(dir);
}
public static IOPath[] GetDirectories(IOPath dir) =>
IOPath.ArrayCast(System.IO.Directory.GetDirectories(dir.Str));
public static IOPath[] GetDirectories(IOPath dir, string searchPattern) =>
IOPath.ArrayCast(System.IO.Directory.GetDirectories(dir.Str, searchPattern));
/// выдает список всех файлов
public static List<string> GetAllFiles(string dir)
public static List<IOPath> GetAllFiles(IOPath dir)
{
var all_files = new List<string>();
string[] cur_files = GetFiles(dir);
for (int i = 0; i < cur_files.Length; i++)
all_files.Add(cur_files[i]);
string[] cur_subdirs = GetDirectories(dir);
for (int i = 0; i < cur_subdirs.Length; i++)
all_files.AddRange(GetAllFiles(cur_subdirs[i]));
return all_files;
return GetAllFiles_internal(dir, null);
}
/// выдает список всех файлов и подпапок в папке
public static List<string> GetAllFiles(string dir, ref List<string> all_subdirs)
public static List<IOPath> GetAllFiles(IOPath dir, out List<IOPath> all_subdirs)
{
var all_files = new List<string>();
string[] cur_files = GetFiles(dir);
all_subdirs = new List<IOPath>();
return GetAllFiles_internal(dir, all_subdirs);
}
private static List<IOPath> GetAllFiles_internal(IOPath dir, List<IOPath> all_subdirs)
{
bool rememberSubdirs = all_subdirs is not null;
var all_files = new List<IOPath>();
IOPath[] cur_files = GetFiles(dir);
for (int i = 0; i < cur_files.Length; i++)
all_files.Add(cur_files[i]);
string[] cur_subdirs = GetDirectories(dir);
IOPath[] cur_subdirs = GetDirectories(dir);
for (int i = 0; i < cur_subdirs.Length; i++)
{
all_subdirs.Add(cur_subdirs[i]);
all_files.AddRange(GetAllFiles(cur_subdirs[i], ref all_subdirs));
if(rememberSubdirs)
all_subdirs.Add(cur_subdirs[i]);
all_files.AddRange(GetAllFiles_internal(cur_subdirs[i], all_subdirs));
}
return all_files;
}
public static string GetCurrent() => System.IO.Directory.GetCurrentDirectory();
public static void CreateSymlink(string sourcePath, string symlinkPath, bool separatorsFixed)
public static void CreateSymlink(string sourcePath, string symlinkPath)
{
if (!separatorsFixed)
{
sourcePath = Path.FixSeparators(sourcePath);
symlinkPath = Path.FixSeparators(symlinkPath);
}
Create(Path.ParentDir(symlinkPath, true), true);
if (symlinkPath.Contains(Path.Sep))
Create(Path.ParentDir(symlinkPath));
if (!Symlink.CreateSymbolicLink(symlinkPath, sourcePath, Symlink.SymlinkTarget.Directory))
throw new InvalidOperationException($"some error occured while creating symlink\nDirectory.CreateSymlink({symlinkPath}, {sourcePath})");
}

95
DTLib/Filesystem/File.cs
View File

@ -3,60 +3,45 @@
public static class File
{
/// возвращает размер файла в байтах
public static long GetSize(string file, bool separatorsFixed)
{
if (!separatorsFixed)
file = Path.FixSeparators(file);
return new System.IO.FileInfo(file).Length;
}
public static long GetSize(IOPath file) => new System.IO.FileInfo(file.Str).Length;
public static bool Exists(string file, bool separatorsFixed)
public static bool Exists(IOPath file)
{
if (!separatorsFixed)
file = Path.FixSeparators(file);
return System.IO.File.Exists(file);
if (System.IO.File.Exists(file.Str)) return true;
return false;
}
/// если файл не существует, создаёт файл с папками из его пути и закрывает этот фвйл
public static void Create(string file, bool separatorsFixed)
public static void Create(IOPath file)
{
if (!separatorsFixed)
file = Path.FixSeparators(file);
if (!Exists(file, true))
{
Directory.Create(Path.ParentDir(file, true), true);
using System.IO.FileStream stream = System.IO.File.Create(file);
stream.Close();
}
if (Exists(file)) return;
Directory.Create(file.ParentDir());
using System.IO.FileStream stream = System.IO.File.Create(file.Str);
stream.Close();
}
public static void Copy(string srcPath, string newPath, bool overwrite = false, bool separatorsFixed)
public static void Copy(IOPath srcPath, IOPath newPath, bool overwrite)
{
if (!separatorsFixed)
{
srcPath = Path.FixSeparators(srcPath);
newPath = Path.FixSeparators(newPath);
}
if (Exists(newPath))
{
if(overwrite) System.IO.File.Delete(newPath);
if(overwrite) System.IO.File.Delete(newPath.Str);
else throw new Exception($"file <{newPath}> alredy exists");
}
else Directory.Create(Path.ParentDir(newPath, true));
using var srcFile=System.IO.File.Open(srcPath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
using var newFile=System.IO.File.Open(newPath, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite);
else Directory.Create(newPath.ParentDir());
using var srcFile=System.IO.File.Open(srcPath.Str, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
using var newFile=System.IO.File.Open(newPath.Str, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite);
srcFile.CopyTo(newFile);
srcFile.Close();
newFile.Flush();
newFile.Close();
}
public static void Delete(string file) => System.IO.File.Delete(Path.FixSeparators(file));
public static void Delete(IOPath file) => System.IO.File.Delete(file.Str);
public static byte[] ReadAllBytes(string file)
public static byte[] ReadAllBytes(IOPath file)
{
file = Path.FixSeparators(file);
using System.IO.FileStream stream = OpenRead(file);
int size = GetSize(file).ToInt();
byte[] output = new byte[size];
@ -66,58 +51,52 @@ public static class File
return output;
}
public static string ReadAllText(string file) => ReadAllBytes(file).BytesToString(StringConverter.UTF8);
public static string ReadAllText(IOPath file) => ReadAllBytes(file).BytesToString(StringConverter.UTF8);
public static void WriteAllBytes(string file, byte[] content)
public static void WriteAllBytes(IOPath file, byte[] content)
{
file = Path.FixSeparators(file);
using System.IO.FileStream stream = OpenWrite(file);
stream.Write(content, 0, content.Length);
stream.Close();
}
public static void WriteAllText(string file, string content) => WriteAllBytes(file, content.ToBytes(StringConverter.UTF8));
public static void WriteAllText(IOPath file, string content) => WriteAllBytes(file, content.ToBytes(StringConverter.UTF8));
public static void AppendAllBytes(string file, byte[] content)
public static void AppendAllBytes(IOPath file, byte[] content)
{
file = Path.FixSeparators(file);
using System.IO.FileStream stream = OpenAppend(file);
stream.Write(content, 0, content.Length);
stream.Close();
}
public static void AppendAllText(string file, string content) => AppendAllBytes(file, content.ToBytes(StringConverter.UTF8));
public static void AppendAllText(IOPath file, string content) => AppendAllBytes(file, content.ToBytes(StringConverter.UTF8));
public static System.IO.FileStream OpenRead(string file)
public static System.IO.FileStream OpenRead(IOPath file)
{
file = Path.FixSeparators(file);
if (Exists(file))
return System.IO.File.Open(file, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
throw new Exception($"file not found: <{file}>");
if (!Exists(file))
throw new Exception($"file not found: <{file}>");
return System.IO.File.Open(file.Str, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
}
public static System.IO.FileStream OpenWrite(string file)
public static System.IO.FileStream OpenWrite(IOPath file)
{
file = Path.FixSeparators(file);
if (Exists(file))
Delete(file);
Create(file);
return System.IO.File.Open(file, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite);
return System.IO.File.Open(file.Str, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite);
}
public static System.IO.FileStream OpenAppend(string file)
public static System.IO.FileStream OpenAppend(IOPath file)
{
file = Path.FixSeparators(file);
Create(file);
return System.IO.File.Open(file, System.IO.FileMode.Append, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite);
return System.IO.File.Open(file.Str, System.IO.FileMode.Append, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite);
}
public static void CreateSymlink(string sourceName, string symlinkName)
public static void CreateSymlink(IOPath sourcePath, IOPath symlinkPath)
{
sourceName = Path.FixSeparators(sourceName);
symlinkName = Path.FixSeparators(symlinkName);
if (symlinkName.Contains(Path.Sep))
Directory.Create(symlinkName.Remove(symlinkName.LastIndexOf(Path.Sep)));
if (!Symlink.CreateSymbolicLink(symlinkName, sourceName, Symlink.SymlinkTarget.File))
throw new InvalidOperationException($"some error occured while creating symlink\nFile.CreateSymlink({symlinkName}, {sourceName})");
if (symlinkPath.Contains(Path.Sep))
Directory.Create(symlinkPath.ParentDir());
if (!Symlink.CreateSymbolicLink(symlinkPath.Str, sourcePath.Str, Symlink.SymlinkTarget.File))
throw new InvalidOperationException($"some error occured while creating symlink\nFile.CreateSymlink({symlinkPath}, {sourcePath})");
}
}

155
DTLib/Filesystem/IOPath.cs Normal file
View File

@ -0,0 +1,155 @@
#if NETSTANDARD2_1 || NET6_0 || NET7_0 || NET8_0
#define USE_SPAN
#endif
using System.Runtime.CompilerServices;
namespace DTLib.Filesystem;
public readonly struct IOPath
{
public readonly string Str;
public IOPath(string path, bool separatorsFixed=false)
{
if (!separatorsFixed)
{
var chars = path.ToCharArray();
for(int i=0; i<path.Length; i++)
if (chars[i] == Path.NotSep)
chars[i] = Path.Sep;
Str = new string(chars);
}
else Str = path;
}
public IOPath(char[] path) : this(new string(path)) {}
public static IOPath[] ArrayCast(string[] a)
{
IOPath[] b = new IOPath[a.Length];
for (int i = 0; i < a.Length; i++)
b[i] = (IOPath)a[i];
return b;
}
public static IOPath[] ArrayCast(IList<string> a)
{
IOPath[] b = new IOPath[a.Count];
for (int i = 0; i < a.Count; i++)
b[i] = (IOPath)a[i];
return b;
}
// public static IOPath operator +(IOPath a, IOPath b) => Concat(a, b);
public static bool operator ==(IOPath a, IOPath b) => a.Str==b.Str;
public static bool operator !=(IOPath a, IOPath b) => a.Str!=b.Str;
public static implicit operator IOPath(string s) => new(s);
public static explicit operator string(IOPath p) => p.Str;
public override string ToString() => Str;
public override bool Equals(object obj) => Str.Equals(obj);
public override int GetHashCode() => Str.GetHashCode();
public char this[int i] => Str[i];
public int Length => Str.Length;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public char[] ToCharArray() => Str.ToCharArray();
#if USE_SPAN
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ReadOnlySpan<char> AsSpan() => Str.AsSpan();
#endif
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Contains(char c) => Str.Contains(c);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Contains(string s) => Str.Contains(s);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Contains(IOPath p) => Str.Contains(p.Str);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool StartsWith(char c) => Str.StartsWith(c);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool StartsWith(string s) => Str.StartsWith(s);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool StartsWith(IOPath p) => Str.StartsWith(p.Str);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool EndsWith(char c) => Str.EndsWith(c);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool EndsWith(string s) => Str.EndsWith(s);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool EndsWith(IOPath p) => Str.EndsWith(p.Str);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public IOPath Remove(int startIndex) => new(Str.Remove(startIndex), true);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public IOPath Remove(int startIndex, int count) => new(Str.Remove(startIndex, count), true);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public IOPath Substring(int startIndex) => new(Str.Substring(startIndex), true);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public IOPath Substring(int startIndex, int count) => new(Str.Substring(startIndex, count), true);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public IOPath Replace(char oldChar, char newChar) => new(Str.Replace(oldChar, newChar), true);
[Obsolete("use different replace methods")]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public IOPath Replace(string oldStr, string newStr) => new(Str.Replace(oldStr, newStr), true);
///<inheritdoc cref="string.IndexOf(char)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int IndexOf(char c) => Str.IndexOf(c);
///<inheritdoc cref="string.IndexOf(char,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int IndexOf(char c, int startIndex) => Str.IndexOf(c, startIndex);
///<inheritdoc cref="string.IndexOf(char,int,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int IndexOf(char c, int startIndex, int count) => Str.IndexOf(c, startIndex, count);
///<inheritdoc cref="string.IndexOf(string)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int IndexOf(string s) => Str.IndexOf(s, StringComparison.Ordinal);
///<inheritdoc cref="string.IndexOf(string,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int IndexOf(string s, int startIndex) => Str.IndexOf(s, startIndex, StringComparison.Ordinal);
///<inheritdoc cref="string.IndexOf(string,int,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int IndexOf(string s, int startIndex, int count) => Str.IndexOf(s, startIndex, count, StringComparison.Ordinal);
///<inheritdoc cref="string.IndexOf(string)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int IndexOf(IOPath p) => Str.IndexOf(p.Str, StringComparison.Ordinal);
///<inheritdoc cref="string.IndexOf(string,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int IndexOf(IOPath p, int startIndex) => Str.IndexOf(p.Str, startIndex, StringComparison.Ordinal);
///<inheritdoc cref="string.IndexOf(string,int,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int IndexOf(IOPath p, int startIndex, int count) => Str.IndexOf(p.Str, startIndex, count, StringComparison.Ordinal);
///<inheritdoc cref="string.LastIndexOf(char)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int LastIndexOf(char c) => Str.LastIndexOf(c);
///<inheritdoc cref="string.LastIndexOf(char,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int LastIndexOf(char c, int startLastIndex) => Str.LastIndexOf(c, startLastIndex);
///<inheritdoc cref="string.LastIndexOf(char,int,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int LastIndexOf(char c, int startLastIndex, int count) => Str.LastIndexOf(c, startLastIndex, count);
///<inheritdoc cref="string.LastIndexOf(string)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int LastIndexOf(string s) => Str.LastIndexOf(s, StringComparison.Ordinal);
///<inheritdoc cref="string.LastIndexOf(string,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int LastIndexOf(string s, int startLastIndex) => Str.LastIndexOf(s, startLastIndex, StringComparison.Ordinal);
///<inheritdoc cref="string.LastIndexOf(string,int,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int LastIndexOf(string s, int startLastIndex, int count) => Str.LastIndexOf(s, startLastIndex, count, StringComparison.Ordinal);
///<inheritdoc cref="string.LastIndexOf(string)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int LastIndexOf(IOPath p) => Str.LastIndexOf(p.Str, StringComparison.Ordinal);
///<inheritdoc cref="string.LastIndexOf(string,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int LastIndexOf(IOPath p, int startLastIndex) => Str.LastIndexOf(p.Str, startLastIndex, StringComparison.Ordinal);
///<inheritdoc cref="string.LastIndexOf(string,int,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int LastIndexOf(IOPath p, int startLastIndex, int count) => Str.LastIndexOf(p.Str, startLastIndex, count, StringComparison.Ordinal);
}

144
DTLib/Filesystem/Path.cs
View File

@ -1,73 +1,32 @@
#if NETSTANDARD2_1 || NET6_0 || NET7_0 || NET8_0
#define USE_SPAN
#endif
using System.Runtime.CompilerServices;
namespace DTLib.Filesystem;
public static class Path
{
public static readonly char Sep = Environment.OSVersion.Platform == PlatformID.Win32NT ? '\\' : '/';
private static readonly char NotSep = Environment.OSVersion.Platform == PlatformID.Win32NT ? '/' : '\\' ;
public static readonly char NotSep = Environment.OSVersion.Platform == PlatformID.Win32NT ? '/' : '\\' ;
/// does not correct separators, use Resolve for correction
/// <see cref="Resolve(string[])"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static string Concat(string path, string addition)
{
if (!path.EndsWith(Sep) && !addition.StartsWith(Sep))
path += Sep;
return path + addition;
}
/// <inheritdoc cref="Concat(string,string)"/>
public static string Concat(params string[] parts)
{
StringBuilder builder = new StringBuilder();
builder.Append(parts[0]);
for (int i = 1; i < parts.Length; i++)
{
char lastC = builder[builder.Length - 1];
if(lastC!=Sep && lastC!=NotSep)
builder.Append(Sep);
builder.Append(parts[i]);
}
return builder.ToString();
}
public static string FixSeparators(string path)
{
var chars = path.ToCharArray();
int length = path.Length;
for(int i=0; i<length; i++)
if (chars[i] == NotSep)
chars[i] = Sep;
return new string(chars);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static string Resolve(params string[] parts) => FixSeparators(Concat(parts));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static string Resolve(string path, string addition) => FixSeparators(Concat(path, addition));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ThrowIfEscapes(string path)
public static void ThrowIfEscapes(this IOPath path)
{
if (path.Contains(".."))
if (path.Str.Contains(".."))
throw new Exception($"path <{path}> uses <..>, that's not allowed");
}
/// Replaces restricted characters in string
public static string CorrectString(string str)
public static IOPath ReplaceRestrictedChars(string str)
{
#if NETSTANDARD2_1 || NET6_0 || NET7_0 || NET8_0
var a = str.AsSpan();
#else
var a = str.ToArray();
#endif
char[] r = new char[a.Length];
for (int i = 0; i < a.Length; i++)
char[] r = str.ToCharArray();
for (int i = 0; i < str.Length; i++)
{
switch (a[i])
switch (r[i])
{
case '/': case '\\':
case ':': case ';':
@ -82,44 +41,93 @@ public static class Path
case '`': case '|': case '=':
r[i] = '_';
break;
default:
r[i] = a[i];
break;
}
}
return new string(r);
return new IOPath(r);
}
public static string FileName(string path, bool separatorsFixed)
#if !USE_SPAN
private static unsafe void CopyTo(this string s, char* b)
{
for (int i = 0; i < s.Length; i++)
b[i] = s[i];
}
#endif
public static IOPath Concat(params IOPath[] parts)
{
#if USE_SPAN
Span<bool>
#else
unsafe
{
bool*
#endif
needSeparator = stackalloc bool[parts.Length-1];
int lengthSum = 0;
for (int i = 0; i < parts.Length-1; i++)
{
lengthSum += parts[i].Length;
if (!parts[i].Str.EndsWith(Sep) && !parts[i + 1].Str.StartsWith(Sep))
{
needSeparator[i] = true;
lengthSum++;
}
else needSeparator[i] = false;
}
lengthSum += parts[parts.Length-1].Length;
#if USE_SPAN
Span<char>
#else
char*
#endif
buffer = stackalloc char[lengthSum];
parts[0].Str.CopyTo(buffer);
int copiedChars = parts[0].Length;
for (int i = 1; i < parts.Length; i++)
{
if (needSeparator[i-1])
buffer[copiedChars++] = Sep;
#if USE_SPAN
parts[i].Str.CopyTo(buffer.Slice(copiedChars));
#else
parts[i].Str.CopyTo(buffer+copiedChars);
#endif
copiedChars += parts[i].Length;
}
return new IOPath(new string(buffer), true);
#if !USE_SPAN
}
#endif
}
public static IOPath FileName(this IOPath path)
{
if(!separatorsFixed)
path = FixSeparators(path);
int i = path.LastIndexOf(Sep);
if (i == -1) return path;
return path.Substring(i+1);
}
public static string Extension(string path)
public static IOPath Extension(this IOPath path)
{
int i = path.LastIndexOf('.');
if (i == -1) return FileName(path);
return path.Substring(i + 1);
}
public static string ParentDir(string path, bool separatorsFixed)
public static IOPath ParentDir(this IOPath path)
{
if(!separatorsFixed)
path = FixSeparators(path);
int i = path.LastIndexOf(Sep);
if (i == path.Length - 1) // ends with separator
i = path.LastIndexOf(Sep, 0, i);
i = path.LastIndexOf(Sep, i-1);
if (i == -1) // no parent dir
return $".{Sep}";
return path.Substring(0, i);
return path.Remove(i+1);
}
public static string ReplaceBase(string path, string baseDir, string otherDir)
public static IOPath ReplaceBase(this IOPath path, IOPath baseDir, IOPath otherDir)
{
if (!path.StartsWith(baseDir))
throw new Exception($"path <{path}> doesnt starts with <{baseDir}");