public static unsafe int WriteLongstr(Span <byte> span, string val)
{
fixed(char *chars = val)
fixed(byte *bytes = &span.Slice(4).GetPinnableReference())
{
int bytesWritten = Encoding.UTF8.GetBytes(chars, val.Length, bytes, span.Length);
NetworkOrderSerializer.WriteUInt32(span, (uint)bytesWritten);
return(bytesWritten + 4);
}
}
private static int WriteBaseFrame(Span <byte> span, FrameType type, ushort channel, int payloadLength)
{
const int StartFrameType = 0;
const int StartChannel = 1;
const int StartPayloadSize = 3;
span[StartFrameType] = (byte)type;
NetworkOrderSerializer.WriteUInt16(span.Slice(StartChannel), channel);
NetworkOrderSerializer.WriteUInt32(span.Slice(StartPayloadSize), (uint)payloadLength);
span[StartPayload + payloadLength] = Constants.FrameEnd;
return(StartPayload + 1 + payloadLength);
}
public static int WriteTo <T>(Span <byte> span, ushort channel, ref T method) where T : struct, IOutgoingAmqpMethod
{
const int StartClassId = StartPayload;
const int StartMethodArguments = StartClassId + 4;
int payloadLength = method.WriteTo(span.Slice(StartMethodArguments)) + 4;
NetworkOrderSerializer.WriteUInt64(ref span.GetStart(), ((ulong)Constants.FrameMethod << 56) | ((ulong)channel << 40) | ((ulong)payloadLength << 8));
NetworkOrderSerializer.WriteUInt32(ref span.GetOffset(StartClassId), (uint)method.ProtocolCommandId);
span[payloadLength + StartPayload] = Constants.FrameEnd;
return(payloadLength + BaseFrameSize);
}
public static int WriteTo(Span <byte> span, ushort channel, MethodBase method)
{
const int StartClassId = StartPayload;
const int StartMethodId = StartPayload + 2;
const int StartMethodArguments = StartPayload + 4;
NetworkOrderSerializer.WriteUInt16(span.Slice(StartClassId), method.ProtocolClassId);
NetworkOrderSerializer.WriteUInt16(span.Slice(StartMethodId), method.ProtocolMethodId);
var argWriter = new MethodArgumentWriter(span.Slice(StartMethodArguments));
method.WriteArgumentsTo(ref argWriter);
return(WriteBaseFrame(span, FrameType.FrameMethod, channel, StartMethodArguments - StartPayload + argWriter.Offset));
}
public static int WriteTo(Span <byte> span, ushort channel, ContentHeaderBase header, int bodyLength)
{
const int StartClassId = StartPayload;
const int StartWeight = StartPayload + 2;
const int StartBodyLength = StartPayload + 4;
const int StartHeaderArguments = StartPayload + 12;
NetworkOrderSerializer.WriteUInt16(span.Slice(StartClassId), header.ProtocolClassId);
NetworkOrderSerializer.WriteUInt16(span.Slice(StartWeight), 0); // Weight - not used
NetworkOrderSerializer.WriteUInt64(span.Slice(StartBodyLength), (ulong)bodyLength);
int offset = header.WritePropertiesTo(span.Slice(StartHeaderArguments));
return(WriteBaseFrame(span, FrameType.FrameHeader, channel, StartHeaderArguments - StartPayload + offset));
}
public static int WriteTo <T>(Span <byte> span, ushort channel, ref T header, int bodyLength) where T : IAmqpHeader
{
const int StartClassId = StartPayload;
const int StartBodyLength = StartPayload + 4;
const int StartHeaderArguments = StartPayload + 12;
int payloadLength = 12 + header.WriteTo(span.Slice(StartHeaderArguments));
NetworkOrderSerializer.WriteUInt64(ref span.GetStart(), ((ulong)Constants.FrameHeader << 56) | ((ulong)channel << 40) | ((ulong)payloadLength << 8));
NetworkOrderSerializer.WriteUInt32(ref span.GetOffset(StartClassId), (uint)header.ProtocolClassId << 16); // The last 16 bytes (Weight) aren't used
NetworkOrderSerializer.WriteUInt64(ref span.GetOffset(StartBodyLength), (ulong)bodyLength);
span[payloadLength + StartPayload] = Constants.FrameEnd;
return(payloadLength + BaseFrameSize);
}
public static int WriteArray(Span <byte> span, IList val)
{
if (val is null)
{
NetworkOrderSerializer.WriteUInt32(span, 0);
return(4);
}
int bytesWritten = 4;
for (int index = 0; index < val.Count; index++)
{
bytesWritten += WriteFieldValue(span.Slice(bytesWritten), val[index]);
}
NetworkOrderSerializer.WriteUInt32(span, (uint)bytesWritten - 4u);
return(bytesWritten);
}
public static int WriteArray(ref byte destination, IList val)
{
if (val is null || val.Count == 0)
{
NetworkOrderSerializer.WriteUInt32(ref destination, 0);
return(4);
}
int bytesWritten = 4;
for (int index = 0; index < val.Count; index++)
{
bytesWritten += WriteFieldValue(ref destination.GetOffset(bytesWritten), val[index]);
}
NetworkOrderSerializer.WriteUInt32(ref destination, (uint)bytesWritten - 4u);
return(bytesWritten);
}
public static int WriteArray(Memory <byte> memory, IList val)
{
if (val == null)
{
NetworkOrderSerializer.WriteUInt32(memory.Span, 0);
return(4);
}
else
{
int bytesWritten = 0;
for (int index = 0; index < val.Count; index++)
{
bytesWritten += WriteFieldValue(memory.Slice(4 + bytesWritten), val[index]);
}
NetworkOrderSerializer.WriteUInt32(memory.Span, (uint)bytesWritten);
return(4 + bytesWritten);
}
}
public static int WriteArray(Memory <byte> memory, IList val)
{
if (val == null)
{
NetworkOrderSerializer.WriteUInt32(memory, 0);
return(4);
}
else
{
int bytesWritten = 0;
foreach (object entry in val)
{
bytesWritten += WriteFieldValue(memory.Slice(4 + bytesWritten), entry);;
}
NetworkOrderSerializer.WriteUInt32(memory, (uint)bytesWritten);
return(4 + bytesWritten);
}
}
public static int WriteTable(Span <byte> span, IDictionary val)
{
if (val is null || val.Count == 0)
{
NetworkOrderSerializer.WriteUInt32(span, 0u);
return(4);
}
// Let's only write after the length header.
Span <byte> slice = span.Slice(4);
int bytesWritten = 0;
foreach (DictionaryEntry entry in val)
{
bytesWritten += WriteShortstr(slice.Slice(bytesWritten), entry.Key.ToString());
bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);
}
NetworkOrderSerializer.WriteUInt32(span, (uint)bytesWritten);
return(4 + bytesWritten);
}
public static int WriteTable(Memory <byte> memory, IDictionary <string, object> val)
{
if (val == null)
{
NetworkOrderSerializer.WriteUInt32(memory, 0);
return(4);
}
else
{
// Let's only write after the length header.
Memory <byte> slice = memory.Slice(4);
int bytesWritten = 0;
foreach (KeyValuePair <string, object> entry in val)
{
bytesWritten += WriteShortstr(slice.Slice(bytesWritten), entry.Key.ToString());
bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);
}
NetworkOrderSerializer.WriteUInt32(memory, (uint)bytesWritten);
return(4 + bytesWritten);
}
}
public void TestWriteUInt64()
{
byte[] bytes = new byte[8];
NetworkOrderSerializer.WriteUInt64(bytes, 0x89ABCDEF01234567);
Check(bytes, new byte[] { 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67 });
}
public void TestWriteInt64_negative()
{
byte[] bytes = new byte[8];
NetworkOrderSerializer.WriteInt64(bytes, -0x123456789ABCDEF0);
Check(bytes, new byte[] { 0xED, 0xCB, 0xA9, 0x87, 0x65, 0x43, 0x21, 0x10 });
}
public void TestWriteInt64_positive()
{
byte[] bytes = new byte[8];
NetworkOrderSerializer.WriteInt64(bytes, 0x123456789ABCDEF0);
Check(bytes, new byte[] { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0 });
}
public void TestWriteUInt32()
{
byte[] bytes = new byte[4];
NetworkOrderSerializer.WriteUInt32(bytes, 0x89ABCDEF);
Check(bytes, new byte[] { 0x89, 0xAB, 0xCD, 0xEF });
}
public void TestWriteInt32_negative()
{
byte[] bytes = new byte[4];
NetworkOrderSerializer.WriteInt32(bytes, -0x12345678);
Check(bytes, new byte[] { 0xED, 0xCB, 0xA9, 0x88 });
}
public void TestWriteInt32_positive()
{
byte[] bytes = new byte[4];
NetworkOrderSerializer.WriteInt32(bytes, 0x12345678);
Check(bytes, new byte[] { 0x12, 0x34, 0x56, 0x78 });
}
public void TestWriteUInt16()
{
byte[] bytes = new byte[2];
NetworkOrderSerializer.WriteUInt16(bytes, 0x89AB);
Check(bytes, new byte[] { 0x89, 0xAB });
}
public static int WriteLonglong(Memory <byte> memory, ulong val)
{
NetworkOrderSerializer.WriteUInt64(memory, val);
return(8);
}
public static int WriteShort(Memory <byte> memory, ushort val)
{
NetworkOrderSerializer.WriteUInt16(memory, val);
return(2);
}
public static int WriteLong(Span <byte> span, uint val)
{
NetworkOrderSerializer.WriteUInt32(span, val);
return(4);
}
public void TestWriteInt16_positive()
{
byte[] bytes = new byte[2];
NetworkOrderSerializer.WriteInt16(bytes, 0x1234);
Check(bytes, new byte[] { 0x12, 0x34 });
}
public void TestSingleEncoding()
{
byte[] bytes = new byte[4];
NetworkOrderSerializer.WriteSingle(bytes, 1.234f);
Check(bytes, _expectedSingleBytes);
}
public static int WriteShort(Span <byte> span, ushort val)
{
NetworkOrderSerializer.WriteUInt16(span, val);
return(2);
}
public static int WriteLonglong(Span <byte> span, ulong val)
{
NetworkOrderSerializer.WriteUInt64(span, val);
return(8);
}
public void TestDoubleEncoding()
{
byte[] bytes = new byte[8];
NetworkOrderSerializer.WriteDouble(bytes, 1.234);
Check(bytes, _expectedDoubleBytes);
}
public static int WriteFieldValue(Memory <byte> memory, object value)
{
if (value == null)
{
memory.Span[0] = (byte)'V';
return(1);
}
Memory <byte> slice = memory.Slice(1);
switch (value)
{
case string val:
memory.Span[0] = (byte)'S';
if (MemoryMarshal.TryGetArray(memory.Slice(5, Encoding.UTF8.GetByteCount(val)), out ArraySegment <byte> segment))
{
NetworkOrderSerializer.WriteUInt32(slice, (uint)segment.Count);
Encoding.UTF8.GetBytes(val, 0, val.Length, segment.Array, segment.Offset);
return(segment.Count + 5);
}
throw new WireFormattingException("Unable to get array segment from memory.");
case byte[] val:
memory.Span[0] = (byte)'S';
return(1 + WriteLongstr(slice, val));
case int val:
memory.Span[0] = (byte)'I';
NetworkOrderSerializer.WriteInt32(slice, val);
return(5);
case uint val:
memory.Span[0] = (byte)'i';
NetworkOrderSerializer.WriteUInt32(slice, val);
return(5);
case decimal val:
memory.Span[0] = (byte)'D';
return(1 + WriteDecimal(slice, val));
case AmqpTimestamp val:
memory.Span[0] = (byte)'T';
return(1 + WriteTimestamp(slice, val));
case IDictionary val:
memory.Span[0] = (byte)'F';
return(1 + WriteTable(slice, val));
case IList val:
memory.Span[0] = (byte)'A';
return(1 + WriteArray(slice, val));
case byte val:
memory.Span[0] = (byte)'B';
memory.Span[1] = val;
return(2);
case sbyte val:
memory.Span[0] = (byte)'b';
memory.Span[1] = (byte)val;
return(2);
case double val:
memory.Span[0] = (byte)'d';
NetworkOrderSerializer.WriteDouble(slice, val);
return(9);
case float val:
memory.Span[0] = (byte)'f';
NetworkOrderSerializer.WriteSingle(slice, val);
return(5);
case long val:
memory.Span[0] = (byte)'l';
NetworkOrderSerializer.WriteInt64(slice, val);
return(9);
case short val:
memory.Span[0] = (byte)'s';
NetworkOrderSerializer.WriteInt16(slice, val);
return(3);
case bool val:
memory.Span[0] = (byte)'t';
memory.Span[1] = (byte)(val ? 1 : 0);
return(2);
case BinaryTableValue val:
memory.Span[0] = (byte)'x';
return(1 + WriteLongstr(slice, val.Bytes));
default:
throw new WireFormattingException($"Value of type '{value.GetType().Name}' cannot appear as table value", value);
}
}
public void TestWriteInt16_negative()
{
byte[] bytes = new byte[2];
NetworkOrderSerializer.WriteInt16(bytes, -0x1234);
Check(bytes, new byte[] { 0xED, 0xCC });
}
public static int WriteLong(Memory <byte> memory, uint val)
{
NetworkOrderSerializer.WriteUInt32(memory, val);
return(4);
}
