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,
});
}
}
public global::Fenix.Common.Message.RemoveActorReq 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 __actorId__ = default(uint);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__actorId__ = reader.ReadUInt32();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Fenix.Common.Message.RemoveActorReq();
____result.actorId = __actorId__;
reader.Depth--;
return(____result);
}
public UInt32?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(reader.ReadUInt32());
}
public global::Fenix.HostInfo 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 __HostId__ = default(uint);
var __HostName__ = default(string);
var __HostAddr__ = default(string);
var __ServiceId2Name__ = default(global::System.Collections.Generic.Dictionary <uint, string>);
var __ServiceId2TName__ = default(global::System.Collections.Generic.Dictionary <uint, string>);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__HostId__ = reader.ReadUInt32();
break;
case 1:
__HostName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 2:
__HostAddr__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 3:
__ServiceId2Name__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.Dictionary <uint, string> >().Deserialize(ref reader, options);
break;
case 4:
__ServiceId2TName__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.Dictionary <uint, string> >().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Fenix.HostInfo();
____result.HostId = __HostId__;
____result.HostName = __HostName__;
____result.HostAddr = __HostAddr__;
____result.ServiceId2Name = __ServiceId2Name__;
____result.ServiceId2TName = __ServiceId2TName__;
reader.Depth--;
return(____result);
}
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(uint);
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.ReadUInt32();
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);
}
internal static int ReadElementHeader(ref MessagePackReader reader)
{
int arrTotElems = reader.ReadArrayHeader();
if (arrTotElems != Frame <T> .parallelItemTotElems)
{
throw new StreamSerializationException($"invalid array header returned ({arrTotElems}). Expected ({Frame<T>.parallelItemTotElems})");
}
uint length = reader.ReadUInt32();
if (length > int.MaxValue)
{
throw new StreamSerializationException($"invalid body length ({length})");
}
return((int)length);
}
public UInt32[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
var len = reader.ReadArrayHeader();
var array = new UInt32[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = reader.ReadUInt32();
}
return(array);
}
public global::Fenix.Common.Message.RegisterClientReq 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 __hostId__ = default(uint);
var __hostName__ = default(string);
var __callback__ = default(global::Fenix.Common.Message.RegisterClientReq.Callback);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__hostId__ = reader.ReadUInt32();
break;
case 1:
__hostName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 2:
__callback__ = formatterResolver.GetFormatterWithVerify <global::Fenix.Common.Message.RegisterClientReq.Callback>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Fenix.Common.Message.RegisterClientReq();
____result.hostId = __hostId__;
____result.hostName = __hostName__;
____result.callback = __callback__;
reader.Depth--;
return(____result);
}
public global::Server.SharedThings.Packets.ClientPackets.SessionLoginRequest Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __GameVersion__ = default(uint);
var __Username__ = default(string);
var __SessionId__ = default(string);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__GameVersion__ = reader.ReadUInt32();
break;
case 1:
__Username__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 2:
__SessionId__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.ClientPackets.SessionLoginRequest();
____result.GameVersion = __GameVersion__;
____result.Username = __Username__;
____result.SessionId = __SessionId__;
return(____result);
}
public void UInt32Test(uint 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.ReadUInt32().Is(target);
sequenceReader.End.IsTrue();
this.CreateUnpackedReference(sequence).AsUInt32().Is(target);
}
public ComponentDataWrapper Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(new ComponentDataWrapper(0));
}
options.Security.DepthStep(ref reader);
int length = reader.ReadArrayHeader();
uint[] objects = new uint[length];
for (int i = 0; i < length; i++)
{
objects[i] = reader.ReadUInt32();
}
reader.Depth--;
return(new ComponentDataWrapper(objects));
}
public global::Server.SharedThings.Packets.BasicPacketCapsule Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __Identifier__ = default(uint);
var __Packet__ = default(byte[]);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__Identifier__ = reader.ReadUInt32();
break;
case 1:
__Packet__ = formatterResolver.GetFormatterWithVerify <byte[]>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.BasicPacketCapsule();
____result.Identifier = __Identifier__;
____result.Packet = __Packet__;
return(____result);
}
public EntityId(ref MessagePackReader reader)
{
reader.ReadArrayHeader();
Context = reader.ReadUInt32();
string?value = reader.ReadString();
if (value is not null)
{
var path = new EntityPath(value);
_nameStart = 0;
MouseState = path.MouseState;
Path = path.Value;
_hashCode = HashCode.Combine(Path.GetHashCode(), Context);
}
else
{
Path = null !;
_nameStart = 0;
Context = 0;
_hashCode = 0;
MouseState = 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 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);
}
public UInt32 Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
return(reader.ReadUInt32());
}
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);
}
}