private Tick?Extract()
{
if (BytesRemaining <= 0)
{
return(null);
}
var reader = new MessagePackReader(_parent.AsReadOnlySequence().Slice(_position));
if (_previousTick is null)
{
var price = reader.ReadDouble();
var bid = reader.ReadDouble();
var ask = reader.ReadDouble();
var volume = (double)(reader.ReadUInt32() * _minQtyIncrement);
var timeStamp = new TimeStamp((long)reader.ReadUInt64());
_position += reader.Consumed;
return(_previousTick = new Tick
{
Instrument = Instrument,
Price = price,
Bid = bid,
Ask = ask,
Volume = volume,
TimeStamp = timeStamp,
});
}
else
{
var price = _previousTick.Price.AddIncrements(_tickSize, reader.ReadInt32());
var bid = _previousTick.Bid.AddIncrements(_tickSize, reader.ReadInt32());
var ask = _previousTick.Ask.AddIncrements(_tickSize, reader.ReadInt32());
var volume = (double)(reader.ReadUInt32() * _minQtyIncrement);
var timeStamp = _previousTick.TimeStamp.AddTicks((long)reader.ReadUInt64());
_position += reader.Consumed;
return(_previousTick = new Tick
{
Instrument = Instrument,
Price = price,
Bid = bid,
Ask = ask,
Volume = volume,
TimeStamp = timeStamp,
});
}
}
internal void ReadExtensionMembers(ref MessagePackReader reader)
{
int count = reader.ReadMapHeader();
for (int i = 0; i < count; i++)
{
switch (reader.ReadInt32())
{
case TracingId:
if (this is IMessageWithTracingId withTracingId)
{
withTracingId.TracingId = reader.ReadUInt64();
}
break;
case Ttl:
if (this is IHasTtl hasTtl)
{
hasTtl.Ttl = reader.ReadInt32();
}
break;
case Protocol:
if (this is IHasProtocol hasProtocol)
{
hasProtocol.Protocol = reader.ReadString();
}
break;
// todo : more optional fields
default:
break;
}
}
}
public UInt64?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(reader.ReadUInt64());
}
public global::Shared.Message.LoginReq.Callback Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __code__ = default(global::Shared.Protocol.ErrCode);
var __arg1__ = default(string);
var __arg2__ = default(ulong);
var __arg3__ = default(string);
var __arg4__ = default(string);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__code__ = formatterResolver.GetFormatterWithVerify <global::Shared.Protocol.ErrCode>().Deserialize(ref reader, options);
break;
case 1:
__arg1__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 2:
__arg2__ = reader.ReadUInt64();
break;
case 3:
__arg3__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 4:
__arg4__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Shared.Message.LoginReq.Callback();
____result.code = __code__;
____result.arg1 = __arg1__;
____result.arg2 = __arg2__;
____result.arg3 = __arg3__;
____result.arg4 = __arg4__;
reader.Depth--;
return(____result);
}
public UInt64[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
var len = reader.ReadArrayHeader();
var array = new UInt64[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = reader.ReadUInt64();
}
return(array);
}
public global::GatewayServer.Packet.PKTReqLogin Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __UserID__ = default(string);
var __AuthToken__ = default(string);
var __UniqueIndex__ = default(ulong);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__UserID__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__AuthToken__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 2:
__UniqueIndex__ = reader.ReadUInt64();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::GatewayServer.Packet.PKTReqLogin();
____result.UserID = __UserID__;
____result.AuthToken = __AuthToken__;
____result.UniqueIndex = __UniqueIndex__;
reader.Depth--;
return(____result);
}
public void UInt64Test(ulong target, int length)
{
(MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker();
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
writer.Write(target);
writer.Flush();
sequence.Length.Is(length);
packer.Pack(target).Position.Is(sequence.Length);
stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue();
var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence);
sequenceReader.ReadUInt64().Is(target);
sequenceReader.End.IsTrue();
this.CreateUnpackedReference(sequence).AsUInt64().Is(target);
}
protected virtual (FrameHeader Header, ReadOnlySequence <byte> Payload) DeserializeFrame(ReadOnlySequence <byte> frameSequence)
{
var reader = new MessagePackReader(frameSequence);
int headerElementCount = reader.ReadArrayHeader();
if (headerElementCount < 1)
{
throw new MultiplexingProtocolException("Not enough elements in frame header.");
}
FrameHeader header;
var code = (ControlCode)reader.ReadInt32();
ulong? channelId = null;
if (headerElementCount > 1)
{
if (reader.IsNil)
{
reader.ReadNil();
}
else
{
channelId = reader.ReadUInt64();
}
if (headerElementCount > 2)
{
var payload = reader.ReadBytes() ?? default;
header = this.CreateFrameHeader(code, channelId, null);
return(header, payload);
}
}
header = this.CreateFrameHeader(code, channelId, null);
return(header, default);
}
public object Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
MessagePackType type = reader.NextMessagePackType;
IFormatterResolver resolver = options.Resolver;
switch (type)
{
case MessagePackType.Integer:
var code = reader.NextCode;
if (code >= MessagePackCode.MinNegativeFixInt && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (code >= MessagePackCode.MinFixInt && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.Int8)
{
return(reader.ReadSByte());
}
else if (code == MessagePackCode.Int16)
{
return(reader.ReadInt16());
}
else if (code == MessagePackCode.Int32)
{
return(reader.ReadInt32());
}
else if (code == MessagePackCode.Int64)
{
return(reader.ReadInt64());
}
else if (code == MessagePackCode.UInt8)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.UInt16)
{
return(reader.ReadUInt16());
}
else if (code == MessagePackCode.UInt32)
{
return(reader.ReadUInt32());
}
else if (code == MessagePackCode.UInt64)
{
return(reader.ReadUInt64());
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (reader.NextCode == MessagePackCode.Float32)
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
// We must copy the sequence returned by ReadBytes since the reader's sequence is only valid during deserialization.
return(reader.ReadBytes()?.ToArray());
case MessagePackType.Extension:
ExtensionHeader ext = reader.ReadExtensionFormatHeader();
if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
{
return(reader.ReadDateTime(ext));
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
if (length == 0)
{
return(Array.Empty <object>());
}
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var array = new object[length];
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, options);
}
}
finally
{
reader.Depth--;
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length, options.Security.GetEqualityComparer <object>());
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, options);
var value = objectFormatter.Deserialize(ref reader, options);
hash.Add(key, value);
}
}
finally
{
reader.Depth--;
}
return(hash);
}
case MessagePackType.Nil:
reader.ReadNil();
return(null);
default:
throw new MessagePackSerializationException("Invalid primitive bytes.");
}
}
public void ForceBlockFormatters()
{
var block = new BlockFormattedIntegers
{
UInt8Property = 1,
UInt16Property = 2,
UInt32Property = 3,
UInt64Property = 4,
Int8Property = 1,
Int16Property = 2,
Int32Property = 3,
Int64Property = 4,
NullableUInt8Property = 1,
NullableUInt16Property = 2,
NullableUInt32Property = 3,
NullableUInt64Property = 4,
NullableInt8Property = 1,
NullableInt16Property = 2,
NullableInt32Property = 3,
NullableInt64Property = 4,
};
byte[] packed = MessagePackSerializer.Serialize(block, MessagePackSerializerOptions.Standard);
var reader = new MessagePackReader(packed);
reader.ReadArrayHeader();
Assert.Equal(MessagePackCode.UInt8, reader.NextCode);
Assert.Equal(1, reader.ReadByte());
Assert.Equal(MessagePackCode.UInt16, reader.NextCode);
Assert.Equal(2, reader.ReadUInt16());
Assert.Equal(MessagePackCode.UInt32, reader.NextCode);
Assert.Equal(3u, reader.ReadUInt32());
Assert.Equal(MessagePackCode.UInt64, reader.NextCode);
Assert.Equal(4u, reader.ReadUInt64());
Assert.Equal(MessagePackCode.Int8, reader.NextCode);
Assert.Equal(1, reader.ReadSByte());
Assert.Equal(MessagePackCode.Int16, reader.NextCode);
Assert.Equal(2, reader.ReadInt16());
Assert.Equal(MessagePackCode.Int32, reader.NextCode);
Assert.Equal(3, reader.ReadInt32());
Assert.Equal(MessagePackCode.Int64, reader.NextCode);
Assert.Equal(4, reader.ReadInt64());
Assert.Equal(MessagePackCode.UInt8, reader.NextCode);
Assert.Equal(1, reader.ReadByte());
Assert.Equal(MessagePackCode.UInt16, reader.NextCode);
Assert.Equal(2, reader.ReadUInt16());
Assert.Equal(MessagePackCode.UInt32, reader.NextCode);
Assert.Equal(3u, reader.ReadUInt32());
Assert.Equal(MessagePackCode.UInt64, reader.NextCode);
Assert.Equal(4u, reader.ReadUInt64());
Assert.Equal(MessagePackCode.Int8, reader.NextCode);
Assert.Equal(1, reader.ReadSByte());
Assert.Equal(MessagePackCode.Int16, reader.NextCode);
Assert.Equal(2, reader.ReadInt16());
Assert.Equal(MessagePackCode.Int32, reader.NextCode);
Assert.Equal(3, reader.ReadInt32());
Assert.Equal(MessagePackCode.Int64, reader.NextCode);
Assert.Equal(4, reader.ReadInt64());
}
public UInt64 Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
return(reader.ReadUInt64());
}
public object Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
var type = reader.NextMessagePackType;
switch (type)
{
case MessagePackType.Integer:
var code = reader.NextCode;
if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.Int8)
{
return(reader.ReadSByte());
}
else if (code == MessagePackCode.Int16)
{
return(reader.ReadInt16());
}
else if (code == MessagePackCode.Int32)
{
return(reader.ReadInt32());
}
else if (code == MessagePackCode.Int64)
{
return(reader.ReadInt64());
}
else if (code == MessagePackCode.UInt8)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.UInt16)
{
return(reader.ReadUInt16());
}
else if (code == MessagePackCode.UInt32)
{
return(reader.ReadUInt32());
}
else if (code == MessagePackCode.UInt64)
{
return(reader.ReadUInt64());
}
throw new InvalidOperationException("Invalid primitive bytes.");
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (MessagePackCode.Float32 == reader.NextCode)
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
return(reader.ReadBytes());
case MessagePackType.Extension:
var ext = reader.ReadExtensionFormatHeader();
if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
{
return(reader.ReadDateTime(ext));
}
throw new InvalidOperationException("Invalid primitive bytes.");
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
var objectFormatter = resolver.GetFormatter <object>();
var array = new object[length];
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, resolver);
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
var objectFormatter = resolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length);
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, resolver);
var value = objectFormatter.Deserialize(ref reader, resolver);
hash.Add(key, value);
}
return(hash);
}
case MessagePackType.Nil:
reader.ReadNil();
return(null);
default:
throw new InvalidOperationException("Invalid primitive bytes.");
}
}
public object Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
var type = reader.GetMessagePackType();
switch (type)
{
case MessagePackType.Integer:
var code = reader.Peek();
if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else
{
switch (code)
{
case MessagePackCode.Int8: return(reader.ReadSByte());
case MessagePackCode.Int16: return(reader.ReadInt16());
case MessagePackCode.Int32: return(reader.ReadInt32());
case MessagePackCode.Int64: return(reader.ReadInt64());
case MessagePackCode.UInt8: return(reader.ReadByte());
case MessagePackCode.UInt16: return(reader.ReadUInt16());
case MessagePackCode.UInt32: return(reader.ReadUInt32());
case MessagePackCode.UInt64: return(reader.ReadUInt64());
default: ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes(); return(null);
}
}
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (MessagePackCode.Float32 == reader.Peek())
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
return(reader.ReadBytes());
case MessagePackType.Extension:
var extTypeCode = reader.GetExtensionFormatTypeCode();
if (extTypeCode != ReservedMessagePackExtensionTypeCode.DateTime)
{
ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes();
}
return(reader.ReadDateTime());
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
var objectFormatter = formatterResolver.GetFormatter <object>();
var array = new object[length];
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, formatterResolver);
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
var objectFormatter = formatterResolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length);
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, formatterResolver);
var value = objectFormatter.Deserialize(ref reader, formatterResolver);
hash.Add(key, value);
}
return(hash);
}
case MessagePackType.Nil:
reader.Advance(1);
return(null);
default:
ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes(); return(null);
}
}
public override T Deserialize(ref MessagePackReader reader)
{
ulong value = reader.ReadUInt64();
return(MessagePackUnsafeUtility.As <ulong, T>(ref value));
}
public global::Fenix.Packet Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __Id__ = default(ulong);
var __ProtoCode__ = default(uint);
var __FromHostId__ = default(uint);
var __ToHostId__ = default(uint);
var __FromActorId__ = default(uint);
var __ToActorId__ = default(uint);
var __Payload__ = default(byte[]);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__Id__ = reader.ReadUInt64();
break;
case 1:
__ProtoCode__ = reader.ReadUInt32();
break;
case 2:
__FromHostId__ = reader.ReadUInt32();
break;
case 3:
__ToHostId__ = reader.ReadUInt32();
break;
case 4:
__FromActorId__ = reader.ReadUInt32();
break;
case 5:
__ToActorId__ = reader.ReadUInt32();
break;
case 6:
__Payload__ = formatterResolver.GetFormatterWithVerify <byte[]>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Fenix.Packet();
____result.Id = __Id__;
____result.ProtoCode = __ProtoCode__;
____result.FromHostId = __FromHostId__;
____result.ToHostId = __ToHostId__;
____result.FromActorId = __FromActorId__;
____result.ToActorId = __ToActorId__;
____result.Payload = __Payload__;
reader.Depth--;
return(____result);
}