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