Std

VecStreamReader.cs (9287B)

---

 using Std.Vec;
 using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 #region Namespaces
 namespace Std.IO {
     #region Types
     // Read-only, non-seekable, stream based on Std.Vec.Vec<byte>.
     // This type is an even lighter-weight alternative to the default MemoryStream and has more strictly enforced behavior.
     // This type only implements I(Async)Disposable because it has to by virtue of being a subtype of System.IO.StreamIter.
     // This type does not dispose of anything, however, and calling dispose only suppresses the finalizer.
     // This type is a subtype of MemoryStream purely for performance reasons. There is a lot of code in the .NET SDK
     // that uses reflection to detect more specific subtypes to influence the behavior of a type or function.
     // We want this type to enjoy any potential benefits such code may have.
     // Note this type does not use the underlying data or implementation of MemoryStream in any way with exceptions of BeginRead and EndRead.
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1063:Implement IDisposable Correctly", Justification = "This type should not implement IDisposable to begin with, but it has to by being a subtype of StreamIter. We have it do nothing.")]
     public sealed class VecStreamReader: MemoryStream, IDisposable, IAsyncDisposable {
 
         #region Type-level Constructors
         #endregion
 
         #region Instance Constructors
         public VecStreamReader(Vec<byte> data, uint position) : base(Array.Empty<byte>(), 0, 0, false, false) {
 
             if (position <= data.Len) {
                 (_buffer, _originalPosition, _pos) = (data, position, position);
             } else {
                 throw new ArgumentOutOfRangeException(nameof(position), "Position must be less than or equal to the length of data.");
             }
         }
         #endregion
 
         #region Type-level Fields
         #endregion
 
         #region Instance Fields
         readonly Vec<byte> _buffer;
         readonly uint _originalPosition;
         uint _pos;
         #endregion
 
         #region Type-level Properties
         #endregion
 
         #region Instance Properties
         public sealed override bool CanRead => true;
         public sealed override bool CanSeek => false;
         public sealed override bool CanTimeout => false;
         public sealed override bool CanWrite => false;
         public sealed override int Capacity => (int)_buffer.Capacity;
         public uint CurrentPosition => _pos;
         public ReadOnlySpan<byte> ReadData => _buffer.AsSlice()[(int)_originalPosition..(int)_pos];
         public ReadOnlySpan<byte> UnreadData => _buffer.AsSlice()[(int)_pos..];
         public uint Len => _buffer.Len - _originalPosition;
         public sealed override long Length => Len;
         // The .NET SDK is littered with many terrible design decisions.
         // Instead of having dedicated interfaces, non-sealed classes, and non-sealed records that guarantee certain invariants,
         // many types have functions that are only sometimes valid. This in turn requires
         // many subtypes to throw exceptions for inapplicable functions.
         // The getter of this property should be fine to return, but the API documentation states that only seekable streams are allowed to return anything.
         public sealed override long Position {
             get => throw new NotSupportedException();
             set => throw new NotSupportedException();
         }
         public sealed override int ReadTimeout => throw new InvalidOperationException();
         public sealed override int WriteTimeout => throw new InvalidOperationException();
         #endregion
 
         #region Type-level Functions
         public static VecStreamReader New(Vec<byte> data, uint position) => new(data, position);
         #endregion
 
         #region Instance Functions
         // Due to complexity of doing this correctly, we defer to the base implementation.
         public sealed override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state) => base.BeginRead(buffer, offset, count, callback, state);
         public sealed override IAsyncResult BeginWrite(byte[] _, int _1, int _2, AsyncCallback? _3, object? _4) => throw new NotSupportedException();
         public sealed override void Close() => Dispose();
         public sealed override void CopyTo(Stream stream, int _) {
 
             stream.Write(_buffer.AsSlice()[(int)_pos..]);
             _pos = _buffer.Len;
         }
         public sealed override Task CopyToAsync(Stream stream, int bufferSize, CancellationToken _2) { CopyTo(stream, bufferSize); return Task.CompletedTask; }
         [Obsolete("System.Threading.ManualResetEvent should be used instead.", true)]
         protected sealed override WaitHandle CreateWaitHandle() => new ManualResetEvent(false);
         public new void Dispose() => GC.SuppressFinalize(this);
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2215:Dispose methods should call base class dispose", Justification = "We don't want Dispose to do anything.")]
         protected sealed override void Dispose(bool disposing) {
             // This should mean Dispose on StreamIter or MemoryStream was called, so we redirect to Dispose which suppresses the finalizer.
             if (disposing) {
                 Dispose();
             }
         }
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2215:Dispose methods should call base class dispose", Justification = "We don't want DisposeAsync to do anything.")]
         public sealed override ValueTask DisposeAsync() { 
         
             Dispose();
             return ValueTask.CompletedTask;
         }
         // Due to complexity of doing this correctly, we defer to the base implementation.
         public sealed override int EndRead(IAsyncResult asyncResult) => base.EndRead(asyncResult);
         public sealed override void EndWrite(IAsyncResult asyncResult) => throw new NotSupportedException();
         public sealed override bool Equals(object? _) => false;
         public sealed override void Flush() { }
         public sealed override Task FlushAsync(CancellationToken _) => Task.CompletedTask;
         public sealed override int GetHashCode() => 0;
         public Unit Reset() {
 
             _pos = _originalPosition;
             return new Unit();
         }
         public Vec<byte> GetVecBuffer() => _buffer;
         public sealed override byte[] GetBuffer() => _buffer.AsArray();
         [Obsolete("Platform does not support this. A System.PlatformNotSupportedException will be thrown.", true)]
         public sealed override object InitializeLifetimeService() => throw new PlatformNotSupportedException();
         [Obsolete("Do not call this method.", true)]
         protected sealed override void ObjectInvariant() { }
         public sealed override int Read(byte[] buffer, int offset, int count) => Read(buffer.AsSpan(offset, count));
         public sealed override int Read(Span<byte> buffer) {
 
             var count = (int)Math.Min(buffer.Length, _buffer.Len - _pos);
             _buffer.AsArray().AsSpan((int)_pos, count).CopyTo(buffer);
             _pos += (uint)count;
             return count;
         }
         public sealed override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken _) => Task.FromResult(Read(buffer.AsSpan(offset, count)));
         public sealed override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken _1) => ValueTask.FromResult(Read(buffer.Span));
         public sealed override int ReadByte() => _pos < _buffer.Len ? _buffer[_pos++] : -1;
         public sealed override long Seek(long _, SeekOrigin _1) => throw new NotSupportedException();
         public sealed override void SetLength(long _) => throw new NotSupportedException();
         public sealed override byte[] ToArray() {
 
             var arr = new byte[_buffer.Len - _originalPosition];
             Array.Copy(_buffer.AsArray(), _originalPosition, arr, 0, arr.Length);
             return arr;
         }
         public sealed override string ToString() => "VecStreamReader";
         public sealed override bool TryGetBuffer(out ArraySegment<byte> buffer) {
             
             buffer = new(_buffer.AsArray(), (int)_originalPosition, (int)(_buffer.Len - _originalPosition));
             return true;
         }
         public sealed override void Write(byte[] _, int _1, int _2) => throw new NotSupportedException();
         public sealed override void Write(ReadOnlySpan<byte> _) => throw new NotSupportedException();
         public sealed override Task WriteAsync(byte[] _, int _1, int _2, CancellationToken _3) => throw new NotSupportedException();
         public sealed override ValueTask WriteAsync(ReadOnlyMemory<byte> _, CancellationToken _1) => throw new NotSupportedException();
         public sealed override void WriteByte(byte _) => throw new NotSupportedException();
         public sealed override void WriteTo(Stream stream) => stream.Write(_buffer.AsSlice()[(int)_originalPosition..]);
         #endregion
 
         #region Operators
         #endregion
 
         #region Types
         #endregion
     }
     #endregion
 
     #region Namespaces
     #endregion
 }
 #endregion