private void EmitFlagWord(bool continuationBit)
{
NetworkOrderSerializer.WriteUInt16(Memory.Slice(Offset).Span, (ushort)(continuationBit ? (_flagWord | 1) : _flagWord));
Offset += 2;
_flagWord = 0;
_bitCount = 0;
}
private void WriteBits()
{
NetworkOrderSerializer.WriteUInt16(Span, _bitAccumulator);
_offset += 2;
_bitMask = StartBitMask;
_bitAccumulator = 0;
}
internal override int WritePayload(Memory <byte> memory)
{
// write protocol class id (2 bytes)
NetworkOrderSerializer.WriteUInt16(memory, _header.ProtocolClassId);
// write header (X bytes)
int bytesWritten = _header.WriteTo(memory.Slice(2), (ulong)_bodyLength);
return(2 + bytesWritten);
}
internal void WriteTo(Memory <byte> memory)
{
memory.Span[0] = (byte)Type;
NetworkOrderSerializer.WriteUInt16(memory.Slice(1), (ushort)Channel);
int bytesWritten = WritePayload(memory.Slice(7));
NetworkOrderSerializer.WriteUInt32(memory.Slice(3), (uint)bytesWritten);
memory.Span[bytesWritten + 7] = Constants.FrameEnd;
ByteCount = bytesWritten + 8;
}
internal override int WritePayload(Memory <byte> memory)
{
NetworkOrderSerializer.WriteUInt16(memory, _method.ProtocolClassId);
NetworkOrderSerializer.WriteUInt16(memory.Slice(2), _method.ProtocolMethodId);
var argWriter = new MethodArgumentWriter(memory.Slice(4));
_method.WriteArgumentsTo(ref argWriter);
argWriter.Flush();
return(4 + argWriter.Offset);
}
public int WriteTo(Memory <byte> memory, ulong bodySize)
{
NetworkOrderSerializer.WriteUInt16(memory, ZERO); // Weight - not used
NetworkOrderSerializer.WriteUInt64(memory.Slice(2), bodySize);
ContentHeaderPropertyWriter writer = new ContentHeaderPropertyWriter(memory.Slice(10));
WritePropertiesTo(ref writer);
return(10 + writer.Offset);
}
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(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 void TestWriteUInt16()
{
byte[] bytes = new byte[2];
NetworkOrderSerializer.WriteUInt16(bytes, 0x89AB);
Check(bytes, new byte[] { 0x89, 0xAB });
}
public static int WriteShort(Memory <byte> memory, ushort val)
{
NetworkOrderSerializer.WriteUInt16(memory, val);
return(2);
}
public static int WriteShort(Span <byte> span, ushort val)
{
NetworkOrderSerializer.WriteUInt16(span, val);
return(2);
}
public void TestWriteUInt16()
{
byte[] bytes = new byte[2];
NetworkOrderSerializer.WriteUInt16(ref bytes.AsSpan().GetStart(), 0x89AB);
Check(bytes, new byte[] { 0x89, 0xAB });
}
