Introduce PetroglyphFileSystem abstraction for cross-platform filesystem operations.

Author: AnakinRaW

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem/AssemblyAttributes.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly:InternalsVisibleTo("PG.StarWarsGame.Engine")]

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem/IO/PetroglyphFileSystem.CombineJoin.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Runtime.InteropServices;
+using PG.StarWarsGame.Engine.Utilities;
+
+namespace PG.StarWarsGame.Engine.IO;
+
+public sealed partial class PetroglyphFileSystem
+{
+    public string CombinePath(string pathA, string pathB)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) 
+            return _underlyingFileSystem.Path.Combine(pathA, pathB);
+        
+        if (pathA == null)
+            throw new ArgumentNullException(nameof(pathA));
+        if (pathB == null)
+            throw new ArgumentNullException(nameof(pathB));
+        return CombineInternal(pathA, pathB);
+    }
+    
+    internal void JoinPath(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ref ValueStringBuilder stringBuilder)
+    {
+        if (path1.Length == 0 && path2.Length == 0)
+            return;
+
+        if (path1.Length == 0 || path2.Length == 0)
+        {
+            ref var pathToUse = ref path1.Length == 0 ? ref path2 : ref path1;
+            stringBuilder.Append(pathToUse);
+            return;
+        }
+
+        stringBuilder.Append(path1);
+        
+        var hasSeparator = IsDirectorySeparator(path1[path1.Length - 1]) || IsDirectorySeparator(path2[0]);
+        if (!hasSeparator)
+            stringBuilder.Append(_underlyingFileSystem.Path.DirectorySeparatorChar);
+        
+        stringBuilder.Append(path2);
+    }
+    
+    private string CombineInternal(string first, string second)
+    {
+        if (string.IsNullOrEmpty(first))
+            return second;
+
+        if (string.IsNullOrEmpty(second))
+            return first;
+
+        if (IsPathRooted(second.AsSpan()))
+            return second;
+
+        return JoinInternal(first, second);
+    }
+
+    private string JoinInternal(string first, string second)
+    {
+        var hasSeparator = IsDirectorySeparator(first[first.Length - 1]) || IsDirectorySeparator(second[0]);
+        return hasSeparator
+            ? string.Concat(first, second)
+            : string.Concat(first, _underlyingFileSystem.Path.DirectorySeparatorChar, second);
+    }
+}

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem/IO/PetroglyphFileSystem.Exist.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using AnakinRaW.CommonUtilities.FileSystem;
+using PG.StarWarsGame.Engine.Utilities;
+#if NETSTANDARD2_1 || NET
+using System.Diagnostics.CodeAnalysis;
+#endif
+
+namespace PG.StarWarsGame.Engine.IO;
+
+public sealed partial class PetroglyphFileSystem
+{
+    internal bool FileExists(
+        ReadOnlySpan<char> filePath, 
+        ref ValueStringBuilder stringBuilder,
+        ReadOnlySpan<char> gameDirectory)
+    {
+        stringBuilder.Length = 0;
+
+        if (IsPathFullyQualified_Exists(filePath))
+            stringBuilder.Append(filePath);
+        else
+            JoinPath(gameDirectory, filePath, ref stringBuilder);
+        
+        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            NormalizePath(ref stringBuilder);
+            
+            var actualFilePath = stringBuilder.AsSpan();
+            return FileExistsCaseInsensitive(actualFilePath, ref stringBuilder);
+        }
+
+        // We *could* also use the slightly faster GetFileAttributesA.
+        // However, CreateFileA and GetFileAttributesA are implemented complete independent.
+        // The game uses CreateFileA.
+        // Thus, we should stick to what the game uses in order to be as close to the engine as possible
+        // NB: It's also important that the string builder is zero-terminated, as otherwise CreateFileA might get invalid data.
+        var fileHandle = CreateFile(
+            in stringBuilder.GetPinnableReference(true),
+            FileAccess.Read,
+            FileShare.Read,
+            IntPtr.Zero,
+            FileMode.Open,
+            FileAttributes.Normal, IntPtr.Zero);
+            
+        return IsValidAndClose(fileHandle);
+    }
+    
+    // NB: This method assumes backslashes have been normalized to forward slashes
+    // NB: This method operates on the actual file system
+    private bool FileExistsCaseInsensitive(ReadOnlySpan<char> filePath, ref ValueStringBuilder stringBuilder)
+    {
+        Debug.Assert(!RuntimeInformation.IsOSPlatform(OSPlatform.Windows));
+        
+        var pathString = filePath.ToString();
+        if (_underlyingFileSystem.File.Exists(pathString))
+            return true;
+
+        var directory = _underlyingFileSystem.Path.GetDirectoryName(pathString);
+        var fileName = _underlyingFileSystem.Path.GetFileName(pathString);
+
+        if (string.IsNullOrEmpty(directory) || string.IsNullOrEmpty(fileName))
+            return false;
+
+        if (!_underlyingFileSystem.Directory.Exists(directory))
+        {
+            if (!FileExistsCaseInsensitive(directory.AsSpan(), ref stringBuilder))
+                return false;
+
+            directory = stringBuilder.AsSpan().ToString();
+        }
+
+        var files = _underlyingFileSystem.Directory.GetFiles(directory);
+        var directories = _underlyingFileSystem.Directory.GetDirectories(directory);
+
+        foreach (var file in files)
+        {
+            var name = _underlyingFileSystem.Path.GetFileName(file);
+            if (name.Equals(fileName, StringComparison.OrdinalIgnoreCase))
+            {
+                stringBuilder.Length = 0;
+                stringBuilder.Append(file);
+                return true;
+            }
+        }
+
+        foreach (var dir in directories)
+        {
+            var name = _underlyingFileSystem.Path.GetFileName(dir);
+            if (name.Equals(fileName, StringComparison.OrdinalIgnoreCase))
+            {
+                stringBuilder.Length = 0;
+                stringBuilder.Append(dir);
+                return true;
+            }
+        }
+
+        return false;
+    }
+    
+    private bool IsPathFullyQualified_Exists(ReadOnlySpan<char> path)
+    {
+        // This is really tricky, because under Windows "/" or "\" do NOT
+        // indicate a fully qualified path, under Linux however "/" does. 
+        // The PGFileSystem is implemented to treat backslashes as directory separators.
+        // However, this must not happen here, since we are operating on the actual file system.
+        // E.g, \\Data\\Art\\... MUST not be treated as a fully qualified path
+        // This means, ultimately, we can just delegate to the underlying file system.
+
+        return _underlyingFileSystem.Path.IsPathFullyQualified(path);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool IsValidAndClose(IntPtr handle)
+    {
+        var isValid = handle != IntPtr.Zero && handle != new IntPtr(-1);
+        if (isValid)
+            CloseHandle(handle);
+        return isValid;
+    }
+
+    [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+    private static extern IntPtr CreateFile(
+        in char lpFileName,
+        [MarshalAs(UnmanagedType.U4)] FileAccess access,
+        [MarshalAs(UnmanagedType.U4)] FileShare share,
+        IntPtr securityAttributes,
+        [MarshalAs(UnmanagedType.U4)] FileMode creationDisposition,
+        [MarshalAs(UnmanagedType.U4)] FileAttributes flagsAndAttributes,
+        IntPtr templateFile);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool CloseHandle(IntPtr hObject);
+}

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem/IO/PetroglyphFileSystem.Names.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Runtime.InteropServices;
+using AnakinRaW.CommonUtilities.FileSystem;
+#if NETSTANDARD2_1 || NET
+using System.Diagnostics.CodeAnalysis;
+#endif
+
+namespace PG.StarWarsGame.Engine.IO;
+
+public sealed partial class PetroglyphFileSystem
+{
+    
+#if NETSTANDARD2_1 || NET
+    [return: NotNullIfNotNull(nameof(path))]
+#endif
+    public string? GetFileName(string? path)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            return _underlyingFileSystem.Path.GetFileName(path);
+        
+        if (path == null)
+            return null;
+        var result = GetFileName(path.AsSpan());
+        if (path.Length == result.Length)
+            return path;
+        return result.ToString();
+    }
+
+    public ReadOnlySpan<char> GetFileName(ReadOnlySpan<char> path)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) 
+            return _underlyingFileSystem.Path.GetFileName(path);
+        
+        var root = GetPathRoot(path).Length;
+        var i = path.LastIndexOfAny(DirectorySeparatorChar, AltDirectorySeparatorChar);
+        return path.Slice(i < root ? root : i + 1);
+    }
+
+#if NETSTANDARD2_1 || NET
+    [return: NotNullIfNotNull(nameof(path))]
+#endif
+    public string? GetFileNameWithoutExtension(string? path)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            return _underlyingFileSystem.Path.GetFileNameWithoutExtension(path);
+
+        if (path == null)
+            return null;
+
+        var result = GetFileNameWithoutExtension(path.AsSpan());
+        return path.Length == result.Length
+            ? path
+            : result.ToString();
+    }
+
+    public ReadOnlySpan<char> GetFileNameWithoutExtension(ReadOnlySpan<char> path)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            return _underlyingFileSystem.Path.GetFileNameWithoutExtension(path);
+        var fileName = GetFileName(path);
+        var lastPeriod = fileName.LastIndexOf('.');
+        return lastPeriod < 0
+            ? fileName
+            : // No extension was found
+            fileName.Slice(0, lastPeriod);
+    }
+
+#if NETSTANDARD2_1 || NET
+    [return: NotNullIfNotNull(nameof(path))]
+#endif
+    public string? ChangeExtension(string? path, string? extension)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            return _underlyingFileSystem.Path.ChangeExtension(path, extension);
+
+        if (path == null)
+            return null;
+
+        var subLength = path.Length;
+        if (subLength == 0)
+            return string.Empty;
+
+        for (var i = path.Length - 1; i >= 0; i--)
+        {
+            var ch = path[i];
+
+            if (ch == '.')
+            {
+                subLength = i;
+                break;
+            }
+
+            if (IsDirectorySeparator(ch))
+                break;
+        }
+
+        if (extension == null)
+            return path.Substring(0, subLength);
+
+#if NETCOREAPP3_0_OR_GREATER
+        var subpath = path.AsSpan(0, subLength);
+        return extension.StartsWith('.') ?
+            string.Concat(subpath, extension) :
+            string.Concat(subpath, ".", extension);
+#else
+        var subPath = path.Substring(0, subLength);
+        if (extension.Length >= 1 && extension[0] == '.')
+            return string.Concat(subPath, extension);
+        return string.Concat(subPath, ".", extension);
+#endif
+    }
+    
+    public ReadOnlySpan<char> GetDirectoryName(ReadOnlySpan<char> path)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            return _underlyingFileSystem.Path.GetDirectoryName(path);
+        
+        if (IsEffectivelyEmpty(path))
+            return ReadOnlySpan<char>.Empty;
+
+        var end = GetDirectoryNameOffset(path);
+        return end >= 0 ? path.Slice(0, end) : ReadOnlySpan<char>.Empty;
+    }
+    
+    private static int GetDirectoryNameOffset(ReadOnlySpan<char> path)
+    {
+        var rootLength = GetRootLength(path);
+        var end = path.Length;
+        if (end <= rootLength)
+            return -1;
+
+        while (end > rootLength && !IsDirectorySeparator(path[--end])) ;
+
+        // Trim off any remaining separators (to deal with C:\foo\\bar)
+        while (end > rootLength && IsDirectorySeparator(path[end - 1]))
+            end--;
+
+        return end;
+    }
+}

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem/IO/PetroglyphFileSystem.Normalize.cs

@@ -0,0 +1,39 @@
+using System;
+using System.IO;
+using System.IO.Abstractions;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Microsoft.Extensions.DependencyInjection;
+using PG.StarWarsGame.Engine.Utilities;
+
+namespace PG.StarWarsGame.Engine.IO;
+
+public sealed partial class PetroglyphFileSystem
+{
+    internal void NormalizePath(ref ValueStringBuilder stringBuilder)
+    {
+        stringBuilder.Length = NormalizePath(stringBuilder.RawChars.Slice(0, stringBuilder.Length));
+    }
+    
+    // TODO: Check whether we can eliminate the double slash normalization
+    // once we migrated to PGFileSystem
+    private static int NormalizePath(Span<char> path)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            return path.Length;
+
+        var writePos = 0;
+        var lastWasSeparator = false;
+        for (var i = 0; i < path.Length; i++)
+        {
+            var c = path[i];
+            var isSeparator = c is '\\' or '/';
+            if (isSeparator && lastWasSeparator)
+                continue;
+            path[writePos++] = isSeparator ? '/' : c;
+            lastWasSeparator = isSeparator;
+        }
+
+        return writePos;
+    } 
+}