Allow extensibility in end-user code.

pluskal · pluskal · commit 80da927370db · 2020-07-17T10:37:48.000+02:00
diff --git a/Kaitai.Struct.Runtime.Async/KaitaiAsyncStream.cs b/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
diff --git a/Kaitai.Struct.Runtime.Async/ReaderContext/PipeReaderContext.cs b/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();
       }
     }
   }
diff --git a/Kaitai.Struct.Runtime.Async/ReaderContext/StreamReaderContext.cs b/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);
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -6,42 +6,42 @@`
`6`	`6`
`7`	`7`	`namespace Kaitai.Async`
`8`	`8`	`{`
`9`		`- internal class PipeReaderContext : IReaderContext`
	`9`	`+ public class PipeReaderContext : IReaderContext`
`10`	`10`	`{`
`11`		`- private readonly PipeReader _pipeReader;`
`12`		`- private ReadResult _readResult;`
	`11`	`+ protected readonly PipeReader PipeReader;`
	`12`	`+ protected ReadResult ReadResult;`
`13`	`13`
`14`	`14`	`public PipeReaderContext(PipeReader pipeReader)`
`15`	`15`	`{`
`16`		`- _pipeReader = pipeReader;`
	`16`	`+ PipeReader = pipeReader;`
`17`	`17`	`}`
`18`	`18`
`19`		`- private long RemainingBytesInReadResult => _readResult.Buffer.Length - Position;`
	`19`	`+ protected long RemainingBytesInReadResult => ReadResult.Buffer.Length - Position;`
`20`	`20`
`21`		`- public long Position { get; private set; }`
	`21`	`+ public long Position { get; protected set; }`
`22`	`22`
`23`		`- public async ValueTask<long> GetSizeAsync()`
	`23`	`+ public virtual async ValueTask<long> GetSizeAsync()`
`24`	`24`	`{`
`25`	`25`	`await FillReadResultBufferToTheEnd();`
`26`	`26`
`27`		`- return _readResult.Buffer.Length;`
	`27`	`+ return ReadResult.Buffer.Length;`
`28`	`28`	`}`
`29`	`29`
`30`		`- public async ValueTask<bool> IsEofAsync()`
	`30`	`+ public virtual async ValueTask<bool> IsEofAsync()`
`31`	`31`	`{`
`32`	`32`	`await EnsureReadResultIsNotDefault();`
`33`	`33`
`34`		`- if (Position >= _readResult.Buffer.Length && !_readResult.IsCompleted)`
	`34`	`+ if (Position >= ReadResult.Buffer.Length && !ReadResult.IsCompleted)`
`35`	`35`	`{`
`36`		`- _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.GetPosition(Position));`
`37`		`- _readResult = await _pipeReader.ReadAsync();`
	`36`	`+ PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.GetPosition(Position));`
	`37`	`+ ReadResult = await PipeReader.ReadAsync();`
`38`	`38`	`}`
`39`	`39`
`40`		`- return Position >= _readResult.Buffer.Length && _readResult.IsCompleted;`
	`40`	`+ return Position >= ReadResult.Buffer.Length && ReadResult.IsCompleted;`
`41`	`41`	`}`
`42`	`42`
`43`	`43`
`44`		`- public async ValueTask SeekAsync(long position)`
	`44`	`+ public virtual async ValueTask SeekAsync(long position)`
`45`	`45`	`{`
`46`	`46`	`if (position <= Position)`
`47`	`47`	`{`
`@@ -51,49 +51,49 @@ public async ValueTask SeekAsync(long position)`
`51`	`51`	`{`
`52`	`52`	`await EnsureReadResultIsNotDefault();`
`53`	`53`
`54`		`- while (_readResult.Buffer.Length < position && !_readResult.IsCompleted)`
	`54`	`+ while (ReadResult.Buffer.Length < position && !ReadResult.IsCompleted)`
`55`	`55`	`{`
`56`		`- _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.End);`
`57`		`- _readResult = await _pipeReader.ReadAsync();`
	`56`	`+ PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.End);`
	`57`	`+ ReadResult = await PipeReader.ReadAsync();`
`58`	`58`	`}`
`59`	`59`
`60`		`- if (_readResult.Buffer.Length <= position)`
	`60`	`+ if (ReadResult.Buffer.Length <= position)`
`61`	`61`	`{`
`62`	`62`	`Position = position;`
`63`	`63`	`return;`
`64`	`64`	`}`
`65`	`65`
`66`		`- if (_readResult.IsCompleted)`
	`66`	`+ if (ReadResult.IsCompleted)`
`67`	`67`	`{`
`68`	`68`	`throw new EndOfStreamException(`
`69`	`69`	`$"requested {position} bytes, but got only {RemainingBytesInReadResult} bytes");`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`		`- public async ValueTask<byte> ReadByteAsync()`
	`74`	`+ public virtual async ValueTask<byte> ReadByteAsync()`
`75`	`75`	`{`
`76`	`76`	`await EnsureReadResultIsNotDefault();`
`77`	`77`
`78`	`78`	`var value = byte.MinValue;`
`79`		`- while (!TryReadByte(out value) && !_readResult.IsCompleted)`
	`79`	`+ while (!TryReadByte(out value) && !ReadResult.IsCompleted)`
`80`	`80`	`{`
`81`		`- _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.GetPosition(Position));`
`82`		`- _readResult = await _pipeReader.ReadAsync();`
	`81`	`+ PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.GetPosition(Position));`
	`82`	`+ ReadResult = await PipeReader.ReadAsync();`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`Position += 1;`
`86`	`86`	`return value;`
`87`	`87`
`88`	`88`	`bool TryReadByte(out byte readValue)`
`89`	`89`	`{`
`90`		`- var sequenceReader = new SequenceReader<byte>(_readResult.Buffer);`
	`90`	`+ var sequenceReader = new SequenceReader<byte>(ReadResult.Buffer);`
`91`	`91`	`sequenceReader.Advance(Position);`
`92`	`92`	`return sequenceReader.TryRead(out readValue);`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`96`		`- public async ValueTask<byte[]> ReadBytesAsync(long count)`
	`96`	`+ public virtual async ValueTask<byte[]> ReadBytesAsync(long count)`
`97`	`97`	`{`
`98`	`98`	`if (count < 0 \|\| count > int.MaxValue)`
`99`	`99`	`{`
`@@ -107,14 +107,14 @@ public async ValueTask<byte[]> ReadBytesAsync(long count)`
`107`	`107`
`108`	`108`	`while (!TryRead(out value, count))`
`109`	`109`	`{`
`110`		`- if (_readResult.IsCompleted)`
	`110`	`+ if (ReadResult.IsCompleted)`
`111`	`111`	`{`
`112`	`112`	`throw new EndOfStreamException(`
`113`	`113`	`$"requested {count} bytes, but got only {RemainingBytesInReadResult} bytes");`
`114`	`114`	`}`
`115`	`115`
`116`		`- _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.GetPosition(Position));`
`117`		`- _readResult = await _pipeReader.ReadAsync();`
	`116`	`+ PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.GetPosition(Position));`
	`117`	`+ ReadResult = await PipeReader.ReadAsync();`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`Position += count;`
`@@ -128,7 +128,7 @@ bool TryRead(out byte[] readBytes, long readBytesCount)`
`128`	`128`	`return false;`
`129`	`129`	`}`
`130`	`130`
`131`		`- readBytes = _readResult.Buffer.Slice(Position, readBytesCount).ToArray();`
	`131`	`+ readBytes = ReadResult.Buffer.Slice(Position, readBytesCount).ToArray();`
`132`	`132`	`return true;`
`133`	`133`	`}`
`134`	`134`	`}`
`@@ -137,8 +137,8 @@ public virtual async ValueTask<byte[]> ReadBytesFullAsync()`
`137`	`137`	`{`
`138`	`138`	`await FillReadResultBufferToTheEnd();`
`139`	`139`
`140`		`- _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.End);`
`141`		`- var value = _readResult.Buffer.Slice(Position, _readResult.Buffer.End).ToArray();`
	`140`	`+ PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.End);`
	`141`	`+ var value = ReadResult.Buffer.Slice(Position, ReadResult.Buffer.End).ToArray();`
`142`	`142`	`Position += value.Length;`
`143`	`143`	`return value;`
`144`	`144`	`}`
`@@ -147,18 +147,18 @@ private async ValueTask FillReadResultBufferToTheEnd()`
`147`	`147`	`{`
`148`	`148`	`await EnsureReadResultIsNotDefault();`
`149`	`149`
`150`		`- while (!_readResult.IsCompleted)`
	`150`	`+ while (!ReadResult.IsCompleted)`
`151`	`151`	`{`
`152`		`- _pipeReader.AdvanceTo(_readResult.Buffer.Start, _readResult.Buffer.End);`
`153`		`- _readResult = await _pipeReader.ReadAsync();`
	`152`	`+ PipeReader.AdvanceTo(ReadResult.Buffer.Start, ReadResult.Buffer.End);`
	`153`	`+ ReadResult = await PipeReader.ReadAsync();`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`private async ValueTask EnsureReadResultIsNotDefault()`
`158`	`158`	`{`
`159`		`- if (_readResult.Equals(default(ReadResult)))`
	`159`	`+ if (ReadResult.Equals(default(ReadResult)))`
`160`	`160`	`{`
`161`		`- _readResult = await _pipeReader.ReadAsync();`
	`161`	`+ ReadResult = await PipeReader.ReadAsync();`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,32 +5,32 @@`
`5`	`5`
`6`	`6`	`namespace Kaitai.Async`
`7`	`7`	`{`
`8`		`- internal class StreamReaderContext : IReaderContext`
	`8`	`+ public class StreamReaderContext : IReaderContext`
`9`	`9`	`{`
`10`	`10`	`private readonly Stream _baseStream;`
	`11`	`+ protected readonly AsyncBinaryReader AsyncBinaryReader;`
`11`	`12`
`12`	`13`	`public StreamReaderContext(Stream stream)`
`13`	`14`	`{`
`14`	`15`	`_baseStream = stream;`
`15`	`16`	`AsyncBinaryReader = new AsyncBinaryReader(_baseStream);`
`16`	`17`	`}`
`17`	`18`
`18`		`- protected AsyncBinaryReader AsyncBinaryReader { get; }`
`19`	`19`	`public long Position => _baseStream.Position;`
`20`		`- public ValueTask<long> GetSizeAsync() => new ValueTask<long>(_baseStream.Length);`
	`20`	`+ public virtual ValueTask<long> GetSizeAsync() => new ValueTask<long>(_baseStream.Length);`
`21`	`21`
`22`		`- public ValueTask<bool> IsEofAsync() =>`
	`22`	`+ public virtual ValueTask<bool> IsEofAsync() =>`
`23`	`23`	`new ValueTask<bool>(_baseStream.Position >= _baseStream.Length);`
`24`	`24`
`25`		`- public ValueTask SeekAsync(long position)`
	`25`	`+ public virtual ValueTask SeekAsync(long position)`
`26`	`26`	`{`
`27`	`27`	`_baseStream.Seek(position, SeekOrigin.Begin);`
`28`	`28`	`return new ValueTask();`
`29`	`29`	`}`
`30`	`30`
`31`		`- public async ValueTask<byte> ReadByteAsync() => (byte) await AsyncBinaryReader.ReadSByteAsync();`
	`31`	`+ public virtual async ValueTask<byte> ReadByteAsync() => (byte) await AsyncBinaryReader.ReadSByteAsync();`
`32`	`32`
`33`		`- public async ValueTask<byte[]> ReadBytesAsync(long count)`
	`33`	`+ public virtual async ValueTask<byte[]> ReadBytesAsync(long count)`
`34`	`34`	`{`
`35`	`35`	`if (count < 0 \|\| count > int.MaxValue)`
`36`	`36`	`{`
`@@ -47,7 +47,7 @@ public async ValueTask<byte[]> ReadBytesAsync(long count)`
`47`	`47`	`return bytes;`
`48`	`48`	`}`
`49`	`49`
`50`		`- public async ValueTask<byte[]> ReadBytesFullAsync() =>`
	`50`	`+ public virtual async ValueTask<byte[]> ReadBytesFullAsync() =>`
`51`	`51`	`await ReadBytesAsync(_baseStream.Length - _baseStream.Position);`
`52`	`52`	`}`
`53`	`53`	`}`