public static ByteBuffer Encode(FrameType type, ushort channel, Transfer transfer,
ByteBuffer payload, int maxFrameSize, out int payloadSize)
{
int bufferSize = cmdBufferSize + payload.Length;
if (bufferSize > maxFrameSize)
{
bufferSize = maxFrameSize;
}
bool more = false; // estimate it first
if (payload.Length > bufferSize - 32)
{
transfer.More = more = true;
}
ByteBuffer buffer = new ByteBuffer(bufferSize, false);
EncodeFrame(buffer, type, channel, transfer);
if (more && payload.Length <= buffer.Size)
{
// guessed it wrong. correct it
transfer.More = false;
buffer.Reset();
EncodeFrame(buffer, type, channel, transfer);
}
payloadSize = Math.Min(payload.Length, buffer.Size);
AmqpBitConverter.WriteBytes(buffer, payload.Buffer, payload.Offset, payloadSize);
payload.Complete(payloadSize);
AmqpBitConverter.WriteInt(buffer.Buffer, 0, buffer.Length);
return buffer;
}
public static sbyte ReadByte(ByteBuffer buffer)
{
buffer.Validate(false, FixedWidth.Byte);
sbyte data = (sbyte)buffer.Buffer[buffer.Offset];
buffer.Complete(FixedWidth.Byte);
return data;
}
public void Decode(ByteBuffer buffer)
{
byte[] bytes = new byte[16];
Buffer.BlockCopy(buffer.Buffer, buffer.Offset, bytes, 0, bytes.Length);
this.uuid = new Guid(bytes);
buffer.Complete(bytes.Length);
}
public static byte ReadUByte(ByteBuffer buffer)
{
buffer.EnsureLength(FixedWidth.UByte);
byte data = buffer.Buffer[buffer.Offset];
buffer.Complete(FixedWidth.UByte);
return data;
}
public static uint ReadUInt(ByteBuffer buffer)
{
buffer.Validate(false, FixedWidth.UInt);
uint data = ReadUInt(buffer.Buffer, buffer.Offset, buffer.Length);
buffer.Complete(FixedWidth.UInt);
return data;
}
public static ArraySegment<byte> Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return AmqpConstants.EmptyBinary;
}
int count;
AmqpEncoding.ReadCount(buffer, formatCode, FormatCode.Binary8, FormatCode.Binary32, out count);
ArraySegment<byte> value = new ArraySegment<byte>(buffer.Buffer, buffer.Offset, count);
buffer.Complete(count);
return value;
}
public static short ReadShort(ByteBuffer buffer)
{
buffer.Validate(false, FixedWidth.Short);
short data;
fixed (byte* p = &buffer.Buffer[buffer.Offset])
{
byte* d = (byte*)&data;
d[0] = p[1];
d[1] = p[0];
}
buffer.Complete(FixedWidth.Short);
return data;
}
public static ushort ReadUShort(ByteBuffer buffer)
{
buffer.EnsureLength(FixedWidth.UShort);
ushort data;
fixed (byte* p = &buffer.Buffer[buffer.Offset])
{
byte* d = (byte*)&data;
d[0] = p[1];
d[1] = p[0];
}
buffer.Complete(FixedWidth.UShort);
return data;
}
public static int ReadInt(ByteBuffer buffer)
{
buffer.EnsureLength(FixedWidth.Int);
int data;
fixed (byte* p = &buffer.Buffer[buffer.Offset])
{
byte* d = (byte*)&data;
d[0] = p[3];
d[1] = p[2];
d[2] = p[1];
d[3] = p[0];
}
buffer.Complete(FixedWidth.Int);
return data;
}
protected bool TryDecodeNull(ByteBuffer buffer)
{
buffer.Validate(false, FixedWidth.FormatCode);
byte formatCode = buffer.Buffer[buffer.Offset];
if (formatCode == FormatCode.Null)
{
buffer.Complete(FixedWidth.FormatCode);
return true;
}
else
{
return false;
}
}
void DecodeHeader(ByteBuffer buffer)
{
this.Size = (int)AmqpBitConverter.ReadUInt(buffer);
this.DataOffset = AmqpBitConverter.ReadUByte(buffer);
this.Type = (FrameType)AmqpBitConverter.ReadUByte(buffer);
this.Channel = AmqpBitConverter.ReadUShort(buffer);
// skip extended header
buffer.Complete(this.DataOffset * 4 - Frame.HeaderSize);
}
public static Frame Decode(ByteBuffer buffer, bool fullBody = true)
{
Frame frame = new Frame();
frame.RawBuffer = buffer.Array;
// Header
frame.size = (int)AmqpBitConverter.ReadUInt(buffer);
frame.dataOffset = AmqpBitConverter.ReadUByte(buffer);
frame.Type = (FrameType)AmqpBitConverter.ReadUByte(buffer);
frame.Channel = AmqpBitConverter.ReadUShort(buffer);
// skip extended header
buffer.Complete(frame.dataOffset * 4 - Frame.HeaderSize);
// Command
if (buffer.Length > 0)
{
frame.Command = (Performative)AmqpCodec.CreateAmqpDescribed(buffer);
if (fullBody)
{
frame.Command.DecodeValue(buffer);
}
}
return frame;
}
public static double ReadDouble(ByteBuffer buffer)
{
buffer.EnsureLength(FixedWidth.Double);
double data;
fixed (byte* p = &buffer.Buffer[buffer.Offset])
{
byte* d = (byte*)&data;
d[0] = p[7];
d[1] = p[6];
d[2] = p[5];
d[3] = p[4];
d[4] = p[3];
d[5] = p[2];
d[6] = p[1];
d[7] = p[0];
}
buffer.Complete(FixedWidth.Double);
return data;
}
public static Guid ReadUuid(ByteBuffer buffer)
{
buffer.EnsureLength(FixedWidth.Uuid);
Guid data;
fixed (byte* p = &buffer.Buffer[buffer.Offset])
{
byte* d = (byte*)&data;
d[0] = p[3];
d[1] = p[2];
d[2] = p[1];
d[3] = p[0];
d[4] = p[5];
d[5] = p[4];
d[6] = p[7];
d[7] = p[6];
*((ulong*)&d[8]) = *((ulong*)&p[8]);
}
buffer.Complete(FixedWidth.Uuid);
return data;
}
public override object ReadObject(ByteBuffer buffer)
{
FormatCode formatCode = AmqpEncoding.ReadFormatCode(buffer);
if (formatCode == FormatCode.Null)
{
return null;
}
int size;
int count;
int encodeWidth;
Collection effectiveType;
this.Initialize(buffer, formatCode, out size, out count, out encodeWidth, out effectiveType);
int offset = buffer.Offset;
object container = effectiveType.CreateInstance();
if (count > 0)
{
effectiveType.ReadMembers(buffer, container, ref count);
if (count > 0)
{
// skip unknow members: todo: support IExtensibleDataObject
buffer.Complete(size - (buffer.Offset - offset) - encodeWidth);
}
}
return container;
}
public static ulong ReadULong(ByteBuffer buffer)
{
buffer.EnsureLength(FixedWidth.ULong);
ulong data = ReadULong(buffer.Buffer, buffer.Offset, buffer.Length);
buffer.Complete(FixedWidth.ULong);
return data;
}
static string ReadString(ByteBuffer buffer, byte formatCode, byte code8, byte code32, string type)
{
if (formatCode == FormatCode.Null)
{
return null;
}
int count;
if (formatCode == code8)
{
count = AmqpBitConverter.ReadUByte(buffer);
}
else if (formatCode == code32)
{
count = (int)AmqpBitConverter.ReadUInt(buffer);
}
else
{
throw DecodeException(formatCode, buffer.Offset);
}
buffer.Validate(false, count);
string value = new string(Encoding.UTF8.GetChars(buffer.Buffer, buffer.Offset, count));
buffer.Complete(count);
return value;
}
public override object ReadObject(ByteBuffer buffer)
{
buffer.Validate(false, FixedWidth.FormatCode);
FormatCode formatCode = buffer.Buffer[buffer.Offset];
if (formatCode == FormatCode.Null)
{
buffer.Complete(FixedWidth.FormatCode);
return null;
}
else
{
object container = this.CreateInstance();
((IAmqpSerializable)container).Decode(buffer);
return container;
}
}
public static long ReadLong(ByteBuffer buffer)
{
buffer.Validate(false, FixedWidth.Long);
long data;
fixed (byte* p = &buffer.Buffer[buffer.Offset])
{
byte* d = (byte*)&data;
d[0] = p[7];
d[1] = p[6];
d[2] = p[5];
d[3] = p[4];
d[4] = p[3];
d[5] = p[2];
d[6] = p[1];
d[7] = p[0];
}
buffer.Complete(FixedWidth.Long);
return data;
}
/// <summary>
/// Reads a binary value from a buffer.
/// </summary>
/// <param name="buffer">The buffer to read.</param>
/// <param name="formatCode">The format code of the value.</param>
public static byte[] ReadBinary(ByteBuffer buffer, byte formatCode)
{
if (formatCode == FormatCode.Null)
{
return null;
}
int count;
if (formatCode == FormatCode.Binary8)
{
count = AmqpBitConverter.ReadUByte(buffer);
}
else if (formatCode == FormatCode.Binary32)
{
count = (int)AmqpBitConverter.ReadUInt(buffer);
}
else
{
throw DecodeException(formatCode, buffer.Offset);
}
buffer.Validate(false, count);
byte[] value = new byte[count];
Array.Copy(buffer.Buffer, buffer.Offset, value, 0, count);
buffer.Complete(count);
return value;
}
public override object ReadObject(ByteBuffer buffer)
{
byte formatCode = Encoder.ReadFormatCode(buffer);
if (formatCode == FormatCode.Null)
{
return null;
}
int size;
int count;
int encodeWidth;
CollectionType effectiveType;
this.Initialize(buffer, formatCode, out size, out count, out encodeWidth, out effectiveType);
int offset = buffer.Offset;
object container = effectiveType.hasDefaultCtor ?
Activator.CreateInstance(effectiveType.type) :
FormatterServices.GetUninitializedObject(effectiveType.type);
if (count > 0)
{
effectiveType.ReadMembers(buffer, container, ref count);
if (count > 0)
{
// skip unknow members
buffer.Complete(size - (buffer.Offset - offset) - encodeWidth);
}
}
return container;
}
public override object ReadObject(ByteBuffer buffer)
{
buffer.Validate(false, FixedWidth.FormatCode);
byte formatCode = buffer.Buffer[buffer.Offset];
if (formatCode == FormatCode.Null)
{
buffer.Complete(FixedWidth.FormatCode);
return null;
}
else
{
object value = this.type.CreateInstance(this.hasDefaultCtor);
((IAmqpSerializable)value).Decode(buffer);
return value;
}
}
internal static ByteBuffer ReadBinaryBuffer(ByteBuffer buffer)
{
byte formatCode = Encoder.ReadFormatCode(buffer);
if (formatCode == FormatCode.Null)
{
return null;
}
int count;
if (formatCode == FormatCode.Binary8)
{
count = AmqpBitConverter.ReadUByte(buffer);
}
else if (formatCode == FormatCode.Binary32)
{
count = (int)AmqpBitConverter.ReadUInt(buffer);
}
else
{
throw InvalidFormatCodeException(formatCode, buffer.Offset);
}
buffer.Validate(false, count);
ByteBuffer result = new ByteBuffer(buffer.Buffer, buffer.Offset, count, count);
buffer.Complete(count);
return result;
}
public static float ReadFloat(ByteBuffer buffer)
{
buffer.Validate(false, FixedWidth.Float);
float data;
fixed (byte* p = &buffer.Buffer[buffer.Offset])
{
byte* d = (byte*)&data;
d[0] = p[3];
d[1] = p[2];
d[2] = p[1];
d[3] = p[0];
}
buffer.Complete(FixedWidth.Float);
return data;
}
public static void ReadBytes(ByteBuffer buffer, byte[] data, int offset, int count)
{
buffer.Validate(false, count);
Buffer.BlockCopy(buffer.Buffer, buffer.Offset, data, offset, count);
buffer.Complete(count);
}