Resource Manager impl

Hypercube.Shared/Resources/Manager/IResourceManager.cs

@@ -0,0 +1,6 @@
+namespace Hypercube.Shared.Resources.Manager;
+
+public class IResourceManager
+{
+
+}

Hypercube.Shared/Resources/Manager/ResourceManager.cs

@@ -0,0 +1,6 @@
+namespace Hypercube.Shared.Resources.Manager;
+
+public class ResourceManager : IResourceManager
+{
+
+}

Hypercube.Shared/Resources/ResourcePath.cs

@@ -0,0 +1,143 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Hypercube.Shared.Resources;
+
+public struct ResourcePath
+{
+    public const char Separator = '/';
+    public const string SeparatorStr = "/";
+    public const char WinSeparator = '\\';
+    public const string WinSeparatorStr = @"\";
+
+    public static readonly ResourcePath Self = ".";
+
+
+    public ResourcePath(string path)
+    {
+        if (OperatingSystem.IsWindows())
+        {
+            Path = path.Replace('\\', '/');
+            return;
+        }
+
+        Path = path;
+    }
+
+    public readonly string Path { get; }
+
+    public bool Rooted => Path.Length > 0 && Path[0] == Separator;
+    public bool Relative => !Rooted;
+    public bool IsSelf => Path == Self.Path;
+
+    public string FilenameWithExt
+    {
+        get
+        {
+            var sepIndex = Path.LastIndexOf('/') + 1;
+            return sepIndex == -1 ? "" : Path[sepIndex..];
+        }
+    }
+
+    public string Extension
+    {
+        get
+        {
+            var filename = FilenameWithExt;
+
+            var ind = filename.LastIndexOf('.');
+            return ind <= 1
+                ? string.Empty
+                : filename[ind..];
+        }
+    }
+
+    public string Filename
+    {
+        get
+        {
+            var filename = FilenameWithExt;
+
+            var ind = filename.LastIndexOf('.');
+            return ind <= 0
+                ? filename
+                : filename[..ind];
+        }
+    }
+
+    public ResourcePath ParentDirectory
+    {
+        get
+        {
+            if (IsSelf)
+            {
+                return Self;
+            }
+
+            var idx = Path.Length > 1 && Path[^1] == '/'
+                ? Path[..^1].LastIndexOf('/')
+                : Path.LastIndexOf('/');
+
+            return idx switch
+            {
+                -1 => Self,
+                0 => new ResourcePath(Path[..1]),
+                _ => new ResourcePath(Path[..idx])
+            };
+        }
+    }
+
+    public static implicit operator ResourcePath(string path)
+    {
+        return new ResourcePath(path);
+    }
+
+    public static ResourcePath operator +(ResourcePath l, ResourcePath r)
+    {
+        if (r.IsSelf)
+            return l;
+        if (r.Rooted)
+            return r;
+        if (l.Path == "")
+            return new ResourcePath("/" + r.Path);
+
+        if (l.Path.EndsWith("/"))
+        {
+            return new ResourcePath(l.Path + r.Path);
+        }
+
+        return new ResourcePath(l.Path + "/" + r.Path);
+    }
+
+    public static bool Equals(ResourcePath a, ResourcePath b)
+    {
+        return a.Path == b.Path;
+    }
+
+    public bool Equals(ResourcePath b)
+    {
+        return Path == b.Path;
+    }
+
+    public override bool Equals(object? other)
+    {
+        if (other is null || other is not ResourcePath b)
+            return false;
+
+        return Path == b.Path;
+    }
+
+    public override int GetHashCode()
+    {
+        return Path.GetHashCode();
+    }
+
+    public static bool operator ==(ResourcePath a, ResourcePath b)
+    {
+        return a.Equals(b);
+    }
+
+    public static bool operator !=(ResourcePath a, ResourcePath b)
+    {
+        return !a.Equals(b);
+    }
+}

Hypercube.UnitTests/Hypercube.UnitTests.csproj

@@ -19,6 +19,7 @@
 
     <ItemGroup>
       <ProjectReference Include="..\Hypercube.Shared.Math\Hypercube.Shared.Math.csproj" />
+      <ProjectReference Include="..\Hypercube.Shared\Hypercube.Shared.csproj" />
     </ItemGroup>
 
 </Project>

Hypercube.UnitTests/ResourceManager/ResourcePathTest.cs

@@ -0,0 +1,56 @@
+using Hypercube.Shared.Resources;
+
+namespace Hypercube.UnitTests.ResourceManager;
+
+public class ResourcePathTest
+{
+    [Test]
+    public void GetFilenameTest()
+    {
+        var resPath = new ResourcePath("/Rooted/path.txt");
+        Assert.That(resPath.Filename == "path");
+
+        Assert.Pass($"ResPath file name is {resPath.Filename}");
+    }
+
+    [Test]
+    public void GetExtensionTest()
+    {
+        var resPath = new ResourcePath("/Rooted/path.txt");
+        Assert.That(resPath.Extension == ".txt");
+        Assert.Pass($"ResPath ext is {resPath.Extension}");
+    }
+
+    [Test]
+    public void RootedTest()
+    {
+        var resPath = new ResourcePath("/Rooted/path.txt");
+        Assert.That(resPath.Rooted);
+        Assert.Pass("Res path is rooted");
+    }
+
+    [Test]
+    public void PathConcatTest()
+    {
+        var resPath = new ResourcePath("/Rooted/");
+        var resPath2 = new ResourcePath("path.txt");
+
+        var concated = resPath + resPath2;
+        Assert.That(concated.Path == "/Rooted/path.txt");
+
+        Assert.Pass($"Concatenated path is equal to {concated.Path}");
+    }
+
+    [Test]
+    public void PathEqualityTest()
+    {
+        var resPath = new ResourcePath("/Rooted/");
+        var resPath2 = new ResourcePath("/Rooted/");
+        var resPath3 = new ResourcePath("path.txt");
+
+        Assert.That(resPath != resPath3);
+        Assert.That(resPath == resPath2);
+
+        Assert.Pass("Passed equality test");
+    }
+}