Ejemplo n.º 1
0
 public static ushort GetUnsignedShortLE(this IByteBuffer buf, int index)
 {
     unchecked
     {
         return((ushort)buf.GetShortLE(index));
     }
 }
Ejemplo n.º 2
0
        protected override long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order)
        {
            var scalarPrefix = buffer.GetByte(offset++);

            if (buffer.ReadableBytes - (offset - buffer.ReaderIndex) < scalarPrefix)
            {
                return(scalarPrefix);
            }

            switch (scalarPrefix)
            {
            case 1:
                return(buffer.GetByte(offset) + scalarPrefix);

            case 2:
                return(buffer.GetShortLE(offset) + scalarPrefix);

            case 4:
                return(buffer.GetIntLE(offset) + scalarPrefix);

            default:
                throw new ProudFrameException("Invalid scalar prefix " + scalarPrefix);
            }
        }
Ejemplo n.º 3
0
 public virtual short GetShortLE(int index) => Buf.GetShortLE(index);
Ejemplo n.º 4
0
 public short GetShortLE(int index)
 {
     CheckIndex(index, 2);
     return(_buffer.GetShortLE(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);
        }