protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output) { if (input is EmptyByteBuffer) { return; } if (input.GetLongLE(0) != 0) { context.FireChannelRead(input.Retain()); return; } input.SkipBytes(8); var messageId = input.ReadLongLE(); input.SkipBytes(4); var message = Serializer.Deserialize(input); Log.Debug($"#{ClientSettings.ClientSession.SessionId}: Recieve the message {message} with id: {messageId}"); output.Add(message); }
protected long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length) { long frameLength; switch (length) { case 1: frameLength = buffer.GetByte(offset); break; case 2: frameLength = BitConverter.IsLittleEndian ? buffer.GetUnsignedShort(offset) : buffer.GetUnsignedShortLE(offset); break; case 3: frameLength = BitConverter.IsLittleEndian ? buffer.GetUnsignedMedium(offset) : buffer.GetUnsignedMediumLE(offset); break; case 4: frameLength = BitConverter.IsLittleEndian ? buffer.GetInt(offset) : buffer.GetIntLE(offset); break; case 8: frameLength = BitConverter.IsLittleEndian ? buffer.GetLong(offset) : buffer.GetLongLE(offset); break; default: throw new Exception("unsupported lengthFieldLength: " + this.lengthFieldLength + " (expected: 1, 2, 3, 4, or 8)"); } return(frameLength); }
/// <summary> /// Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is /// capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to /// decode the length field encoded differently. /// Note that this method must not modify the state of the specified buffer (e.g. /// <see cref="IByteBuffer.ReaderIndex" />, /// <see cref="IByteBuffer.WriterIndex" />, and the content of the buffer.) /// </summary> /// <param name="buffer">The buffer we'll be extracting the frame length from.</param> /// <param name="offset">The offset from the absolute <see cref="IByteBuffer.ReaderIndex" />.</param> /// <param name="length">The length of the framelenght field. Expected: 1, 2, 3, 4, or 8.</param> /// <param name="order">The preferred <see cref="ByteOrder" /> of buffer.</param> /// <returns>A long integer that represents the unadjusted length of the next frame.</returns> protected static long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order) { return(length switch { 1 => buffer.GetByte(offset), 2 => order == ByteOrder.BigEndian ? buffer.GetUnsignedShort(offset) : buffer.GetUnsignedShortLE(offset), 3 => order == ByteOrder.BigEndian ? buffer.GetUnsignedMedium(offset) : buffer.GetUnsignedMediumLE(offset), 4 => order == ByteOrder.BigEndian ? buffer.GetInt(offset) : buffer.GetIntLE(offset), 8 => order == ByteOrder.BigEndian ? buffer.GetLong(offset) : buffer.GetLongLE(offset), _ => CThrowHelper.ThrowDecoderException(length), });
/// <summary> /// Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is /// capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to /// decode the length field encoded differently. /// Note that this method must not modify the state of the specified buffer (e.g. /// <see cref="IByteBuffer.ReaderIndex" />, /// <see cref="IByteBuffer.WriterIndex" />, and the content of the buffer.) /// </summary> /// <param name="buffer">The buffer we'll be extracting the frame length from.</param> /// <param name="offset">The offset from the absolute <see cref="IByteBuffer.ReaderIndex" />.</param> /// <param name="length">The length of the framelenght field. Expected: 1, 2, 3, 4, or 8.</param> /// <param name="order">The preferred <see cref="ByteOrder" /> of buffer.</param> /// <returns>A long integer that represents the unadjusted length of the next frame.</returns> protected long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order) { long frameLength; switch (length) { case 1: frameLength = buffer.GetByte(offset); break; case 2: frameLength = order == ByteOrder.BigEndian ? buffer.GetUnsignedShort(offset) : buffer.GetUnsignedShortLE(offset); break; case 3: frameLength = order == ByteOrder.BigEndian ? buffer.GetUnsignedMedium(offset) : buffer.GetUnsignedMediumLE(offset); break; case 4: frameLength = order == ByteOrder.BigEndian ? buffer.GetInt(offset) : buffer.GetIntLE(offset); break; case 8: frameLength = order == ByteOrder.BigEndian ? buffer.GetLong(offset) : buffer.GetLongLE(offset); break; default: throw new DecoderException("unsupported lengthFieldLength: " + this.lengthFieldLength + " (expected: 1, 2, 3, 4, or 8)"); } byte[] bytes = BitConverter.GetBytes(frameLength); string slength = Encoding.UTF8.GetString(bytes); frameLength = long.Parse(slength); return(frameLength); }
public virtual long GetLongLE(int index) => Buf.GetLongLE(index);
public long GetLongLE(int index) { CheckIndex(index, 8); return(_buffer.GetLongLE(index)); }
/// <summary> /// Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is /// capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to /// decode the length field encoded differently. /// Note that this method must not modify the state of the specified buffer (e.g. /// <see cref="IByteBuffer.ReaderIndex" />, /// <see cref="IByteBuffer.WriterIndex" />, and the content of the buffer.) /// </summary> /// <param name="buffer">The buffer we'll be extracting the frame length from.</param> /// <param name="offset">The offset from the absolute <see cref="IByteBuffer.ReaderIndex" />.</param> /// <param name="length">The length of the framelenght field. Expected: 1, 2, 3, 4, or 8.</param> /// <param name="order">The preferred <see cref="ByteOrder" /> of buffer.</param> /// <returns>A long integer that represents the unadjusted length of the next frame.</returns> protected long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order) { long frameLength; switch (length) { case 1: frameLength = buffer.GetByte(offset); break; case 2: frameLength = this.byteOrder == ByteOrder.BigEndian ? buffer.GetShort(offset) : buffer.GetShortLE(offset); break; case 4: frameLength = this.byteOrder == ByteOrder.BigEndian ? buffer.GetInt(offset) : buffer.GetIntLE(offset); break; case 8: frameLength = this.byteOrder == ByteOrder.BigEndian ? buffer.GetLong(offset) : buffer.GetLongLE(offset); break; default: throw new DecoderException("unsupported lengthFieldLength: " + this.lengthFieldLength + " (expected: 1, 2, 3, 4, or 8)"); } return(frameLength); }
public static double GetDoubleLE(this IByteBuffer buf, int index) => BitConverter.Int64BitsToDouble(buf.GetLongLE(index));