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); }
ByteBuffer IIoHandler.CreateBuffer(int frameSize) { var buffer = new ByteBuffer(frameSize, false); AmqpBitConverter.WriteUInt(buffer, (uint)frameSize); return(buffer); }
public void Encode(ByteBuffer buffer) { AmqpBitConverter.WriteUInt(buffer, AmqpPrefix); AmqpBitConverter.WriteUByte(buffer, (byte)this.protocolId); AmqpBitConverter.WriteUByte(buffer, this.version.Major); AmqpBitConverter.WriteUByte(buffer, this.version.Minor); AmqpBitConverter.WriteUByte(buffer, this.version.Revision); }
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); }
private void SetReadFrameBody(int frameSize) { ByteBuffer byteBuffer = new ByteBuffer(frameSize, false, false); AmqpBitConverter.WriteUInt(byteBuffer, (uint)frameSize); this.readState = AsyncIO.AsyncReader.ReadState.FrameBody; this.remainingBytes = byteBuffer.Size; this.readAsyncEventArgs.SetBuffer(byteBuffer.Buffer, byteBuffer.Length, this.remainingBytes); this.readAsyncEventArgs.UserToken2 = byteBuffer; }
public override void EncodeObject(object value, bool arrayEncoding, ByteBuffer buffer) { if (arrayEncoding) { AmqpBitConverter.WriteUInt(buffer, (uint)value); } else { UIntEncoding.Encode((uint)value, buffer); } }
public static void WriteList(ByteBuffer buffer, IList value, bool smallEncoding) { if (value == null) { AmqpBitConverter.WriteUByte(buffer, FormatCode.Null); } else { // trim tailing nulls int last = value.Count - 1; while (last >= 0 && value[last] == null) { --last; } if (last < 0 && smallEncoding) { AmqpBitConverter.WriteUByte(buffer, FormatCode.List0); } else { int pos = buffer.WritePos; AmqpBitConverter.WriteUByte(buffer, 0); AmqpBitConverter.WriteUInt(buffer, 0); AmqpBitConverter.WriteUInt(buffer, 0); for (int i = 0; i <= last; ++i) { Encoder.WriteObject(buffer, value[i], smallEncoding); } int size = buffer.WritePos - pos - 9; int count = last + 1; if (smallEncoding && size < byte.MaxValue && count <= byte.MaxValue) { buffer.Buffer[pos] = FormatCode.List8; buffer.Buffer[pos + 1] = (byte)(size + 1); buffer.Buffer[pos + 2] = (byte)count; Array.Copy(buffer.Buffer, pos + 9, buffer.Buffer, pos + 3, size); buffer.Shrink(6); } else { buffer.Buffer[pos] = FormatCode.List32; AmqpBitConverter.WriteInt(buffer.Buffer, pos + 1, size + 4); AmqpBitConverter.WriteInt(buffer.Buffer, pos + 5, count); } } } }
public static void WriteArray(ByteBuffer buffer, Array value) { if (value == null) { AmqpBitConverter.WriteUByte(buffer, FormatCode.Null); } else { int count = value.Length; Fx.Assert(count > 0, "must have at least 1 element in array"); int pos = buffer.WritePos; AmqpBitConverter.WriteUByte(buffer, 0); AmqpBitConverter.WriteUInt(buffer, 0); AmqpBitConverter.WriteUInt(buffer, 0); for (int i = 0; i < count; ++i) { object item = value.GetValue(i); if (i == 0) { Encoder.WriteObject(buffer, item, false); } else { int lastPos = buffer.WritePos - 1; byte lastByte = buffer.Buffer[lastPos]; buffer.Shrink(1); Encoder.WriteObject(buffer, item, false); buffer.Buffer[lastPos] = lastByte; } } int size = buffer.WritePos - pos - 9; if (size < byte.MaxValue && count <= byte.MaxValue) { buffer.Buffer[pos] = FormatCode.Array8; buffer.Buffer[pos + 1] = (byte)(size + 1); buffer.Buffer[pos + 2] = (byte)count; Array.Copy(buffer.Buffer, pos + 9, buffer.Buffer, pos + 3, size); buffer.Shrink(6); } else { buffer.Buffer[pos] = FormatCode.Array32; AmqpBitConverter.WriteInt(buffer.Buffer, pos + 1, size + 4); AmqpBitConverter.WriteInt(buffer.Buffer, pos + 5, count); } } }
protected override void EncodeBody(ByteBuffer buffer) { int pos = buffer.WritePos; buffer.Validate(true, 8); buffer.Append(8); int length = 0; long streamPos = this.bodyStream.CanSeek ? this.bodyStream.Position : -1; try { while (true) { buffer.Validate(true, 512); int size = this.bodyStream.Read(buffer.Buffer, buffer.WritePos, 512); if (size == 0) { break; } buffer.Append(size); length += size; } } finally { if (this.bodyStream.CanSeek) { this.bodyStream.Position = streamPos; } } AmqpBitConverter.WriteUByte(buffer.Buffer, pos, FormatCode.Described); AmqpBitConverter.WriteUByte(buffer.Buffer, pos + 1, FormatCode.SmallULong); AmqpBitConverter.WriteUByte(buffer.Buffer, pos + 2, (byte)Data.Code); AmqpBitConverter.WriteUByte(buffer.Buffer, pos + 3, FormatCode.Binary32); AmqpBitConverter.WriteUInt(buffer.Buffer, pos + 4, (uint)length); this.bodyOffset = pos; this.bodyLength = buffer.WritePos - pos; this.dataList = new Data[] { new Data() { Value = new ArraySegment <byte>(buffer.Buffer, pos, length), Offset = pos, Length = length } }; }
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 WriteUInt(ByteBuffer buffer, uint value, bool smallEncoding) { if (!smallEncoding || value > byte.MaxValue) { AmqpBitConverter.WriteUByte(buffer, FormatCode.UInt); AmqpBitConverter.WriteUInt(buffer, value); } else if (value == 0) { AmqpBitConverter.WriteUByte(buffer, FormatCode.UInt0); } else if (value <= byte.MaxValue) { AmqpBitConverter.WriteUByte(buffer, FormatCode.SmallUInt); AmqpBitConverter.WriteUByte(buffer, (byte)value); } }
internal override void EncodeValue(ByteBuffer buffer) { if (this.FieldCount == 0) { AmqpBitConverter.WriteUByte(buffer, FormatCode.List0); } else { int valueSize = this.OnValueSize(); int encodeWidth = AmqpEncoding.GetEncodeWidthByCountAndSize(this.FieldCount, valueSize); int sizeOffset; if (encodeWidth == FixedWidth.UByte) { AmqpBitConverter.WriteUByte(buffer, FormatCode.List8); sizeOffset = buffer.Length; AmqpBitConverter.WriteUByte(buffer, 0); AmqpBitConverter.WriteUByte(buffer, (byte)this.FieldCount); } else { AmqpBitConverter.WriteUByte(buffer, FormatCode.List32); sizeOffset = buffer.Length; AmqpBitConverter.WriteUInt(buffer, 0); AmqpBitConverter.WriteUInt(buffer, (uint)this.FieldCount); } this.OnEncode(buffer); // the actual encoded value size may be different from the calculated // valueSize. However, it can only become smaller. This allows for // reserving space in the buffer using the longest encoding form of a // value. For example, if the delivery id of a transfer is unknown, we // can use uint.Max for calculating encode size, but the actual encoding // could be small uint. int size = buffer.Length - sizeOffset - encodeWidth; if (encodeWidth == FixedWidth.UByte) { AmqpBitConverter.WriteUByte(buffer.Buffer, sizeOffset, (byte)size); } else { AmqpBitConverter.WriteUInt(buffer.Buffer, sizeOffset, (uint)size); } } }
unsafe public void Write(byte[] buffer, int offset, int count, Action <object> callback, object state) { if (this.parent.encoding) { this.WriteTransferFrame(buffer, offset, count, callback, state); } else { ByteBuffer byteBuffer = ByteBuffer.Wrap(Frame.HeaderSize); AmqpBitConverter.WriteUInt(byteBuffer, (uint)(Frame.HeaderSize + count)); byteBuffer.Append(4); this.AsyncIO.Writer.WriteBuffer( byteBuffer.Array, new ArraySegment <byte>[] { new ArraySegment <byte>(buffer, offset, count) }, callback, state); } }
public static void WriteBinary(ByteBuffer buffer, byte[] value, bool smallEncoding) { if (value == null) { AmqpBitConverter.WriteUByte(buffer, FormatCode.Null); } else if (smallEncoding && value.Length <= byte.MaxValue) { AmqpBitConverter.WriteUByte(buffer, FormatCode.Binary8); AmqpBitConverter.WriteUByte(buffer, (byte)value.Length); AmqpBitConverter.WriteBytes(buffer, value, 0, value.Length); } else { AmqpBitConverter.WriteUByte(buffer, FormatCode.Binary32); AmqpBitConverter.WriteUInt(buffer, (uint)value.Length); AmqpBitConverter.WriteBytes(buffer, value, 0, value.Length); } }
public override void WriteObject(ByteBuffer buffer, object graph) { if (graph == null) { AmqpEncoding.EncodeNull(buffer); return; } if (!this.WriteFormatCode(buffer)) { return; } int writePos = buffer.WritePos; AmqpBitConverter.WriteULong(buffer, (ulong)0); int num = this.WriteMembers(buffer, graph); AmqpBitConverter.WriteUInt(buffer.Buffer, writePos, (uint)(buffer.WritePos - writePos - 4)); AmqpBitConverter.WriteUInt(buffer.Buffer, writePos + 4, (uint)num); }
public static ArraySegment <byte> GetEncodedPrefix(int valueLength) { int num; byte[] code = new byte[] { 0, 83, (byte)Data.Code, 0, 0, 0, 0, 0 }; byte[] numArray = code; if (valueLength > 255) { numArray[3] = 176; AmqpBitConverter.WriteUInt(numArray, 4, (uint)valueLength); num = 8; } else { numArray[3] = 160; numArray[4] = (byte)valueLength; num = 5; } return(new ArraySegment <byte>(numArray, 0, num)); }
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); }
public static ArraySegment <byte> GetEncodedPrefix(int valueLength) { byte[] buffer = new byte[8] { FormatCode.Described, FormatCode.SmallULong, (byte)Data.Code, 0x00, 0x00, 0x00, 0x00, 0x00 }; int count; if (valueLength <= byte.MaxValue) { buffer[3] = FormatCode.Binary8; buffer[4] = (byte)valueLength; count = 5; } else { buffer[3] = FormatCode.Binary32; AmqpBitConverter.WriteUInt(buffer, 4, (uint)valueLength); count = 8; } return(new ArraySegment <byte>(buffer, 0, count)); }
public override void WriteObject(ByteBuffer buffer, object graph) { if (graph == null) { AmqpEncoding.EncodeNull(buffer); return; } if (!this.WriteFormatCode(buffer)) { return; } int pos = buffer.WritePos; // remember the current position AmqpBitConverter.WriteULong(buffer, 0); // reserve space for size and count int count = this.WriteMembers(buffer, graph); AmqpBitConverter.WriteUInt(buffer.Buffer, pos, (uint)(buffer.WritePos - pos - FixedWidth.UInt)); AmqpBitConverter.WriteUInt(buffer.Buffer, pos + FixedWidth.UInt, (uint)count); }
protected override void OnWriteObject(ByteBuffer buffer, object graph) { if (graph == null) { AmqpEncoding.EncodeNull(buffer); return; } AmqpBitConverter.WriteUByte(buffer, (byte)FormatCode.Described); if (this.descriptorName.Value != null) { SymbolEncoding.Encode(this.descriptorName, buffer); } else { ULongEncoding.Encode(this.descriptorCode, buffer); } if (this.members.Length == 0) { AmqpBitConverter.WriteUByte(buffer, (byte)FormatCode.List0); return; } AmqpBitConverter.WriteUByte(buffer, (byte)FormatCode.List32); int endCopy = buffer.End; // remember the current position AmqpBitConverter.WriteUInt(buffer, 0); // reserve space for list size AmqpBitConverter.WriteUInt(buffer, (uint)this.members.Length); for (int i = 0; i < this.members.Length; ++i) { object memberValue = this.members[i].Accessor.ReadObject(graph); this.members[i].Type.OnWriteObject(buffer, memberValue); } // write the correct size AmqpBitConverter.WriteUInt(buffer.Buffer, endCopy, (uint)(buffer.End - endCopy - FixedWidth.UInt)); }
protected override void EncodeValue(ByteBuffer buffer, bool arrayEncoding) { int pos = buffer.WriteOffset; // initial values for ctor, size, length AmqpBitConverter.WriteUByte(buffer, 0); AmqpBitConverter.WriteUInt(buffer, 0); AmqpBitConverter.WriteUInt(buffer, 0); var propertyCount = GetEncodablePropertyCount(GetType()); int lastNotNullIndex = -1; int lastNotNullBufferWriteOffset = buffer.WriteOffset; var thisType = GetType(); for (int i = 0; i < propertyCount; i++) { var encoderFunc = GetEncoderDelegate(thisType, i); var valueWasNull = encoderFunc(this, buffer, arrayEncoding); // returns true if the value == null, false otherwise if (!valueWasNull || i == 0) { lastNotNullIndex = i; lastNotNullBufferWriteOffset = buffer.WriteOffset; } } // rewind the buffer to just after we wrote the last not-null value var listLength = lastNotNullIndex + 1; buffer.AdjustWriteOffset(lastNotNullBufferWriteOffset); int size = buffer.WriteOffset - pos - 9; // recalculate list size // set ctor, size, length buffer.Buffer[pos] = FormatCode.List32; AmqpBitConverter.WriteInt(buffer.Buffer, pos + 1, size + 4); AmqpBitConverter.WriteInt(buffer.Buffer, pos + 5, listLength); }
public static void WriteMap(ByteBuffer buffer, Map value, bool smallEncoding) { if (value == null) { AmqpBitConverter.WriteUByte(buffer, FormatCode.Null); } else { int pos = buffer.WritePos; AmqpBitConverter.WriteUByte(buffer, 0); AmqpBitConverter.WriteUInt(buffer, 0); AmqpBitConverter.WriteUInt(buffer, 0); foreach (var key in value.Keys) { Encoder.WriteObject(buffer, key); Encoder.WriteObject(buffer, value[key]); } int size = buffer.WritePos - pos - 9; int count = value.Count * 2; if (smallEncoding && size < byte.MaxValue && count <= byte.MaxValue) { buffer.Buffer[pos] = FormatCode.Map8; buffer.Buffer[pos + 1] = (byte)(size + 1); buffer.Buffer[pos + 2] = (byte)count; Array.Copy(buffer.Buffer, pos + 9, buffer.Buffer, pos + 3, size); buffer.Shrink(6); } else { buffer.Buffer[pos] = FormatCode.Map32; AmqpBitConverter.WriteInt(buffer.Buffer, pos + 1, size + 4); AmqpBitConverter.WriteInt(buffer.Buffer, pos + 5, count); } } }
public static void WriteSymbol(ByteBuffer buffer, Symbol value, bool smallEncoding) { if (value == null) { AmqpBitConverter.WriteUByte(buffer, FormatCode.Null); } else { byte[] data = Encoding.UTF8.GetBytes(value); if (smallEncoding && data.Length <= byte.MaxValue) { AmqpBitConverter.WriteUByte(buffer, FormatCode.Symbol8); AmqpBitConverter.WriteUByte(buffer, (byte)data.Length); AmqpBitConverter.WriteBytes(buffer, data, 0, data.Length); } else { AmqpBitConverter.WriteUByte(buffer, FormatCode.Symbol32); AmqpBitConverter.WriteUInt(buffer, (uint)data.Length); AmqpBitConverter.WriteBytes(buffer, data, 0, data.Length); } } }
public static void Encode(uint?value, ByteBuffer buffer) { if (value.HasValue) { if (value == 0) { AmqpBitConverter.WriteUByte(buffer, (byte)FormatCode.UInt0); } else if (value.Value <= byte.MaxValue) { AmqpBitConverter.WriteUByte(buffer, (byte)FormatCode.SmallUInt); AmqpBitConverter.WriteUByte(buffer, (byte)value.Value); } else { AmqpBitConverter.WriteUByte(buffer, (byte)FormatCode.UInt); AmqpBitConverter.WriteUInt(buffer, value.Value); } } else { AmqpEncoding.EncodeNull(buffer); } }
public override void EncodeValue(ByteBuffer buffer) { int length; if (this.FieldCount == 0) { AmqpBitConverter.WriteUByte(buffer, 69); return; } int num = this.OnValueSize(); int encodeWidthByCountAndSize = AmqpEncoding.GetEncodeWidthByCountAndSize(this.FieldCount, num); if (encodeWidthByCountAndSize != 1) { AmqpBitConverter.WriteUByte(buffer, 208); length = buffer.Length; buffer.Append(4); AmqpBitConverter.WriteUInt(buffer, (uint)this.FieldCount); } else { AmqpBitConverter.WriteUByte(buffer, 192); length = buffer.Length; buffer.Append(1); AmqpBitConverter.WriteUByte(buffer, (byte)this.FieldCount); } this.OnEncode(buffer); int length1 = buffer.Length - length - encodeWidthByCountAndSize; if (encodeWidthByCountAndSize != 1) { AmqpBitConverter.WriteUInt(buffer.Buffer, length, (uint)length1); return; } AmqpBitConverter.WriteUByte(buffer.Buffer, length, (byte)length1); }
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); }