Пример #1
0
        internal static ByteBuffer EncodeCommand(FrameType type, ushort channel, Performative command, int payloadSize)
        {
            int frameSize = HeaderSize;

            if (command != null)
            {
                frameSize += AmqpCodec.GetSerializableEncodeSize(command);
            }

            frameSize += payloadSize;

            ByteBuffer buffer = new ByteBuffer(frameSize, false, false);

            AmqpBitConverter.WriteUInt(buffer, (uint)frameSize);
            AmqpBitConverter.WriteUByte(buffer, DefaultDataOffset);
            AmqpBitConverter.WriteUByte(buffer, (byte)type);
            AmqpBitConverter.WriteUShort(buffer, channel);

            if (command != null)
            {
                AmqpCodec.EncodeSerializable(command, buffer);
            }

            return(buffer);
        }
Пример #2
0
 static void EncodeFrame(ByteBuffer buffer, FrameType type, ushort channel, DescribedList command)
 {
     AmqpBitConverter.WriteUInt(buffer, 0u);
     AmqpBitConverter.WriteUByte(buffer, DOF);
     AmqpBitConverter.WriteUByte(buffer, (byte)type);
     AmqpBitConverter.WriteUShort(buffer, channel);
     Codec.Encode(command, buffer);
 }
Пример #3
0
 public static void Encode(ByteBuffer buffer, FrameType type, ushort channel, DescribedList command)
 {
     buffer.Append(4);
     AmqpBitConverter.WriteUByte(buffer, 2);
     AmqpBitConverter.WriteUByte(buffer, (byte)type);
     AmqpBitConverter.WriteUShort(buffer, channel);
     command.Encode(buffer);
     AmqpBitConverter.WriteInt(buffer.Buffer, buffer.Offset, buffer.Length);
 }
Пример #4
0
 public override void EncodeObject(object value, bool arrayEncoding, ByteBuffer buffer)
 {
     if (arrayEncoding)
     {
         AmqpBitConverter.WriteUShort(buffer, (ushort)value);
     }
     else
     {
         UShortEncoding.Encode((ushort)value, buffer);
     }
 }
Пример #5
0
 public static void Encode(ushort?value, ByteBuffer buffer)
 {
     if (value.HasValue)
     {
         AmqpBitConverter.WriteUByte(buffer, (byte)FormatCode.UShort);
         AmqpBitConverter.WriteUShort(buffer, value.Value);
     }
     else
     {
         AmqpEncoding.EncodeNull(buffer);
     }
 }
Пример #6
0
        public void Encode(ByteBuffer buffer)
        {
            AmqpBitConverter.WriteUInt(buffer, (uint)this.size);
            AmqpBitConverter.WriteUByte(buffer, this.dataOffset);
            AmqpBitConverter.WriteUByte(buffer, (byte)this.Type);
            AmqpBitConverter.WriteUShort(buffer, this.Channel);

            if (this.Command != null)
            {
                AmqpCodec.EncodeSerializable(this.Command, buffer);
            }

            this.frameBuffer = buffer.Array;
        }
        public static void FRM(Stream stream, ulong code, byte type, ushort channel, params object[] value)
        {
            List list = new List();

            if (value != null)
            {
                list.AddRange(value);
            }
            ByteBuffer buffer = new ByteBuffer(256, true);

            buffer.Append(4);
            AmqpBitConverter.WriteUByte(buffer, 2);
            AmqpBitConverter.WriteUByte(buffer, type);
            AmqpBitConverter.WriteUShort(buffer, channel);
            Encoder.WriteObject(buffer, new DescribedValue(code, list));
            AmqpBitConverter.WriteInt(buffer.Buffer, 0, buffer.Length);
            stream.Write(buffer.Buffer, buffer.Offset, buffer.Length);
        }
Пример #8
0
        public static ByteBuffer EncodeCommand(FrameType type, ushort channel, Performative command, int payloadSize)
        {
            int serializableEncodeSize = 8;

            if (command != null)
            {
                serializableEncodeSize = serializableEncodeSize + AmqpCodec.GetSerializableEncodeSize(command);
            }
            serializableEncodeSize = serializableEncodeSize + payloadSize;
            ByteBuffer byteBuffer = new ByteBuffer(serializableEncodeSize, false, false);

            AmqpBitConverter.WriteUInt(byteBuffer, (uint)serializableEncodeSize);
            AmqpBitConverter.WriteUByte(byteBuffer, 2);
            AmqpBitConverter.WriteUByte(byteBuffer, (byte)type);
            AmqpBitConverter.WriteUShort(byteBuffer, channel);
            if (command != null)
            {
                AmqpCodec.EncodeSerializable(command, byteBuffer);
            }
            return(byteBuffer);
        }
Пример #9
0
        public static void EncodeFrame(ByteBuffer buffer, AmqpFrame frame, ushort channelNumber)
        {
            buffer.ValidateWrite(8);

            var frameStartOffset = buffer.WriteOffset;

            // header
            buffer.AppendWrite(FixedWidth.UInt);       // placeholder for frame size
            AmqpBitConverter.WriteUByte(buffer, 0x02); // data offset (2*4 = 8 bytes to account for header)
            AmqpBitConverter.WriteUByte(buffer, 0x00); // frame type = AMQP frame
            AmqpBitConverter.WriteUShort(buffer, channelNumber);

            // frame body, may be null/empty
            if (frame != null)
            {
                frame.Encode(buffer);
            }

            // frame size
            int frameSize = buffer.WriteOffset - frameStartOffset;

            AmqpBitConverter.WriteInt(buffer.Buffer, frameStartOffset, frameSize);
        }
Пример #10
0
        public static void FRM(Stream stream, ulong code, byte type, ushort channel, params object[] value)
        {
            List list = new List();

            if (value != null)
            {
                list.AddRange(value);
            }
            ByteBuffer buffer = new ByteBuffer(256, true);

            buffer.Append(4);
            AmqpBitConverter.WriteUByte(buffer, 2);
            AmqpBitConverter.WriteUByte(buffer, type);
            AmqpBitConverter.WriteUShort(buffer, channel);
            Encoder.WriteObject(buffer, new DescribedValue(code, list));
            if (code == 0x14UL) // transfer
            {
                byte[] bytes = new byte[] { 0x00, 0x53, 0x77, 0xa1, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f };
                AmqpBitConverter.WriteBytes(buffer, bytes, 0, bytes.Length);
            }

            AmqpBitConverter.WriteInt(buffer.Buffer, 0, buffer.Length);
            stream.Write(buffer.Buffer, buffer.Offset, buffer.Length);
        }
Пример #11
0
        public void TestMethod_AmqpBitConverter()
        {
            ByteBuffer buffer = new ByteBuffer(128, true);

            AmqpBitConverter.WriteByte(buffer, 0x22);
            AmqpBitConverter.WriteByte(buffer, -0x22);

            AmqpBitConverter.WriteUByte(buffer, 0x22);
            AmqpBitConverter.WriteUByte(buffer, 0xB2);

            AmqpBitConverter.WriteShort(buffer, 0x22B7);
            AmqpBitConverter.WriteShort(buffer, -0x22B7);

            AmqpBitConverter.WriteUShort(buffer, 0x22B7);
            AmqpBitConverter.WriteUShort(buffer, 0xC2B7);

            AmqpBitConverter.WriteInt(buffer, 0x340da287);
            AmqpBitConverter.WriteInt(buffer, -0x340da287);

            AmqpBitConverter.WriteUInt(buffer, 0x340da287);
            AmqpBitConverter.WriteUInt(buffer, 0xF40da287);

            AmqpBitConverter.WriteLong(buffer, 0x5d00BB9A340da287);
            AmqpBitConverter.WriteLong(buffer, -0x5d00BB9A340da287);

            AmqpBitConverter.WriteULong(buffer, 0x5d00BB9A340da287);
            AmqpBitConverter.WriteULong(buffer, 0xad00BB9A340da287);

            AmqpBitConverter.WriteFloat(buffer, 12344.4434F);
            AmqpBitConverter.WriteFloat(buffer, -12344.4434F);

            AmqpBitConverter.WriteDouble(buffer, 39432123244.44352334);
            AmqpBitConverter.WriteDouble(buffer, -39432123244.44352334);

            Guid uuid = Guid.NewGuid();

            AmqpBitConverter.WriteUuid(buffer, uuid);

            sbyte b  = AmqpBitConverter.ReadByte(buffer);
            sbyte b2 = AmqpBitConverter.ReadByte(buffer);

            byte ub  = AmqpBitConverter.ReadUByte(buffer);
            byte ub2 = AmqpBitConverter.ReadUByte(buffer);

            short s  = AmqpBitConverter.ReadShort(buffer);
            short s2 = AmqpBitConverter.ReadShort(buffer);

            ushort us  = AmqpBitConverter.ReadUShort(buffer);
            ushort us2 = AmqpBitConverter.ReadUShort(buffer);

            int i  = AmqpBitConverter.ReadInt(buffer);
            int i2 = AmqpBitConverter.ReadInt(buffer);

            uint ui  = AmqpBitConverter.ReadUInt(buffer);
            uint ui2 = AmqpBitConverter.ReadUInt(buffer);

            long l  = AmqpBitConverter.ReadLong(buffer);
            long l2 = AmqpBitConverter.ReadLong(buffer);

            ulong ul  = AmqpBitConverter.ReadULong(buffer);
            ulong ul2 = AmqpBitConverter.ReadULong(buffer);

            float f  = AmqpBitConverter.ReadFloat(buffer);
            float f2 = AmqpBitConverter.ReadFloat(buffer);

            double d  = AmqpBitConverter.ReadDouble(buffer);
            double d2 = AmqpBitConverter.ReadDouble(buffer);

            Guid uuid2 = AmqpBitConverter.ReadUuid(buffer);
        }
Пример #12
0
 public static void WriteUShort(ByteBuffer buffer, ushort value)
 {
     AmqpBitConverter.WriteUByte(buffer, FormatCode.UShort);
     AmqpBitConverter.WriteUShort(buffer, value);
 }