Init enter game

KcpSharp/Base/KcpStream.cs

@@ -0,0 +1,176 @@
+namespace KianaBH.KcpSharp.Base;
+
+/// <summary>
+///     A stream wrapper of <see cref="KcpConversation" />.
+/// </summary>
+public sealed class KcpStream : Stream
+{
+    private readonly bool _ownsConversation;
+    private KcpConversation? _conversation;
+
+    /// <summary>
+    ///     Create a stream wrapper over an existing <see cref="KcpConversation" /> instance.
+    /// </summary>
+    /// <param name="conversation">The conversation instance. It must be in stream mode.</param>
+    /// <param name="ownsConversation">
+    ///     Whether to dispose the <see cref="KcpConversation" /> instance when
+    ///     <see cref="KcpStream" /> is disposed.
+    /// </param>
+    public KcpStream(KcpConversation conversation, bool ownsConversation)
+    {
+        if (conversation is null) throw new ArgumentNullException(nameof(conversation));
+        if (!conversation.StreamMode)
+            throw new ArgumentException("Non-stream mode conversation is not supported.", nameof(conversation));
+        _conversation = conversation;
+        _ownsConversation = ownsConversation;
+    }
+
+    /// <inheritdoc />
+    public override bool CanRead => true;
+
+    /// <inheritdoc />
+    public override bool CanSeek => false;
+
+    /// <inheritdoc />
+    public override bool CanWrite => true;
+
+    /// <summary>
+    ///     The length of the stream. This always throws <see cref="NotSupportedException" />.
+    /// </summary>
+    public override long Length => throw new NotSupportedException();
+
+    /// <summary>
+    ///     The position of the stream. This always throws <see cref="NotSupportedException" />.
+    /// </summary>
+    public override long Position
+    {
+        get => throw new NotSupportedException();
+        set => throw new NotSupportedException();
+    }
+
+    /// <summary>
+    ///     Indicates data is available on the stream to be read. This property checks to see if at least one byte of data is
+    ///     currently available
+    /// </summary>
+    public bool DataAvailable
+    {
+        get
+        {
+            if (_conversation is null) ThrowHelper.ThrowObjectDisposedForKcpStreamException();
+            return _conversation!.TryPeek(out var result) && result.BytesReceived != 0;
+        }
+    }
+
+    /// <inheritdoc />
+    public override long Seek(long offset, SeekOrigin origin)
+    {
+        throw new NotSupportedException();
+    }
+
+    /// <inheritdoc />
+    public override void SetLength(long value)
+    {
+        throw new NotSupportedException();
+    }
+
+    /// <inheritdoc />
+    public override void Flush()
+    {
+        throw new NotSupportedException();
+    }
+
+    /// <inheritdoc />
+    public override Task FlushAsync(CancellationToken cancellationToken)
+    {
+        if (_conversation is null) return Task.FromException(ThrowHelper.NewObjectDisposedForKcpStreamException());
+        return _conversation!.FlushAsync(cancellationToken).AsTask();
+    }
+
+    /// <inheritdoc />
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        throw new NotSupportedException();
+    }
+
+    /// <inheritdoc />
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        throw new NotSupportedException();
+    }
+
+    /// <inheritdoc />
+    public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+    {
+        if (_conversation is null) return Task.FromException<int>(new ObjectDisposedException(nameof(KcpStream)));
+        return _conversation.ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();
+    }
+
+    /// <inheritdoc />
+    public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+    {
+        if (_conversation is null) return Task.FromException(new ObjectDisposedException(nameof(KcpStream)));
+        return _conversation.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();
+    }
+
+    /// <inheritdoc />
+    public override int ReadByte()
+    {
+        throw new NotSupportedException();
+    }
+
+    /// <inheritdoc />
+    public override void WriteByte(byte value)
+    {
+        throw new NotSupportedException();
+    }
+
+    /// <inheritdoc />
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing && _ownsConversation) _conversation?.Dispose();
+        _conversation = null;
+        base.Dispose(disposing);
+    }
+
+#if !NO_FAST_SPAN
+    /// <inheritdoc />
+    public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+    {
+        if (_conversation is null)
+            return new ValueTask<int>(Task.FromException<int>(new ObjectDisposedException(nameof(KcpStream))));
+        return _conversation.ReadAsync(buffer, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+    {
+        if (_conversation is null)
+            return new ValueTask(Task.FromException(new ObjectDisposedException(nameof(KcpStream))));
+        return _conversation.WriteAsync(buffer, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public override ValueTask DisposeAsync()
+    {
+        if (_conversation is not null)
+        {
+            _conversation.Dispose();
+            _conversation = null;
+        }
+
+        return base.DisposeAsync();
+    }
+
+    /// <inheritdoc />
+    public override int Read(Span<byte> buffer)
+    {
+        throw new NotSupportedException();
+    }
+
+    /// <inheritdoc />
+    public override void Write(ReadOnlySpan<byte> buffer)
+    {
+        throw new NotSupportedException();
+    }
+#endif
+}