Implemented GetPositionInBaseStream

Library/DiscUtils.Ntfs/Internals/WofStream.cs

@@ -146,7 +146,7 @@ public override int Read(Span<byte> buffer)
     {
         if ((Position & (maxChunkSize - 1)) != 0)
         {
-            throw new ArgumentOutOfRangeException("Read not aligned to compression chunks");
+            throw new InvalidOperationException("Read not aligned to compression chunks");
         }
 
         var total = 0;
@@ -175,7 +175,7 @@ public override async ValueTask<int> ReadAsync(Memory<byte> buffer, Cancellation
     {
         if ((Position & (maxChunkSize - 1)) != 0)
         {
-            throw new ArgumentOutOfRangeException("Read not aligned to compression chunks");
+            throw new InvalidOperationException("Read not aligned to compression chunks");
         }
 
         var total = 0;
@@ -204,7 +204,7 @@ public override int Read(byte[] buffer, int offset, int count)
     {
         if ((Position & (maxChunkSize - 1)) != 0)
         {
-            throw new ArgumentOutOfRangeException("Read not aligned to compression chunks");
+            throw new InvalidOperationException("Read not aligned to compression chunks");
         }
 
         var total = 0;

Library/DiscUtils.Streams/Block/BlockCacheStream.cs

@@ -822,10 +822,14 @@ protected override void Dispose(bool disposing)
 
     private void CheckDisposed()
     {
+#if NET7_0_OR_GREATER
+        ObjectDisposedException.ThrowIf(_wrappedStream is null, this);
+#else
         if (_wrappedStream == null)
         {
             throw new ObjectDisposedException("BlockCacheStream");
         }
+#endif
     }
 
     private void InvalidateBlocks(long firstBlock, int numBlocks)

Library/DiscUtils.Streams/ConcatStream.cs

@@ -82,25 +82,38 @@ public override bool CanWrite
         }
     }
 
+    public override long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+    {
+        if (ReferenceEquals(baseStream, this))
+        {
+            return virtualPosition;
+        }
+
+        var activeStreamIndex = GetStream(virtualPosition, out var activeStreamStartPos);
+
+        var activeStream = _streams[activeStreamIndex];
+
+        var basePosition = virtualPosition - activeStreamStartPos;
+
+        return activeStream.GetPositionInBaseStream(baseStream, basePosition);
+    }
+
     public override IEnumerable<StreamExtent> Extents
     {
         get
         {
             CheckDisposed();
-            var extents = new List<StreamExtent>();
 
             long pos = 0;
             for (var i = 0; i < _streams.Count; ++i)
             {
                 foreach (var extent in _streams[i].Extents)
                 {
-                    extents.Add(new StreamExtent(extent.Start + pos, extent.Length));
+                    yield return new StreamExtent(extent.Start + pos, extent.Length);
                 }
 
                 pos += _streams[i].Length;
             }
-
-            return extents;
         }
     }
 
@@ -388,9 +401,13 @@ private int GetStream(long targetPos, out long streamStartPos)
 
     private void CheckDisposed()
     {
+#if NET7_0_OR_GREATER
+        ObjectDisposedException.ThrowIf(_streams is null, this);
+#else
         if (_streams == null)
         {
             throw new ObjectDisposedException("ConcatStream");
         }
+#endif
     }
 }

Library/DiscUtils.Streams/MirrorStream.cs

@@ -20,6 +20,7 @@
 // DEALINGS IN THE SOFTWARE.
 //
 
+using DiscUtils.Streams.Compatibility;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -63,6 +64,16 @@ public MirrorStream(Ownership ownsWrapped, IEnumerable<SparseStream> wrapped)
         }
     }
 
+    public override long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+    {
+        if (ReferenceEquals(baseStream, this))
+        {
+            return virtualPosition;
+        }
+
+        return _wrapped[0].GetPositionInBaseStream(baseStream, virtualPosition);
+    }
+
     public override bool CanRead => _canRead;
 
     public override bool CanSeek => _canSeek;

Library/DiscUtils.Streams/SnapshotStream.cs

@@ -77,6 +77,17 @@ public SnapshotStream(Stream baseStream, Ownership owns)
         _diffExtents = [];
     }
 
+    public override long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+    {
+        if (ReferenceEquals(baseStream, this)
+            || _baseStream is not CompatibilityStream baseCompatStream)
+        {
+            return virtualPosition;
+        }
+
+        return baseCompatStream.GetPositionInBaseStream(baseStream, virtualPosition);
+    }
+
     /// <summary>
     /// Gets an indication as to whether the stream can be read.
     /// </summary>

Library/DiscUtils.Streams/SparseStream.cs

@@ -178,6 +178,16 @@ public SparseReadOnlyWrapperStream(SparseStream wrapped, Ownership ownsWrapped)
             _ownsWrapped = ownsWrapped;
         }
 
+        public override long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+        {
+            if (ReferenceEquals(baseStream, this))
+            {
+                return virtualPosition;
+            }
+
+            return _wrapped.GetPositionInBaseStream(baseStream, virtualPosition);
+        }
+
         public override bool CanRead
         {
             get
@@ -331,6 +341,16 @@ public SparseWrapperStream(Stream wrapped, Ownership ownsWrapped, IEnumerable<St
             }
         }
 
+        public override long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+        {
+            if (ReferenceEquals(baseStream, this))
+            {
+                return virtualPosition;
+            }
+
+            return _wrapped.GetPositionInBaseStream(baseStream, virtualPosition);
+        }
+
         public override bool CanRead
         {
             get

Library/DiscUtils.Streams/StripedStream.cs

@@ -69,6 +69,26 @@ public StripedStream(long stripeSize, Ownership ownsWrapped, IEnumerable<SparseS
         _length = subStreamLength * _wrapped.Count;
     }
 
+    public override long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+    {
+        if (ReferenceEquals(baseStream, this))
+        {
+            return virtualPosition;
+        }
+
+        var stripe = virtualPosition / _stripeSize;
+        var stripeOffset = virtualPosition % _stripeSize;
+
+        var streamIdx = (int)(stripe % _wrapped.Count);
+        var streamStripe = stripe / _wrapped.Count;
+
+        var targetStream = _wrapped[streamIdx];
+
+        var targetStreamPosition = streamStripe * _stripeSize + stripeOffset;
+
+        return targetStream.GetPositionInBaseStream(baseStream, targetStreamPosition);
+    }
+
     public override bool CanRead => _canRead;
 
     public override bool CanSeek => true;
@@ -116,7 +136,7 @@ public override int Read(byte[] buffer, int offset, int count)
             var streamIdx = (int)(stripe % _wrapped.Count);
             var streamStripe = stripe / _wrapped.Count;
 
-            Stream targetStream = _wrapped[streamIdx];
+            var targetStream = _wrapped[streamIdx];
             targetStream.Position = streamStripe * _stripeSize + stripeOffset;
 
             var numRead = targetStream.Read(buffer, offset + totalRead, stripeToRead);
@@ -146,7 +166,7 @@ public override async ValueTask<int> ReadAsync(Memory<byte> buffer, Cancellation
             var streamIdx = (int)(stripe % _wrapped.Count);
             var streamStripe = stripe / _wrapped.Count;
 
-            Stream targetStream = _wrapped[streamIdx];
+            var targetStream = _wrapped[streamIdx];
             targetStream.Position = streamStripe * _stripeSize + stripeOffset;
 
             var numRead = await targetStream.ReadAsync(buffer.Slice(totalRead, stripeToRead), cancellationToken).ConfigureAwait(false);
@@ -238,7 +258,7 @@ public override void Write(byte[] buffer, int offset, int count)
             var streamIdx = (int)(stripe % _wrapped.Count);
             var streamStripe = stripe / _wrapped.Count;
 
-            Stream targetStream = _wrapped[streamIdx];
+            var targetStream = _wrapped[streamIdx];
             targetStream.Position = streamStripe * _stripeSize + stripeOffset;
             targetStream.Write(buffer, offset + totalWritten, stripeToWrite);
 
@@ -269,7 +289,7 @@ public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, Cancella
             var streamIdx = (int)(stripe % _wrapped.Count);
             var streamStripe = stripe / _wrapped.Count;
 
-            Stream targetStream = _wrapped[streamIdx];
+            var targetStream = _wrapped[streamIdx];
             targetStream.Position = streamStripe * _stripeSize + stripeOffset;
             await targetStream.WriteAsync(buffer.Slice(totalWritten, stripeToWrite), cancellationToken).ConfigureAwait(false);
 
@@ -300,7 +320,7 @@ public override void Write(ReadOnlySpan<byte> buffer)
             var streamIdx = (int)(stripe % _wrapped.Count);
             var streamStripe = stripe / _wrapped.Count;
 
-            Stream targetStream = _wrapped[streamIdx];
+            var targetStream = _wrapped[streamIdx];
             targetStream.Position = streamStripe * _stripeSize + stripeOffset;
             targetStream.Write(buffer.Slice(totalWritten, stripeToWrite));
 

Library/DiscUtils.Streams/SubStream.cs

@@ -85,6 +85,21 @@ public override IEnumerable<StreamExtent> Extents
         }
     }
 
+    public override long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+    {
+        if (ReferenceEquals(baseStream, this))
+        {
+            return virtualPosition;
+        }
+
+        if (_parent is CompatibilityStream baseCompatStream)
+        {
+            return baseCompatStream.GetPositionInBaseStream(baseStream, _first + virtualPosition);
+        }
+
+        return _first + virtualPosition;
+    }
+
     public override long Length => _length;
 
     public override long Position

Library/DiscUtils.Streams/ThreadSafeStream.cs

@@ -20,6 +20,7 @@
 // DEALINGS IN THE SOFTWARE.
 //
 
+using DiscUtils.Streams.Compatibility;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -87,10 +88,26 @@ public ThreadSafeStream(SparseStream toWrap, Ownership ownership)
     private ThreadSafeStream(ThreadSafeStream toClone)
     {
         _common = toClone._common;
+
+#if NET7_0_OR_GREATER
+        ObjectDisposedException.ThrowIf(_common is null, toClone);
+#else
         if (_common == null)
         {
             throw new ObjectDisposedException("toClone");
         }
+#endif
+    }
+
+    public override long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+    {
+        if (ReferenceEquals(baseStream, this)
+            || _common.WrappedStream is not CompatibilityStream baseCompatStream)
+        {
+            return virtualPosition;
+        }
+
+        return baseCompatStream.GetPositionInBaseStream(baseStream, virtualPosition);
     }
 
     /// <summary>
@@ -169,8 +186,12 @@ private SparseStream Wrapped
     {
         get
         {
-            var wrapped = _common.WrappedStream ?? throw new ObjectDisposedException("ThreadSafeStream");
-            return wrapped;
+#if NET7_0_OR_GREATER
+            ObjectDisposedException.ThrowIf(_common.WrappedStream is null, this);
+            return _common.WrappedStream;
+#else
+            return _common.WrappedStream ?? throw new ObjectDisposedException("ThreadSafeStream");
+#endif
         }
     }
 

Library/DiscUtils.Streams/Util/CompatExtensions.cs

@@ -13,6 +13,21 @@ namespace DiscUtils.Streams.Compatibility;
 
 public abstract class CompatibilityStream : Stream
 {
+    /// <summary>
+    /// In a derived class, get corresponding position in a base stream of this instance
+    /// to a position in this instance.
+    /// </summary>
+    public virtual long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+    {
+        if (baseStream is null
+            || ReferenceEquals(baseStream, this))
+        {
+            return virtualPosition;
+        }
+
+        return null;
+    }
+
     public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
     {
 #if NET6_0_OR_GREATER
@@ -241,5 +256,29 @@ public static void AppendData(this IncrementalHash hash, ReadOnlySpan<byte> data
     public static Task CopyToAsync(this Stream source, Stream target, CancellationToken cancellationToken)
         => source.CopyToAsync(target, bufferSize: 80 * 1024, cancellationToken);
 #endif
+
+    /// <summary>
+    /// If stream is derived from CompatibilityStream, get corresponding position in a base stream of this instance
+    /// to a position in this instance.
+    /// </summary>
+    public static long? GetPositionInBaseStream(this Stream stream, Stream baseStream, long virtualPosition)
+    {
+        if (ReferenceEquals(stream, baseStream))
+        {
+            return virtualPosition;
+        }
+
+        if (stream is CompatibilityStream compatBaseStream)
+        {
+            return compatBaseStream.GetPositionInBaseStream(baseStream, virtualPosition);
+        }
+
+        if (baseStream is null)
+        {
+            return virtualPosition;
+        }
+
+        return null;
+    }
 }
 

Library/DiscUtils.Streams/WrappingMappedStream.cs

@@ -54,6 +54,17 @@ public WrappingMappedStream(T toWrap, Ownership ownership, IEnumerable<StreamExt
         }
     }
 
+    public override long? GetPositionInBaseStream(Stream baseStream, long virtualPosition)
+    {
+        if (ReferenceEquals(baseStream, this)
+            || WrappedStream is not CompatibilityStream baseCompatStream)
+        {
+            return virtualPosition;
+        }
+
+        return baseCompatStream.GetPositionInBaseStream(baseStream, virtualPosition);
+    }
+
     public override bool CanRead => WrappedStream.CanRead;
 
     public override bool CanSeek => WrappedStream.CanSeek;