Add TruncatedSubStorage

src/LibHac/Fs/SubStorage.cs

@@ -6,11 +6,38 @@ namespace LibHac.Fs
     public class SubStorage : IStorage
     {
         private ReferenceCountedDisposable<IStorage> SharedBaseStorage { get; set; }
-        private IStorage BaseStorage { get; }
-        private long Offset { get; }
+        protected IStorage BaseStorage { get; private set; }
+        private long Offset { get; set; }
         private long Size { get; set; }
         private bool IsResizable { get; set; }
 
+        public SubStorage()
+        {
+            BaseStorage = null;
+            Offset = 0;
+            Size = 0;
+            IsResizable = false;
+        }
+
+        public SubStorage(SubStorage other)
+        {
+            BaseStorage = other.BaseStorage;
+            Offset = other.Offset;
+            Size = other.Size;
+            IsResizable = other.IsResizable;
+        }
+
+        public void InitializeFrom(SubStorage other)
+        {
+            if (this != other)
+            {
+                BaseStorage = other.BaseStorage;
+                Offset = other.Offset;
+                Size = other.Size;
+                IsResizable = other.IsResizable;
+            }
+        }
+
         public SubStorage(IStorage baseStorage, long offset, long size)
         {
             BaseStorage = baseStorage;

src/LibHac/FsSystem/TruncatedSubStorage.cs

@@ -0,0 +1,39 @@
+using System;
+using LibHac.Fs;
+
+namespace LibHac.FsSystem
+{
+    public class TruncatedSubStorage : SubStorage
+    {
+        public TruncatedSubStorage() { }
+        public TruncatedSubStorage(SubStorage other) : base(other) { }
+
+        protected override Result DoRead(long offset, Span<byte> destination)
+        {
+            if (destination.Length == 0)
+                return Result.Success;
+
+            Result rc = BaseStorage.GetSize(out long baseStorageSize);
+            if (rc.IsFailure()) return rc;
+
+            long availableSize = baseStorageSize - offset;
+            long sizeToRead = Math.Min(destination.Length, availableSize);
+
+            return base.DoRead(offset, destination.Slice(0, (int)sizeToRead));
+        }
+
+        protected override Result DoWrite(long offset, ReadOnlySpan<byte> source)
+        {
+            if (source.Length == 0)
+                return Result.Success;
+
+            Result rc = BaseStorage.GetSize(out long baseStorageSize);
+            if (rc.IsFailure()) return rc;
+
+            long availableSize = baseStorageSize - offset;
+            long sizeToWrite = Math.Min(source.Length, availableSize);
+
+            return base.DoWrite(offset, source.Slice(0, (int)sizeToWrite));
+        }
+    }
+}