Std

VecStreamWriter.cs (8685B)

---

 using Std.Vec;
 using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 #region Namespaces
 namespace Std.IO {
     #region Types
     // Write-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 BeginWrite and EndWrite.
     [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 VecStreamWriter: MemoryStream, IDisposable, IAsyncDisposable {
 
         #region Type-level Constructors
         #endregion
 
         #region Instance Constructors
         public VecStreamWriter() : base(Array.Empty<byte>(), 0, 0, false, false) => _buffer = new Vec<byte>();
         public VecStreamWriter(uint capacity) : base(Array.Empty<byte>(), 0, 0, false, false) => _buffer = Vec<byte>.WithCapacity(capacity);
         #endregion
 
         #region Type-level Fields
         #endregion
 
         #region Instance Fields
         Vec<byte> _buffer;
         #endregion
 
         #region Type-level Properties
         #endregion
 
         #region Instance Properties
         public sealed override bool CanRead => false;
         public sealed override bool CanSeek => false;
         public sealed override bool CanTimeout => false;
         public sealed override bool CanWrite => true;
         public sealed override int Capacity => (int)_buffer.Capacity;
         public ReadOnlySpan<byte> Data => _buffer.AsSlice();
         public uint Len => _buffer.Len;
         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 VecStreamWriter New() => new();
         public static VecStreamWriter NewWithCapacity(uint capacity) => new(capacity);
         #endregion
 
         #region Instance Functions
         public sealed override IAsyncResult BeginRead(byte[] _, int _1, int _2, AsyncCallback? _3, object? _4) => throw new NotSupportedException();
         // Due to complexity of doing this correctly, we defer to the base implementation.
         public sealed override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state) => base.BeginWrite(buffer, offset, count, callback, state);
         public sealed override void Close() => Dispose();
         public sealed override void CopyTo(Stream _, int _1) => throw new NotSupportedException();
         public sealed override Task CopyToAsync(Stream _, int _1, CancellationToken _2) => throw new NotSupportedException();
         [Obsolete("System.Threading.ManualResetEvent should be used instead.", true)]
         protected sealed override WaitHandle CreateWaitHandle() => new ManualResetEvent(false);
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA1816:Dispose methods should call SuppressFinalize", Justification = "We don't want Dispose to do anything.")]
         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;
         }
         public sealed override int EndRead(IAsyncResult _) => throw new NotSupportedException();
         // Due to complexity of doing this correctly, we defer to the base implementation.
         public sealed override void EndWrite(IAsyncResult asyncResult) => base.EndWrite(asyncResult);
         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() => _buffer.Clear();
         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[] _, int _1, int _2) => throw new NotSupportedException();
         public sealed override int Read(Span<byte> _) => throw new NotSupportedException();
         public sealed override Task<int> ReadAsync(byte[] _, int _1, int _2, CancellationToken _3) => throw new NotSupportedException();
         public sealed override ValueTask<int> ReadAsync(Memory<byte> _, CancellationToken _1) => throw new NotSupportedException();
         public sealed override int ReadByte() => throw new NotSupportedException();
         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];
             _buffer.AsSlice().CopyTo(arr.AsSpan());
             return arr;
         }
         public sealed override string ToString() => "VecStreamWriter";
         public Unit Truncate(uint len) => _buffer.Truncate(len);
         public sealed override bool TryGetBuffer(out ArraySegment<byte> buffer) {
 
             buffer = new(_buffer.AsArray(), 0, (int)_buffer.Len);
             return true;
         }
         public sealed override void Write(byte[] buffer, int offset, int count) => Write(buffer.AsSpan(offset, count));
         public sealed override void Write(ReadOnlySpan<byte> buffer) => _buffer.ExtendFromSlice(buffer);
         public sealed override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken _) { Write(buffer.AsSpan(offset, count)); return Task.CompletedTask; }
         public sealed override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken _1) { Write(buffer.Span); return ValueTask.CompletedTask; }
         public sealed override void WriteByte(byte value) => _buffer.Push(value);
         public sealed override void WriteTo(Stream stream) => stream.Write(_buffer.AsSlice());
         #endregion
 
         #region Operators
         #endregion
 
         #region Types
         #endregion
     }
     #endregion
 
     #region Namespaces
     #endregion
 }
 #endregion