public Vector2I Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.IsNil) { throw new InvalidOperationException("type code is null, struct not supported"); } var length = reader.ReadArrayHeader(); var x = default(int); var y = default(int); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: x = reader.ReadInt32(); break; case 1: y = reader.ReadInt32(); break; default: reader.Skip(); break; } } var result = new Vector2I(x, y); return(result); }
public T[,,,] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } var formatter = formatterResolver.GetFormatterWithVerify <T>(); var len = reader.ReadArrayHeader(); if (len != ArrayLength) { ThrowHelper.ThrowInvalidOperationException_T_Format3(); } var iLength = reader.ReadInt32(); var jLength = reader.ReadInt32(); var kLength = reader.ReadInt32(); var lLength = reader.ReadInt32(); var maxLen = reader.ReadArrayHeader(); var array = new T[iLength, jLength, kLength, lLength]; var i = 0; var j = 0; var k = 0; var l = -1; for (int loop = 0; loop < maxLen; loop++) { if (l < lLength - 1) { l++; } else if (k < kLength - 1) { l = 0; k++; } else if (j < jLength - 1) { l = 0; k = 0; j++; } else { l = 0; k = 0; j = 0; i++; } array[i, j, k, l] = formatter.Deserialize(ref reader, formatterResolver); } return(array); }
public T[,,,] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } else { IMessagePackFormatter <T> formatter = options.Resolver.GetFormatterWithVerify <T>(); var len = reader.ReadArrayHeader(); if (len != ArrayLength) { throw new InvalidOperationException("Invalid T[,,,] format"); } var iLength = reader.ReadInt32(); var jLength = reader.ReadInt32(); var kLength = reader.ReadInt32(); var lLength = reader.ReadInt32(); var maxLen = reader.ReadArrayHeader(); var array = new T[iLength, jLength, kLength, lLength]; var i = 0; var j = 0; var k = 0; var l = -1; for (int loop = 0; loop < maxLen; loop++) { reader.CancellationToken.ThrowIfCancellationRequested(); if (l < lLength - 1) { l++; } else if (k < kLength - 1) { l = 0; k++; } else if (j < jLength - 1) { l = 0; k = 0; j++; } else { l = 0; k = 0; j = 0; i++; } array[i, j, k, l] = formatter.Deserialize(ref reader, options); } return(array); } }
public global::DM.MessagePackTest 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.ReadMapHeader(); var __IsNetworkError__ = default(bool); var __IsHttpError__ = default(bool); var __ResponseCode__ = default(int); var __Sec__ = default(int); for (int i = 0; i < length; i++) { ReadOnlySpan <byte> stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader); int key; if (!this.____keyMapping.TryGetValue(stringKey, out key)) { reader.Skip(); continue; } switch (key) { case 0: __IsNetworkError__ = reader.ReadBoolean(); break; case 1: __IsHttpError__ = reader.ReadBoolean(); break; case 2: __ResponseCode__ = reader.ReadInt32(); break; case 3: __Sec__ = reader.ReadInt32(); break; default: reader.Skip(); break; } } var ____result = new global::DM.MessagePackTest(); ____result.IsNetworkError = __IsNetworkError__; ____result.IsHttpError = __IsHttpError__; ____result.ResponseCode = __ResponseCode__; ____result.Sec = __Sec__; reader.Depth--; return(____result); }
public global::DM.Person 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.ReadMapHeader(); var __PersonId__ = default(int); var __Age__ = default(int); var __Gender__ = default(global::DM.Gender); var __Name__ = default(string); for (int i = 0; i < length; i++) { ReadOnlySpan <byte> stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader); int key; if (!this.____keyMapping.TryGetValue(stringKey, out key)) { reader.Skip(); continue; } switch (key) { case 0: __PersonId__ = reader.ReadInt32(); break; case 1: __Age__ = reader.ReadInt32(); break; case 2: __Gender__ = formatterResolver.GetFormatterWithVerify <global::DM.Gender>().Deserialize(ref reader, options); break; case 3: __Name__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::DM.Person(); ____result.PersonId = __PersonId__; ____result.Age = __Age__; ____result.Gender = __Gender__; ____result.Name = __Name__; reader.Depth--; return(____result); }
public TypeRequiringCustomFormatter Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { Assert.Equal(2, reader.ReadArrayHeader()); return(new TypeRequiringCustomFormatter { Prop1 = reader.ReadInt32(), Prop2 = reader.ReadInt32(), }); }
private static void Assert3MemberClassSerializedContent(ReadOnlyMemory <byte> msgpack) { var reader = new MessagePackReader(msgpack); Assert.Equal(3, reader.ReadArrayHeader()); Assert.Equal(1, reader.ReadInt32()); Assert.Equal(2, reader.ReadInt32()); Assert.Equal(3, reader.ReadInt32()); }
public global::MasterMemory.Tests.Sample Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadMapHeader(); var __Id__ = default(int); var __Age__ = default(int); var __FirstName__ = default(string); var __LastName__ = default(string); for (int i = 0; i < length; i++) { ReadOnlySpan <byte> stringKey = Internal.CodeGenHelpers.ReadStringSpan(ref reader); int key; if (!this.____keyMapping.TryGetValue(stringKey, out key)) { reader.Skip(); continue; } switch (key) { case 0: __Id__ = reader.ReadInt32(); break; case 1: __Age__ = reader.ReadInt32(); break; case 2: __FirstName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; case 3: __LastName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::MasterMemory.Tests.Sample(__Id__, __Age__, __FirstName__, __LastName__); ____result.Id = __Id__; ____result.Age = __Age__; ____result.FirstName = __FirstName__; ____result.LastName = __LastName__; return(____result); }
public override TestTarget Deserialize(ref MessagePackReader reader) { if (!reader.TryReadNil()) { var value = new TestTarget(); int count = reader.ReadArrayHeader(); for (int i = 0; i < count; i++) { int key = reader.ReadInt32(); switch (key) { case 0: { value.BoolValue = reader.ReadBoolean(); break; } case 1: { value.IntValue = reader.ReadInt32(); break; } case 2: { value.FloatValue = reader.ReadSingle(); break; } case 3: { value.StringValue = reader.ReadString(); break; } case 4: { value.EnumValue = m_formatterTypeCode.Deserialize(ref reader); break; } default: { reader.ReadNextBlock(); break; } } } return(value); } return(default);
public global::Common.UserInputs Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { throw new InvalidOperationException("typecode is null, struct not supported"); } options.Security.DepthStep(ref reader); IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadArrayHeader(); var __Index__ = default(int); var __TickId__ = default(int); var __UserId__ = default(int); var __InputData__ = default(byte[][]); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __Index__ = reader.ReadInt32(); break; case 1: __TickId__ = reader.ReadInt32(); break; case 2: __UserId__ = reader.ReadInt32(); break; case 3: __InputData__ = formatterResolver.GetFormatterWithVerify <byte[][]>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::Common.UserInputs(); ____result.Index = __Index__; ____result.TickId = __TickId__; ____result.UserId = __UserId__; ____result.InputData = __InputData__; reader.Depth--; return(____result); }
public T[,] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } else { IMessagePackFormatter <T> formatter = options.Resolver.GetFormatterWithVerify <T>(); var len = reader.ReadArrayHeader(); if (len != ArrayLength) { throw new MessagePackSerializationException("Invalid T[,] format"); } var iLength = reader.ReadInt32(); var jLength = reader.ReadInt32(); var maxLen = reader.ReadArrayHeader(); var array = new T[iLength, jLength]; var i = 0; var j = -1; options.Security.DepthStep(ref reader); try { for (int loop = 0; loop < maxLen; loop++) { reader.CancellationToken.ThrowIfCancellationRequested(); if (j < jLength - 1) { j++; } else { j = 0; i++; } array[i, j] = formatter.Deserialize(ref reader, options); } } finally { reader.Depth--; } return(array); } }
public T[,,] Deserialize(ref MessagePackReader reader, IFormatterResolver resolver) { if (reader.TryReadNil()) { return(null); } else { var formatter = resolver.GetFormatterWithVerify <T>(); var len = reader.ReadArrayHeader(); if (len != ArrayLength) { throw new InvalidOperationException("Invalid T[,,] format"); } var iLength = reader.ReadInt32(); var jLength = reader.ReadInt32(); var kLength = reader.ReadInt32(); var maxLen = reader.ReadArrayHeader(); var array = new T[iLength, jLength, kLength]; var i = 0; var j = 0; var k = -1; for (int loop = 0; loop < maxLen; loop++) { if (k < kLength - 1) { k++; } else if (j < jLength - 1) { k = 0; j++; } else { k = 0; j = 0; i++; } array[i, j, k] = formatter.Deserialize(ref reader, resolver); } return(array); } }
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::UnityEngine.RectOffset Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.IsNil) { return(null); } var length = reader.ReadArrayHeader(); var __left__ = default(int); var __right__ = default(int); var __top__ = default(int); var __bottom__ = default(int); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __left__ = reader.ReadInt32(); break; case 1: __right__ = reader.ReadInt32(); break; case 2: __top__ = reader.ReadInt32(); break; case 3: __bottom__ = reader.ReadInt32(); break; default: reader.Skip(); break; } } var ____result = new global::UnityEngine.RectOffset(); ____result.left = __left__; ____result.right = __right__; ____result.top = __top__; ____result.bottom = __bottom__; return(____result); }
Request DeserializeRequest(ref MessagePackReader reader, MessagePackSerializerOptions options) => new Request { MsgId = reader.ReadInt32(), Method = reader.ReadString(), Params = reader.ReadBytes().ToArray().AsSequence() };
public void Int32Test(int 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); // bug of msgpack-cli if (target == 255) { packer.Pack((byte)255).Position.Is(sequence.Length); } else if (target == 50000) { packer.Pack((ushort)50000).Position.Is(sequence.Length); } else { packer.Pack(target).Position.Is(sequence.Length); } //// stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue(); var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence); sequenceReader.ReadInt32().Is(target); sequenceReader.End.IsTrue(); this.CreateUnpackedReference(sequence).AsInt32().Is(target); }
public static TrackableDictionaryTracker <TKey, TValue> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { var count = reader.ReadArrayHeader(); TrackableDictionaryTracker <TKey, TValue> tracker = new TrackableDictionaryTracker <TKey, TValue>(); for (var i = 0; i < count; i++) { var operation = reader.ReadInt32(); var key = MessagePackSerializer.Deserialize <TKey>(ref reader, options); var value = MessagePackSerializer.Deserialize <TValue>(ref reader, options); switch (operation) { case (int)TrackableDictionaryOperation.Add: tracker.TrackAdd(key, value); break; case (int)TrackableDictionaryOperation.Remove: tracker.TrackRemove(key, value); break; case (int)TrackableDictionaryOperation.Modify: tracker.TrackModify(key, default(TValue), value); break; } } return(tracker); }
public global::MSBuildAssemblyLoadIssue.Foo Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadArrayHeader(); var __Bar__ = default(int); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __Bar__ = reader.ReadInt32(); break; default: reader.Skip(); break; } } var ____result = new global::MSBuildAssemblyLoadIssue.Foo(); ____result.Bar = __Bar__; return(____result); }
public global::MsgDefine.TestMsg.TestMsg2 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 __Age__ = default(int); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __Age__ = reader.ReadInt32(); break; default: reader.Skip(); break; } } var ____result = new global::MsgDefine.TestMsg.TestMsg2(); ____result.Age = __Age__; reader.Depth--; return(____result); }
public StringValues Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(StringValues.Empty); } else { var count = reader.ReadInt32(); if (count == 1) { return(new StringValues(reader.ReadString())); } else { var arr = new string[count]; for (int n = 0; n < count; n++) { arr[n] = reader.ReadString(); } return(new StringValues(arr)); } } }
public ReactivePropertySlim <T> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } else { var length = reader.ReadArrayHeader(); if (length != 2) { throw new InvalidOperationException("Invalid ReactivePropertySlim data."); } options.Security.DepthStep(ref reader); try { var mode = (ReactivePropertyMode)reader.ReadInt32(); T v = options.Resolver.GetFormatterWithVerify <T>().Deserialize(ref reader, options); return(new ReactivePropertySlim <T>(v, mode)); } finally { reader.Depth--; } } }
public ScString Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.IsNil) { reader.Skip(); return(null); } var strNo = reader.ReadInt32(); if (BlackStringTable.ScStringMap != null && strNo >= 1 && strNo <= BlackStringTable.ScStringMap.Length) { return(BlackStringTable.ScStringMap[strNo - 1]); } Debug.LogError( $"String number {strNo} not found on string map! BlackStringTable.ScStringMap={BlackStringTable.ScStringMap}, BlackStringTable.ScStringMap.Length={BlackStringTable.ScStringMap?.Length ?? -1}"); // Dictionary 키로 쓰이는 문자열도 있어서 숫자 하나씩 증가시켜준다. errorStringCounter++; if (errorStringCounter >= 100) { throw new UnityException("Too many string number not found."); } return(new ScString($"STRING NUMBER NOT FOUND [{errorStringCounter}]")); }
private static void DeserializeFormat0(ref MessagePackReader reader, MessagePackSerializerOptions options, ref string message, ref int number) { int length = reader.ReadMapHeader(); int i = 0; IFormatterResolver resolver = options.Resolver; while (i < length) { ReadOnlySpan <byte> stringKey = CodeGenHelpers.ReadStringSpan(ref reader); int length2 = stringKey.Length; ulong key = 0uL; if (length2 <= 8) { key = AutomataKeyGen.GetKey(ref stringKey); } if (length2 == 7 && key == 28542640894207341L) { message = reader.ReadString(); } else if (length2 == 6 && key == 125779768604014L) { number = reader.ReadInt32(); } else { reader.Skip(); } i++; } }
private static void DeserializeFormat1(ref MessagePackReader reader, MessagePackSerializerOptions options, ref Type type, ref IExposedWrapper wrapper) { int count = reader.ReadArrayHeader(); for (int i = 0; i < count; i++) { switch (i) { case 0: var typeHash = reader.ReadInt32(); type = LevelEditorSerializer.GetType(typeHash); break; case 1: if (type == null) { reader.Skip(); continue; } ((LevelEditorResolver)LevelEditorResolver.instance).DeserializeWrapper(type, ref reader, options, out wrapper); break; } } }
public global::UnityEngine.LayerMask Deserialize(ref MessagePackReader reader, global::MessagePack.IFormatterResolver formatterResolver) { if (reader.IsNil) { throw new InvalidOperationException("typecode is null, struct not supported"); } var length = reader.ReadArrayHeader(); var __value__ = default(int); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __value__ = reader.ReadInt32(); break; default: reader.Skip(); break; } } var ____result = new global::UnityEngine.LayerMask(); ____result.value = __value__; return(____result); }
Response DeserializeResponse(ref MessagePackReader reader, MessagePackSerializerOptions options) => new Response { MsgId = reader.ReadInt32(), Result = reader.ReadBytes().ToArray().AsSequence(), Error = reader.ReadBytes().ToArray().AsSequence() };
private static void DeserializeFormat1(ref MessagePackReader reader, MessagePackSerializerOptions options, ref Type type, ref object value) { int count = reader.ReadArrayHeader(); for (int i = 0; i < count; i++) { switch (i) { case 0: type = LevelEditorSerializer.GetType(reader.ReadInt32()); break; case 1: if (type == null) { Debug.LogWarning("Can't deserialize some custom data because no type for it was found."); reader.Skip(); break; } ((LevelEditorResolver)LevelEditorResolver.instance).DeserializeDynamic(type, ref reader, out value, options); break; } } }
public global::SharedProject_ShouldInclude.FromSharedProject_ShouldBeIncluded 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 __SomeOtherValue__ = default(int); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __SomeOtherValue__ = reader.ReadInt32(); break; default: reader.Skip(); break; } } var ____result = new global::SharedProject_ShouldInclude.FromSharedProject_ShouldBeIncluded(); ____result.SomeOtherValue = __SomeOtherValue__; reader.Depth--; return(____result); }
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field) { try { if (type == typeof(string)) { return(ReadString(ref reader, "argument")); } else if (type == typeof(bool)) { return(reader.ReadBoolean()); } else if (type == typeof(int)) { return(reader.ReadInt32()); } else if (type == typeof(long)) { return(reader.ReadInt64()); } else if (type == typeof(float)) { return(reader.ReadSingle()); } } catch (Exception ex) { throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex); } throw new FormatException($"Type {type} is not supported"); }
protected override PackageVulnerabilityMetadataContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { Uri?advisoryUrl = null; int severity = 0; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case AdvisoryUrlPropertyName: advisoryUrl = options.Resolver.GetFormatter <Uri>().Deserialize(ref reader, options); break; case SeverityPropertyName: severity = reader.ReadInt32(); break; default: reader.Skip(); break; } } Assumes.NotNull(advisoryUrl); return(new PackageVulnerabilityMetadataContextInfo(advisoryUrl, severity)); }