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); } }