public global::DRXLibrary.Models.Drx.DrxFlagColour Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } options.Security.DepthStep(ref reader); var length = reader.ReadArrayHeader(); var __A__ = default(byte); var __R__ = default(byte); var __G__ = default(byte); var __B__ = default(byte); for (int i = 0; i < length; i++) { switch (i) { case 0: __A__ = reader.ReadByte(); break; case 1: __R__ = reader.ReadByte(); break; case 2: __G__ = reader.ReadByte(); break; case 3: __B__ = reader.ReadByte(); break; default: reader.Skip(); break; } } var ____result = new global::DRXLibrary.Models.Drx.DrxFlagColour(); ____result.A = __A__; ____result.R = __R__; ____result.G = __G__; ____result.B = __B__; reader.Depth--; return(____result); }
public global::UnityEngine.Color32 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.IsNil) { throw new InvalidOperationException("typecode is null, struct not supported"); } var length = reader.ReadArrayHeader(); var __r__ = default(byte); var __g__ = default(byte); var __b__ = default(byte); var __a__ = default(byte); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __r__ = reader.ReadByte(); break; case 1: __g__ = reader.ReadByte(); break; case 2: __b__ = reader.ReadByte(); break; case 3: __a__ = reader.ReadByte(); break; default: reader.Skip(); break; } } var ____result = new global::UnityEngine.Color32(__r__, __g__, __b__, __a__); ____result.r = __r__; ____result.g = __g__; ____result.b = __b__; ____result.a = __a__; return(____result); }
public global::GatewayServer.Packet.PKTReqMatching 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 __MatchingType__ = default(byte); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __MatchingType__ = reader.ReadByte(); break; default: reader.Skip(); break; } } var ____result = new global::GatewayServer.Packet.PKTReqMatching(); ____result.MatchingType = __MatchingType__; reader.Depth--; return(____result); }
public global::Server.SharedThings.Packets.ClientPackets.CharacterListRequest Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadArrayHeader(); var __A__ = default(byte); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __A__ = reader.ReadByte(); break; default: reader.Skip(); break; } } var ____result = new global::Server.SharedThings.Packets.ClientPackets.CharacterListRequest(); ____result.A = __A__; return(____result); }
public byte[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.NextMessagePackType == MessagePackType.Array) { int len = reader.ReadArrayHeader(); if (len == 0) { return(Array.Empty <byte>()); } byte[] array = new byte[len]; options.Security.DepthStep(ref reader); try { for (int i = 0; i < len; i++) { reader.CancellationToken.ThrowIfCancellationRequested(); array[i] = reader.ReadByte(); } } finally { reader.Depth--; } return(array); } else { return(reader.ReadBytes()?.ToArray()); } }
public object Deserialize(int id, ref MessagePackReader reader, MessagePackSerializerOptions options) { if (id == 0) { return(reader.ReadString()); } if (id == 1) { return(reader.ReadInt32()); } if (id == 2) { return(reader.ReadByte()); } if (id == 4) { return(options.Resolver.GetFormatterWithVerify <Vector3>().Deserialize(ref reader, options)); } if (id == 5) { return(reader.ReadSingle()); } return(null); }
public override TestSerializable Deserialize(MessagePackReader reader) { var value = reader.ReadByte(); var testSerializable = new TestSerializable(value); return(testSerializable); }
public Byte?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } return(reader.ReadByte()); }
public Color Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.IsNil) { throw new InvalidOperationException("type code is null, struct not supported"); } var length = reader.ReadArrayHeader(); var r = default(byte); var g = default(byte); var b = default(byte); var a = default(byte); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: r = reader.ReadByte(); break; case 1: g = reader.ReadByte(); break; case 2: b = reader.ReadByte(); break; case 3: a = reader.ReadByte(); break; default: reader.Skip(); break; } } var result = new Color(r, g, b, a); return(result); }
public RigidbodyWrapper.Wrapper Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { throw new InvalidOperationException("typecode is null, struct not supported"); } options.Security.DepthStep(ref reader); int length = reader.ReadArrayHeader(); RigidbodyWrapper.Wrapper wrapper = new RigidbodyWrapper.Wrapper { Values = new Dictionary <int, object>(5), Dirty = new Dictionary <int, bool>(5) }; for (int i = 0; i < length / 2; i++) { byte id = reader.ReadByte(); switch (id) { case 0: wrapper.Values[0] = wrapper.Deserialize(0, ref reader, options); wrapper.Dirty[0] = true; break; case 1: wrapper.Values[1] = wrapper.Deserialize(1, ref reader, options); wrapper.Dirty[1] = true; break; case 2: wrapper.Values[2] = wrapper.Deserialize(2, ref reader, options); wrapper.Dirty[2] = true; break; case 3: wrapper.Values[3] = wrapper.Deserialize(3, ref reader, options); wrapper.Dirty[3] = true; break; case 4: wrapper.Values[4] = wrapper.Deserialize(4, ref reader, options); wrapper.Dirty[4] = true; break; default: reader.Skip(); break; } } reader.Depth--; return(wrapper); }
public RedisGroupCommand ReadGroupCommand(ReadOnlyMemory <byte> data) { var reader = new MessagePackReader(data); // See WriteGroupCommand for format. ValidateArraySize(ref reader, 5, "GroupCommand"); var id = reader.ReadInt32(); var serverName = reader.ReadString(); var action = (GroupAction)reader.ReadByte(); var groupName = reader.ReadString(); var connectionId = reader.ReadString(); return(new RedisGroupCommand(id, serverName, action, groupName, connectionId)); }
public global::GatewayServer.Packet.PKTNTFGamePut 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 __Result__ = default(ushort); var __PutPos__ = default((int, int)); var __Type__ = default(byte); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __Result__ = reader.ReadUInt16(); break; case 1: __PutPos__ = formatterResolver.GetFormatterWithVerify <(int, int)>().Deserialize(ref reader, options); break; case 2: __Type__ = reader.ReadByte(); break; default: reader.Skip(); break; } } var ____result = new global::GatewayServer.Packet.PKTNTFGamePut(); ____result.Result = __Result__; ____result.PutPos = __PutPos__; ____result.Type = __Type__; reader.Depth--; return(____result); }
private Message ReadCompletion(ref MessagePackReader reader) { // https://github.com/aspnet/AspNetCore/blob/master/src/SignalR/docs/specs/HubProtocol.md#completion-message-encoding-1 ReadHeaders(ref reader); string invocationId = reader.ReadString(); byte resultKind = reader.ReadByte(); switch (resultKind) { // 1 - Error result - Result contains a String with the error message case 1: string error = reader.ReadString(); return(new Message { type = MessageTypes.Completion, invocationId = invocationId, error = error }); // 2 - Void result - Result is absent case 2: return(new Message { type = MessageTypes.Completion, invocationId = invocationId }); // 3 - Non-Void result - Result contains the value returned by the server case 3: object item = ReadItem(ref reader, invocationId); return(new Message { type = MessageTypes.Completion, invocationId = invocationId, item = item, result = item }); default: throw new NotImplementedException("Unknown resultKind: " + resultKind); } }
public void ByteTest(byte 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.ReadByte().Is(target); sequenceReader.End.IsTrue(); this.CreateUnpackedReference(sequence).AsByte().Is(target); }
public static InterprocessMessage ReadPubSubMessage(byte[] buffer) { var reader = new MessagePackReader(buffer); if (reader.ReadArrayHeader() != 3) { throw new InvalidOperationException("Invalid messagepack buffer."); } var b = reader.ReadByte(); var msgType = (MessageType)b; var keyIndex = (int)reader.Consumed; reader.Skip(); var keyOffset = (int)reader.Consumed; reader.Skip(); return(new InterprocessMessage(msgType, buffer, keyIndex, keyOffset)); }
public void ParseMessages(BufferSegment segment, ref List <Message> messages) { int offset = segment.Offset; while (offset < segment.Count) { int length = (int)ReadVarInt(segment.Data, ref offset); var reader = new MessagePackReader(new ReadOnlyMemory <byte>(segment.Data, offset, length)); int arrayLength = reader.ReadArrayHeader(); int messageType = reader.ReadByte(); switch ((MessageTypes)messageType) { case MessageTypes.Invocation: messages.Add(ReadInvocation(ref reader)); break; case MessageTypes.StreamItem: messages.Add(ReadStreamItem(ref reader)); break; case MessageTypes.Completion: messages.Add(ReadCompletion(ref reader)); break; case MessageTypes.StreamInvocation: messages.Add(ReadStreamInvocation(ref reader)); break; case MessageTypes.CancelInvocation: messages.Add(ReadCancelInvocation(ref reader)); break; case MessageTypes.Ping: // https://github.com/aspnet/AspNetCore/blob/master/src/SignalR/docs/specs/HubProtocol.md#ping-message-encoding-1 messages.Add(new Message { type = MessageTypes.Ping }); break; case MessageTypes.Close: messages.Add(ReadClose(ref reader)); break; } offset += length; } }
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 global::Server.SharedThings.Enums.AuthorityType Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { return((global::Server.SharedThings.Enums.AuthorityType)reader.ReadByte()); }
public override T Deserialize(ref MessagePackReader reader) { byte value = reader.ReadByte(); return(MessagePackUnsafeUtility.As <byte, T>(ref value)); }
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 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, 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 override byte Deserialize(MessagePackReader reader) { return(reader.ReadByte()); }
public Byte Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { return(reader.ReadByte()); }
public StatusCode Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { return(new StatusCode(reader.ReadByte(), reader.ReadUInt16())); }