public Vector3 Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { var length = reader.ReadArrayHeader(); var __MyProperty1__ = default(float); var __MyProperty2__ = default(float); var __MyProperty3__ = default(float); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __MyProperty1__ = reader.ReadSingle(); break; case 1: __MyProperty2__ = reader.ReadSingle(); break; case 2: __MyProperty3__ = reader.ReadSingle(); break; default: reader.Skip(); break; } } return(new Vector3(__MyProperty1__, __MyProperty2__, __MyProperty3__)); }
public global::UnityEngine.Vector2 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 x = default(float); var y = default(float); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: x = reader.ReadSingle(); break; case 1: y = reader.ReadSingle(); break; default: reader.Skip(); break; } } var result = new global::UnityEngine.Vector2(x, y); return(result); }
public float2 Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.IsNil) { throw new InvalidOperationException("typecode is null, struct not supported"); } var length = reader.ReadArrayHeader(); var x = default(float); var y = default(float); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: x = reader.ReadSingle(); break; case 1: y = reader.ReadSingle(); break; default: reader.Skip(); break; } } var result = float2(x, y); return(result); }
public global::UnityEngine.GradientAlphaKey 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 __alpha__ = default(float); var __time__ = default(float); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __alpha__ = reader.ReadSingle(); break; case 1: __time__ = reader.ReadSingle(); break; default: reader.Skip(); break; } } var ____result = new global::UnityEngine.GradientAlphaKey(__alpha__, __time__); ____result.alpha = __alpha__; ____result.time = __time__; return(____result); }
public global::Server.SharedThings.Packets.Representations.Player Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadArrayHeader(); var __Id__ = default(string); var __X__ = default(float); var __Y__ = default(float); var __Nickname__ = default(string); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __Id__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; case 1: __X__ = reader.ReadSingle(); break; case 2: __Y__ = reader.ReadSingle(); break; case 3: __Nickname__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::Server.SharedThings.Packets.Representations.Player(); ____result.Id = __Id__; ____result.X = __X__; ____result.Y = __Y__; ____result.Nickname = __Nickname__; return(____result); }
public global::UnityEngine.Keyframe 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 __time__ = default(float); var __value__ = default(float); var __inTangent__ = default(float); var __outTangent__ = default(float); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __time__ = reader.ReadSingle(); break; case 1: __value__ = reader.ReadSingle(); break; case 2: __inTangent__ = reader.ReadSingle(); break; case 3: __outTangent__ = reader.ReadSingle(); break; default: reader.Skip(); break; } } var ____result = new global::UnityEngine.Keyframe(__time__, __value__, __inTangent__, __outTangent__); ____result.time = __time__; ____result.value = __value__; ____result.inTangent = __inTangent__; ____result.outTangent = __outTangent__; return(____result); }
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); }
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"); }
public Single?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } return(reader.ReadSingle()); }
public global::UnityEngine.Rect 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 x = default(float); var y = default(float); var width = default(float); var height = default(float); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: x = reader.ReadSingle(); break; case 1: y = reader.ReadSingle(); break; case 2: width = reader.ReadSingle(); break; case 3: height = reader.ReadSingle(); break; default: reader.Skip(); break; } } var result = new global::UnityEngine.Rect(x, y, width, height); return(result); }
public global::UnityEngine.Color 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(float); var g = default(float); var b = default(float); var a = default(float); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: r = reader.ReadSingle(); break; case 1: g = reader.ReadSingle(); break; case 2: b = reader.ReadSingle(); break; case 3: a = reader.ReadSingle(); break; default: reader.Skip(); break; } } var result = new global::UnityEngine.Color(r, g, b, a); return(result); }
public override TestTarget Deserialize(ref MessagePackReader reader) { if (!reader.TryReadNil()) { var value = new TestTarget(); int count = reader.ReadMapHeader(); for (int i = 0; i < count; i++) { ArraySegment<byte> segment = reader.ReadStringSegment(); if (m_nameToKey.TryGetValue(segment.Array, segment.Offset, segment.Count, out int key)) { 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; } } } else { reader.ReadNextBlock(); } } } return default; }
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 object Deserialize(int id, ref MessagePackReader reader, MessagePackSerializerOptions options) { switch (id) { case MASS_ID: return(reader.ReadSingle()); case DRAG_ID: return(reader.ReadSingle()); case ANGULAR_DRAG_ID: return(reader.ReadSingle()); case USE_GRAVITY_ID: return(reader.ReadBoolean()); case IS_KINEMATIC_ID: return(reader.ReadBoolean()); } return(default);
public global::Sakaba.Domain.StatModifier 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 __value__ = default(float); var __type__ = default(global::Sakaba.Domain.StatModType); var __targetType__ = default(global::Sakaba.Domain.ModTargetType); 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: __value__ = reader.ReadSingle(); break; case 1: __type__ = formatterResolver.GetFormatterWithVerify <global::Sakaba.Domain.StatModType>().Deserialize(ref reader, options); break; case 2: __targetType__ = formatterResolver.GetFormatterWithVerify <global::Sakaba.Domain.ModTargetType>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::Sakaba.Domain.StatModifier(); ____result.value = __value__; ____result.type = __type__; ____result.targetType = __targetType__; reader.Depth--; return(____result); }
public global::Server.SharedThings.Packets.ServerPackets.Game.PlayerUpdateOwnPosition Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadArrayHeader(); var __X__ = default(float); var __Y__ = default(float); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __X__ = reader.ReadSingle(); break; case 1: __Y__ = reader.ReadSingle(); break; default: reader.Skip(); break; } } var ____result = new global::Server.SharedThings.Packets.ServerPackets.Game.PlayerUpdateOwnPosition(); ____result.X = __X__; ____result.Y = __Y__; return(____result); }
public override TestTarget Deserialize(ref MessagePackReader reader) { if (!reader.TryReadNil()) { var value = new TestTarget(); value.BoolValue = reader.ReadBoolean(); value.IntValue = reader.ReadInt32(); value.FloatValue = reader.ReadSingle(); value.StringValue = reader.ReadString(); value.EnumValue = m_formatterTypeCode.Deserialize(ref reader); return(value); } return(default);
public Single[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } var len = reader.ReadArrayHeader(); var array = new Single[len]; for (int i = 0; i < array.Length; i++) { array[i] = reader.ReadSingle(); } return(array); }
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()); } else if (type == typeof(byte[])) { var bytes = reader.ReadBytes(); if (!bytes.HasValue) { return(null); } else if (bytes.Value.Length == 0) { return(Array.Empty <byte>()); } return(bytes.Value.ToArray()); } } 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"); }
public global::Pathfinding.Node 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 __pos__ = default(global::UnityEngine.Vector3); var __isoValue__ = default(float); var __neighbourIdentifiers__ = default(global::System.Collections.Generic.List <global::Pathfinding.NodeIdentifier>); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __pos__ = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Vector3>().Deserialize(ref reader, options); break; case 1: __isoValue__ = reader.ReadSingle(); break; case 2: __neighbourIdentifiers__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <global::Pathfinding.NodeIdentifier> >().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::Pathfinding.Node(__pos__, __isoValue__, __neighbourIdentifiers__); ____result.pos = __pos__; ____result.isoValue = __isoValue__; ____result.neighbourIdentifiers = __neighbourIdentifiers__; 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()); } else if (type == typeof(byte[])) { var bytes = reader.ReadBytes(); if (!bytes.HasValue) { return(null); } else if (bytes.Value.Length == 0) { return(Array.Empty <byte>()); } return(bytes.Value.ToArray()); } else if (type == typeof(JsonElement)) { var bytes = reader.ReadBytes(); if (bytes is null) { return(default);
public void SingleTest(Single 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.ReadSingle().Is(target); sequenceReader.End.IsTrue(); this.CreateUnpackedReference(sequence).AsSingle().Is(target); }
private static 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()); } else if (type == typeof(byte[])) { var bytes = reader.ReadBytes(); // MessagePack ensures there are at least as many bytes in the message as declared by the byte header. // Consequently it is safe to do ToArray on the returned SequenceReader instance. return(bytes.ToArray()); } } 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"); }
public Matrix44F Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.IsNil) { throw new InvalidOperationException("type code is null, struct not supported"); } var length = reader.ReadArrayHeader(); var result = new Matrix44F(); for (int i = 0; i < length; i++) { if (i > 16) { reader.Skip(); continue; } result[i / 4, i % 4] = reader.ReadSingle(); } return(result); }
public global::UnityEngine.GradientColorKey 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 __color__ = default(global::UnityEngine.Color); var __time__ = default(float); IFormatterResolver resolver = options.Resolver; for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __color__ = resolver.GetFormatterWithVerify <global::UnityEngine.Color>().Deserialize(ref reader, options); break; case 1: __time__ = reader.ReadSingle(); break; default: reader.Skip(); break; } } var ____result = new global::UnityEngine.GradientColorKey(__color__, __time__); ____result.color = __color__; ____result.time = __time__; return(____result); }
public global::UnityEngine.Matrix4x4 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 __m00__ = default(float); var __m10__ = default(float); var __m20__ = default(float); var __m30__ = default(float); var __m01__ = default(float); var __m11__ = default(float); var __m21__ = default(float); var __m31__ = default(float); var __m02__ = default(float); var __m12__ = default(float); var __m22__ = default(float); var __m32__ = default(float); var __m03__ = default(float); var __m13__ = default(float); var __m23__ = default(float); var __m33__ = default(float); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __m00__ = reader.ReadSingle(); break; case 1: __m10__ = reader.ReadSingle(); break; case 2: __m20__ = reader.ReadSingle(); break; case 3: __m30__ = reader.ReadSingle(); break; case 4: __m01__ = reader.ReadSingle(); break; case 5: __m11__ = reader.ReadSingle(); break; case 6: __m21__ = reader.ReadSingle(); break; case 7: __m31__ = reader.ReadSingle(); break; case 8: __m02__ = reader.ReadSingle(); break; case 9: __m12__ = reader.ReadSingle(); break; case 10: __m22__ = reader.ReadSingle(); break; case 11: __m32__ = reader.ReadSingle(); break; case 12: __m03__ = reader.ReadSingle(); break; case 13: __m13__ = reader.ReadSingle(); break; case 14: __m23__ = reader.ReadSingle(); break; case 15: __m33__ = reader.ReadSingle(); break; default: reader.Skip(); break; } } var ____result = new global::UnityEngine.Matrix4x4(); ____result.m00 = __m00__; ____result.m10 = __m10__; ____result.m20 = __m20__; ____result.m30 = __m30__; ____result.m01 = __m01__; ____result.m11 = __m11__; ____result.m21 = __m21__; ____result.m31 = __m31__; ____result.m02 = __m02__; ____result.m12 = __m12__; ____result.m22 = __m22__; ____result.m32 = __m32__; ____result.m03 = __m03__; ____result.m13 = __m13__; ____result.m23 = __m23__; ____result.m33 = __m33__; return(____result); }
public void ReadSingle_CanReadDouble() { var reader = new MessagePackReader(Encode((ref MessagePackWriter w) => w.Write(1.23))); Assert.Equal(1.23f, reader.ReadSingle()); }
public Half Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { return((Half)reader.ReadSingle()); }
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 global::MSP_Game_Base 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 __DataKey__ = default(string); var __Var_int__ = default(int); var __Var_float__ = default(float); var __Var_string__ = default(string); var __Var_list_int__ = default(global::System.Collections.Generic.List <int>); var __Var_list_float__ = default(global::System.Collections.Generic.List <float>); var __Var_list_string__ = default(global::System.Collections.Generic.List <string>); for (int i = 0; i < length; i++) { switch (i) { case 0: __DataKey__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; case 1: __Var_int__ = reader.ReadInt32(); break; case 2: __Var_float__ = reader.ReadSingle(); break; case 3: __Var_string__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; case 4: __Var_list_int__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <int> >().Deserialize(ref reader, options); break; case 5: __Var_list_float__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <float> >().Deserialize(ref reader, options); break; case 6: __Var_list_string__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <string> >().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::MSP_Game_Base(); ____result.DataKey = __DataKey__; ____result.Var_int = __Var_int__; ____result.Var_float = __Var_float__; ____result.Var_string = __Var_string__; ____result.Var_list_int = __Var_list_int__; ____result.Var_list_float = __Var_list_float__; ____result.Var_list_string = __Var_list_string__; reader.Depth--; return(____result); }