Merge branch '8-kaitaistreamasync-encapsulating-pipereader-should-implemement-advance' into 'master'

Resolve "KaitaiStreamAsync encapsulating pipereader should implemement Advance"

Closes kaitai-io#8

See merge request marta/kaitai_struct_csharp_runtime!18

Author: pluskal

Kaitai.Struct.Runtime.Async/KaitaiAsyncStream.cs

@@ -8,25 +8,25 @@ namespace Kaitai.Async
 {
   public class KaitaiAsyncStream : KaitaiStreamBase, IKaitaiAsyncStream
   {
-    private readonly IReaderContext _readerContext;
+    protected readonly IReaderContext ReaderContext;
     private ulong _bits;
     private int _bitsLeft;
 
     #region Constructors
 
     public KaitaiAsyncStream(IReaderContext readerContext)
     {
-      _readerContext = readerContext;
+      ReaderContext = readerContext;
     }
 
     public KaitaiAsyncStream(PipeReader pipeReader)
     {
-      _readerContext = new PipeReaderContext(pipeReader);
+      ReaderContext = new PipeReaderContext(pipeReader);
     }
 
     public KaitaiAsyncStream(Stream stream)
     {
-      _readerContext = new StreamReaderContext(stream);
+      ReaderContext = new StreamReaderContext(stream);
     }
 
     /// <summary>
@@ -51,18 +51,18 @@ public KaitaiAsyncStream(byte[] bytes) : this(new MemoryStream(bytes))
     #region Stream positioning
 
     public override bool IsEof =>
-      _readerContext.IsEofAsync().GetAwaiter().GetResult() && _bitsLeft == 0;
+      ReaderContext.IsEofAsync().GetAwaiter().GetResult() && _bitsLeft == 0;
 
-    public async ValueTask<bool> IsEofAsync() => await _readerContext.IsEofAsync() && _bitsLeft == 0;
+    public async ValueTask<bool> IsEofAsync() => await ReaderContext.IsEofAsync() && _bitsLeft == 0;
 
-    public ValueTask<long> GetSizeAsync() => _readerContext.GetSizeAsync();
+    public ValueTask<long> GetSizeAsync() => ReaderContext.GetSizeAsync();
 
-    public virtual async Task SeekAsync(long position) => await _readerContext.SeekAsync(position);
+    public virtual async Task SeekAsync(long position) => await ReaderContext.SeekAsync(position);
     public virtual async Task SeekAsync(ulong position) => await SeekAsync((long)position);
 
-    public override long Pos => _readerContext.Position;
+    public override long Pos => ReaderContext.Position;
 
-    public override long Size => _readerContext.GetSizeAsync().GetAwaiter().GetResult();
+    public override long Size => ReaderContext.GetSizeAsync().GetAwaiter().GetResult();
 
     #endregion
 
@@ -96,7 +96,7 @@ public KaitaiAsyncStream(byte[] bytes) : this(new MemoryStream(bytes))
 
     #region Unsigned
 
-    public async Task<byte> ReadU1Async() => await _readerContext.ReadByteAsync();
+    public async Task<byte> ReadU1Async() => await ReaderContext.ReadByteAsync();
 
     #region Big-endian
 
@@ -222,7 +222,7 @@ public async Task<ulong> ReadBitsIntLeAsync(int n)
 
     #region Byte arrays
 
-    public async Task<byte[]> ReadBytesAsync(long count) => await _readerContext.ReadBytesAsync(count);
+    public async Task<byte[]> ReadBytesAsync(long count) => await ReaderContext.ReadBytesAsync(count);
 
     public async Task<byte[]> ReadBytesAsync(ulong count)
     {
@@ -271,7 +271,7 @@ protected async Task<byte[]> ReadBytesNormalisedBigEndianAsync(int count)
     /// Read all the remaining bytes from the stream until the end is reached
     /// </summary>
     /// <returns></returns>
-    public virtual async Task<byte[]> ReadBytesFullAsync() => await _readerContext.ReadBytesFullAsync();
+    public virtual async Task<byte[]> ReadBytesFullAsync() => await ReaderContext.ReadBytesFullAsync();
 
     /// <summary>
     /// Read a terminated string from the stream

Kaitai.Struct.Runtime.Async/ReaderContext/PipeReaderContext.cs

@@ -6,42 +6,42 @@
 
 namespace Kaitai.Async
 {
-  internal class PipeReaderContext : IReaderContext
+  public class PipeReaderContext : IReaderContext
   {
-    private readonly PipeReader _pipeReader;
-    private ReadResult _readResult;
+    protected readonly PipeReader PipeReader;
+    protected ReadResult ReadResult;
 
     public PipeReaderContext(PipeReader pipeReader)
     {
-      _pipeReader = pipeReader;
+      PipeReader = pipeReader;
     }
 
-    private long RemainingBytesInReadResult => _readResult.Buffer.Length - Position;
+    protected long RemainingBytesInReadResult => ReadResult.Buffer.Length - Position;
 
-    public long Position { get; private set; }
+    public long Position { get; protected set; }
 
-    public async ValueTask<long> GetSizeAsync()
+    public virtual async ValueTask<long> GetSizeAsync()
     {
       await FillReadResultBufferToTheEnd();
 
-      return _readResult.Buffer.Length;
+      return ReadResult.Buffer.Length;
     }
 
-    public async ValueTask<bool> IsEofAsync()
+    public virtual async ValueTask<bool> IsEofAsync()
     {
       await EnsureReadResultIsNotDefault();
 
-      if (Position >= _readResult.Buffer.Length && !_readResult.IsCompleted)
+      if (Position >= ReadResult.Buffer.Length && !ReadResult.IsCompleted)
       {
-        _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.GetPosition(Position));
-        _readResult = await _pipeReader.ReadAsync();
+        PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.GetPosition(Position));
+        ReadResult = await PipeReader.ReadAsync();
       }
 
-      return Position >= _readResult.Buffer.Length && _readResult.IsCompleted;
+      return Position >= ReadResult.Buffer.Length && ReadResult.IsCompleted;
     }
 
 
-    public async ValueTask SeekAsync(long position)
+    public virtual async ValueTask SeekAsync(long position)
     {
       if (position <= Position)
       {
@@ -51,49 +51,49 @@ public async ValueTask SeekAsync(long position)
       {
         await EnsureReadResultIsNotDefault();
 
-        while (_readResult.Buffer.Length < position && !_readResult.IsCompleted)
+        while (ReadResult.Buffer.Length < position && !ReadResult.IsCompleted)
         {
-          _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.End);
-          _readResult = await _pipeReader.ReadAsync();
+          PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.End);
+          ReadResult = await PipeReader.ReadAsync();
         }
 
-        if (_readResult.Buffer.Length <= position)
+        if (ReadResult.Buffer.Length <= position)
         {
           Position = position;
           return;
         }
 
-        if (_readResult.IsCompleted)
+        if (ReadResult.IsCompleted)
         {
           throw new EndOfStreamException(
             $"requested {position} bytes, but got only {RemainingBytesInReadResult} bytes");
         }
       }
     }
 
-    public async ValueTask<byte> ReadByteAsync()
+    public virtual async ValueTask<byte> ReadByteAsync()
     {
       await EnsureReadResultIsNotDefault();
 
       var value = byte.MinValue;
-      while (!TryReadByte(out value) && !_readResult.IsCompleted)
+      while (!TryReadByte(out value) && !ReadResult.IsCompleted)
       {
-        _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.GetPosition(Position));
-        _readResult = await _pipeReader.ReadAsync();
+        PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.GetPosition(Position));
+        ReadResult = await PipeReader.ReadAsync();
       }
 
       Position += 1;
       return value;
 
       bool TryReadByte(out byte readValue)
       {
-        var sequenceReader = new SequenceReader<byte>(_readResult.Buffer);
+        var sequenceReader = new SequenceReader<byte>(ReadResult.Buffer);
         sequenceReader.Advance(Position);
         return sequenceReader.TryRead(out readValue);
       }
     }
 
-    public async ValueTask<byte[]> ReadBytesAsync(long count)
+    public virtual async ValueTask<byte[]> ReadBytesAsync(long count)
     {
       if (count < 0 || count > int.MaxValue)
       {
@@ -107,14 +107,14 @@ public async ValueTask<byte[]> ReadBytesAsync(long count)
 
       while (!TryRead(out value, count))
       {
-        if (_readResult.IsCompleted)
+        if (ReadResult.IsCompleted)
         {
           throw new EndOfStreamException(
             $"requested {count} bytes, but got only {RemainingBytesInReadResult} bytes");
         }
 
-        _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.GetPosition(Position));
-        _readResult = await _pipeReader.ReadAsync();
+        PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.GetPosition(Position));
+        ReadResult = await PipeReader.ReadAsync();
       }
 
       Position += count;
@@ -128,7 +128,7 @@ bool TryRead(out byte[] readBytes, long readBytesCount)
           return false;
         }
 
-        readBytes = _readResult.Buffer.Slice(Position, readBytesCount).ToArray();
+        readBytes = ReadResult.Buffer.Slice(Position, readBytesCount).ToArray();
         return true;
       }
     }
@@ -137,8 +137,8 @@ public virtual async ValueTask<byte[]> ReadBytesFullAsync()
     {
       await FillReadResultBufferToTheEnd();
 
-      _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.End);
-      var value = _readResult.Buffer.Slice(Position, _readResult.Buffer.End).ToArray();
+      PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.End);
+      var value = ReadResult.Buffer.Slice(Position, ReadResult.Buffer.End).ToArray();
       Position += value.Length;
       return value;
     }
@@ -147,18 +147,18 @@ private async ValueTask FillReadResultBufferToTheEnd()
     {
       await EnsureReadResultIsNotDefault();
 
-      while (!_readResult.IsCompleted)
+      while (!ReadResult.IsCompleted)
       {
-        _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.End);
-        _readResult = await _pipeReader.ReadAsync();
+        PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.End);
+        ReadResult = await PipeReader.ReadAsync();
       }
     }
 
     private async ValueTask EnsureReadResultIsNotDefault()
     {
-      if (_readResult.Equals(default(ReadResult)))
+      if (ReadResult.Equals(default(ReadResult)))
       {
-        _readResult = await _pipeReader.ReadAsync();
+        ReadResult = await PipeReader.ReadAsync();
       }
     }
   }

Kaitai.Struct.Runtime.Async/ReaderContext/StreamReaderContext.cs

@@ -5,32 +5,32 @@
 
 namespace Kaitai.Async
 {
-  internal class StreamReaderContext : IReaderContext
+  public class StreamReaderContext : IReaderContext
   {
     private readonly Stream _baseStream;
+    protected readonly AsyncBinaryReader AsyncBinaryReader;
 
     public StreamReaderContext(Stream stream)
     {
       _baseStream = stream;
       AsyncBinaryReader = new AsyncBinaryReader(_baseStream);
     }
 
-    protected AsyncBinaryReader AsyncBinaryReader { get; }
     public long Position => _baseStream.Position;
-    public ValueTask<long> GetSizeAsync() => new ValueTask<long>(_baseStream.Length);
+    public virtual ValueTask<long> GetSizeAsync() => new ValueTask<long>(_baseStream.Length);
 
-    public ValueTask<bool> IsEofAsync() =>
+    public virtual ValueTask<bool> IsEofAsync() =>
       new ValueTask<bool>(_baseStream.Position >= _baseStream.Length);
 
-    public ValueTask SeekAsync(long position)
+    public virtual ValueTask SeekAsync(long position)
     {
       _baseStream.Seek(position, SeekOrigin.Begin);
       return new ValueTask();
     }
 
-    public async ValueTask<byte> ReadByteAsync() => (byte) await AsyncBinaryReader.ReadSByteAsync();
+    public virtual async ValueTask<byte> ReadByteAsync() => (byte) await AsyncBinaryReader.ReadSByteAsync();
 
-    public async ValueTask<byte[]> ReadBytesAsync(long count)
+    public virtual async ValueTask<byte[]> ReadBytesAsync(long count)
     {
       if (count < 0 || count > int.MaxValue)
       {
@@ -47,7 +47,7 @@ public async ValueTask<byte[]> ReadBytesAsync(long count)
       return bytes;
     }
 
-    public async ValueTask<byte[]> ReadBytesFullAsync() =>
+    public virtual async ValueTask<byte[]> ReadBytesFullAsync() =>
       await ReadBytesAsync(_baseStream.Length - _baseStream.Position);
   }
 }