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);
}
