/// <summary>
        /// Reads a <see cref="IBufferReader{T}"/> to completion, writing to a <see cref="IBufferWriterAsync{T}"/>
        /// </summary>
        /// <typeparam name="T">The type of element</typeparam>
        /// <param name="reader">The reader to read from</param>
        /// <param name="writer">The writer to write to</param>
        /// <param name="token">A cancellation token to abort the operation</param>
        /// <returns>A task representing the progress fo the write operation</returns>
        public static async ValueTask CopyToAsync <T>(this IBufferReader <T> reader, IBufferWriterAsync <T> writer, CancellationToken token = default)
        {
            while (reader.CanRead)
            {
                var InBuffer = reader.GetMemory(0);

                if (InBuffer.IsEmpty)
                {
                    break;
                }

                InBuffer.Span.CopyTo(writer.GetSpan(InBuffer.Length));

                await writer.AdvanceAsync(InBuffer.Length, token);

                reader.Advance(InBuffer.Length);
            }
        }
        /// <summary>
        /// Reads a <see cref="IBufferReader{T}"/> to completion, writing to a <see cref="IBufferWriter{T}"/>
        /// </summary>
        /// <typeparam name="T">The type of element</typeparam>
        /// <param name="reader">The reader to read from</param>
        /// <param name="writer">The writer to write to</param>
        public static void CopyTo <T>(this IBufferReader <T> reader, IBufferWriter <T> writer)
        {
            while (reader.CanRead)
            {
                var InBuffer = reader.GetSpan(0);

                if (InBuffer.IsEmpty)
                {
                    break;
                }

                var OutBuffer = writer.GetSpan(InBuffer.Length);

                InBuffer.CopyTo(OutBuffer);

                writer.Advance(InBuffer.Length);
                reader.Advance(InBuffer.Length);
            }
        }
        int Read(Span <char> buffer)
        {               //****************************************
            var CharsWritten = 0;

            //****************************************

            if (buffer.IsEmpty)
            {
                return(0);
            }

            // Empty the buffer if there's anything in it
            if (_BufferLength > 0)
            {
                var WriteLength = Math.Min(_BufferLength, buffer.Length);

                _Buffer.AsSpan(_BufferIndex, WriteLength).CopyTo(buffer);

                buffer = buffer.Slice(WriteLength);

                CharsWritten += WriteLength;

                _BufferIndex  += WriteLength;
                _BufferLength -= WriteLength;

                if (buffer.IsEmpty)
                {
                    return(CharsWritten);
                }
            }

            if (_CheckPreamble)
            {
                CheckPreamble();
            }

            if (_DetectEncoding)
            {
                DetectEncoding();
            }

            ReadOnlySpan <byte> InBuffer;
            var  OutBuffer = _Buffer.AsSpan(0, _Buffer.Length);
            bool IsCompleted;

            // Keep trying to read until we fill the buffer, or the source reader runs out
            do
            {
                InBuffer = _Reader.GetSpan(0);

                // Decode the bytes into our char buffer
                _Decoder.Convert(
                    InBuffer,
                    OutBuffer,
                    InBuffer.IsEmpty,
                    out var BytesRead, out var WrittenChars, out IsCompleted
                    );

                var ReadLength = Math.Min(WrittenChars, buffer.Length);

                OutBuffer.Slice(0, ReadLength).CopyTo(buffer);

                buffer = buffer.Slice(ReadLength);

                CharsWritten += ReadLength;
                _Position    += BytesRead;

                _Reader.Advance(BytesRead);

                if (buffer.IsEmpty)
                {
                    // Buffer is filled. Save any data left over for the next read operation
                    _BufferIndex  = ReadLength;
                    _BufferLength = WrittenChars - ReadLength;

                    return(CharsWritten);
                }

                // Loop while there are more bytes unread, or there are no bytes left but there's still data to flush
            }while (!InBuffer.IsEmpty || !IsCompleted);

            _BufferLength = 0;

            return(CharsWritten);
        }
Example #4
0
        internal static void ReadBufferAsync(IForwarder forwarder, IBufferReader bufferReader)
        {
            var buffer = bufferReader.Read();
            var packet = Deserialize(buffer, out var bytesConsumed);

            if (bytesConsumed == 0)
            {
                return;
            }

            switch (packet)
            {
            case Connect connect:
                forwarder.Dispatch(connect);
                break;

            case ConnAck connAck:
                forwarder.Dispatch(connAck);
                break;

            case Disconnect disconnect:
                forwarder.Dispatch(disconnect);
                break;

            case PubAck pubAck:
                forwarder.Dispatch(pubAck);
                break;

            case PubRel pubRel:
                forwarder.Dispatch(pubRel);
                break;

            case PubRec pubRec:
                forwarder.Dispatch(pubRec);
                break;

            case PubComp pubComp:
                forwarder.Dispatch(pubComp);
                break;

            case PingReq pingReq:
                forwarder.Dispatch(pingReq);
                break;

            case PingResp pingResp:
                forwarder.Dispatch(pingResp);
                break;

            case Subscribe subscribe:
                forwarder.Dispatch(subscribe);
                break;

            case SubAck subAck:
                forwarder.Dispatch(subAck);
                break;

            case Unsubscribe unsubscribe:
                forwarder.Dispatch(unsubscribe);
                break;

            case UnsubAck unsubAck:
                forwarder.Dispatch(unsubAck);
                break;
            }

            bufferReader.Advance(bytesConsumed);
        }
Example #5
0
 public static void Advance(this IBufferReader reader, long count)
 {
     VerifyCountParam(count);
     reader.Advance((int)count);
 }
Example #6
0
        public static void CopyTo(this IBufferReader <byte> source, Stream target) => source.CopyTo(target, 81920);        // Same buffer size as Stream.CopyTo

        /// <summary>
        /// Synchronously reads the bytes from the current <see cref="IBufferReader{Byte}"/> and writes them to a Stream
        /// </summary>
        /// <param name="source">The current buffer reader to read from</param>
        /// <param name="target">The stream to write to</param>
        /// <param name="blockSize">The size of the blocks to read and write</param>
        public static void CopyTo(this IBufferReader <byte> source, Stream target, int blockSize)
        {
            if (blockSize < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(blockSize));
            }

#if NETSTANDARD2_0
            byte[]? InBuffer = null;

            try
            {
                for (; ;)
                {
                    var Buffer = source.GetMemory(blockSize);

                    if (Buffer.IsEmpty)
                    {
                        break;
                    }

                    if (MemoryMarshal.TryGetArray(Buffer, out var Segment))
                    {
                        // Have the stream write directly from the source buffer
                        target.Write(Segment.Array, Segment.Offset, Segment.Count);

                        source.Advance(Segment.Count);
                    }
                    else
                    {
                        // Not a buffer we can pass to Stream.Write, so we have to copy
                        if (InBuffer == null)
                        {
                            InBuffer = ArrayPool <byte> .Shared.Rent(Buffer.Length);
                        }

                        var Length = Math.Min(Buffer.Length, InBuffer.Length);

                        Buffer.Slice(0, Length).CopyTo(InBuffer);

                        target.Write(InBuffer, 0, Length);

                        source.Advance(Length);
                    }
                }
            }
            finally
            {
                if (InBuffer != null)
                {
                    ArrayPool <byte> .Shared.Return(InBuffer);
                }
            }
#else
            for (; ;)
            {
                var Buffer = source.GetSpan(blockSize);

                if (Buffer.IsEmpty)
                {
                    break;
                }

                target.Write(Buffer);

                source.Advance(Buffer.Length);
            }
#endif
        }