public String[] Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
if (reader.TryReadNil())
{
return(null);
}
else
{
var len = reader.ReadArrayHeader();
var array = new String[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = reader.ReadString();
}
return(array);
}
}
public global::net.caffeineinject.multiplayerar.servershared.messagepackobjects.PlayerMoveCommand 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 __PlayerId__ = default(string);
var __Position__ = default(global::UnityEngine.Vector3);
var __Rotation__ = default(global::UnityEngine.Quaternion);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__PlayerId__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__Position__ = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Vector3>().Deserialize(ref reader, options);
break;
case 2:
__Rotation__ = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Quaternion>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::net.caffeineinject.multiplayerar.servershared.messagepackobjects.PlayerMoveCommand();
____result.PlayerId = __PlayerId__;
____result.Position = __Position__;
____result.Rotation = __Rotation__;
reader.Depth--;
return(____result);
}
public global::Common.LockstepInputs 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 __TickId__ = default(int);
var __DeltaTime__ = default(global::Common.Fix64);
var __UserInputs__ = default(global::Common.UserInputs[][]);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__TickId__ = reader.ReadInt32();
break;
case 1:
__DeltaTime__ = formatterResolver.GetFormatterWithVerify <global::Common.Fix64>().Deserialize(ref reader, options);
break;
case 2:
__UserInputs__ = formatterResolver.GetFormatterWithVerify <global::Common.UserInputs[][]>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Common.LockstepInputs();
____result.TickId = __TickId__;
____result.DeltaTime = __DeltaTime__;
____result.UserInputs = __UserInputs__;
reader.Depth--;
return(____result);
}
public static Guid[] Deserialize(ref MessagePackReader reader)
{
if (reader.TryReadNil())
{
return(null);
}
var len = reader.ReadArrayHeader();
var result = new Guid[len];
for (int i = 0; i < len; i++)
{
result[i] = formatter.Deserialize(ref reader, null);
}
return(result);
}
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::Fenix.Common.Message.CreateActorReq.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::Fenix.Common.DefaultErrCode);
var __arg1__ = default(string);
var __arg2__ = default(uint);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__code__ = formatterResolver.GetFormatterWithVerify <global::Fenix.Common.DefaultErrCode>().Deserialize(ref reader, options);
break;
case 1:
__arg1__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 2:
__arg2__ = reader.ReadUInt32();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Fenix.Common.Message.CreateActorReq.Callback();
____result.code = __code__;
____result.arg1 = __arg1__;
____result.arg2 = __arg2__;
reader.Depth--;
return(____result);
}
public global::Shared.Message.__ServerGModule__LoginService__LoginReq 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 __username__ = default(string);
var __password__ = default(string);
var __callback__ = default(global::Shared.Message.__ServerGModule__LoginService__LoginReq.Callback);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__username__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__password__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 2:
__callback__ = formatterResolver.GetFormatterWithVerify <global::Shared.Message.__ServerGModule__LoginService__LoginReq.Callback>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Shared.Message.__ServerGModule__LoginService__LoginReq();
____result.username = __username__;
____result.password = __password__;
____result.callback = __callback__;
reader.Depth--;
return(____result);
}
public global::CoreLibrary.Models.Crypto.CryptoKeyProtector 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 __ProtectorKey__ = default(byte[]);
var __ProtectorState__ = default(object[]);
var __ProtectorName__ = default(string);
for (int i = 0; i < length; i++)
{
switch (i)
{
case 0:
__ProtectorKey__ = reader.ReadBytes()?.ToArray();
break;
case 1:
__ProtectorState__ = formatterResolver.GetFormatterWithVerify <object[]>().Deserialize(ref reader, options);
break;
case 2:
__ProtectorName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::CoreLibrary.Models.Crypto.CryptoKeyProtector();
____result.ProtectorKey = __ProtectorKey__;
____result.ProtectorState = __ProtectorState__;
____result.ProtectorName = __ProtectorName__;
____result.OnAfterDeserialize();
reader.Depth--;
return(____result);
}
public T[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
var formatter = formatterResolver.GetFormatterWithVerify <T>();
var len = reader.ReadArrayHeader();
var array = new T[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = formatter.Deserialize(ref reader, formatterResolver);
}
return(array);
}
public QueryRequestData Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
int size = reader.ReadArrayHeader();
string select = reader.ReadString();
ConsistencyType consistency = (ConsistencyType)Enum.Parse(typeof(ConsistencyType), reader.ReadString(), true);
long timeout = reader.ReadInt64();
int?querypagesize = null;
int?querytype = null;
if (size == 5)
{
querypagesize = reader.ReadInt32();
querytype = reader.ReadInt32();
}
return(new QueryRequestData(select, consistency, timeout, querypagesize, (QueryType)querytype));
}
public TraceRecord Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
// Older trace records (N3 RC3 and before) did not have gas consumed value.
// When parsing TraceRecords, if there are only two fields in the TraceRecord array, provide a dummy gasConsumed value.
var fieldCount = reader.ReadArrayHeader();
if (fieldCount != 2 && fieldCount != 3)
{
throw new MessagePackSerializationException($"Invalid TraceRecord Array Header {fieldCount}");
}
var state = options.Resolver.GetFormatterWithVerify <VMState>().Deserialize(ref reader, options);
var gasConsumed = fieldCount == 3 ? reader.ReadInt64() : 0;
var stackFrames = options.Resolver.GetFormatterWithVerify <IReadOnlyList <TraceRecord.StackFrame> >().Deserialize(ref reader, options);
return(new TraceRecord(state, gasConsumed, stackFrames));
}
public Tuple <T1> Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
var count = reader.ReadArrayHeader();
if (count != 1)
{
ThrowHelper.ThrowInvalidOperationException_Tuple_Count();
}
var item1 = formatterResolver.GetFormatterWithVerify <T1>().Deserialize(ref reader, formatterResolver);
return(new Tuple <T1>(item1));
}
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 global::Server.SharedThings.Packets.Representations.OwnPlayer Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __Nickname__ = default(string);
var __X__ = default(float);
var __Y__ = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__Nickname__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__X__ = reader.ReadSingle();
break;
case 2:
__Y__ = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.Representations.OwnPlayer();
____result.Nickname = __Nickname__;
____result.X = __X__;
____result.Y = __Y__;
return(____result);
}
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 quaternion 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 z = default(float);
var w = 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:
z = reader.ReadSingle();
break;
case 3:
w = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var result = new quaternion(x, y, z, w);
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 global::Server.SharedThings.Packets.ClientPackets.RegisterRequest Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __Key__ = default(string);
var __Username__ = default(string);
var __PasswordHash__ = default(byte[]);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__Key__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__Username__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 2:
__PasswordHash__ = formatterResolver.GetFormatterWithVerify <byte[]>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.ClientPackets.RegisterRequest();
____result.Key = __Key__;
____result.Username = __Username__;
____result.PasswordHash = __PasswordHash__;
return(____result);
}
public NewExposedTemplateChild.ChildWrapper 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();
NewExposedTemplateChild.ChildWrapper wrapper = new NewExposedTemplateChild.ChildWrapper
{
Values = new Dictionary <int, object>(3),
Dirty = new Dictionary <int, bool>(3)
};
for (int i = 0; i < length; i++)
{
int id = reader.ReadInt32();
if (id == 0)
{
wrapper.Values[0] = wrapper.Deserialize(0, ref reader, options);
wrapper.Dirty[0] = true;
continue;
}
if (id == 1)
{
wrapper.Values[1] = wrapper.Deserialize(1, ref reader, options);
wrapper.Dirty[1] = true;
continue;
}
if (id == 2)
{
wrapper.Values[2] = wrapper.Deserialize(2, ref reader, options);
wrapper.Dirty[2] = true;
}
}
reader.Depth--;
return(wrapper);
}
public global::MSP_Item_ETC 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 __Name__ = default(string);
var __Image__ = default(string);
for (int i = 0; i < length; i++)
{
switch (i)
{
case 0:
__DataKey__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__Name__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 2:
__Image__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::MSP_Item_ETC();
____result.DataKey = __DataKey__;
____result.Name = __Name__;
____result.Image = __Image__;
reader.Depth--;
return(____result);
}
public global::Game.Core.WorldData 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 __Width__ = default(int);
var __Height__ = default(int);
var __TileMap__ = default(int[, ]);
for (int i = 0; i < length; i++)
{
switch (i)
{
case 0:
__Width__ = reader.ReadInt32();
break;
case 1:
__Height__ = reader.ReadInt32();
break;
case 2:
__TileMap__ = formatterResolver.GetFormatterWithVerify <int[, ]>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Game.Core.WorldData();
____result.Width = __Width__;
____result.Height = __Height__;
____result.TileMap = __TileMap__;
reader.Depth--;
return(____result);
}
public global::UnityEngine.Vector4 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);
var z = default(float);
var w = 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:
z = reader.ReadSingle();
break;
case 3:
w = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var result = new global::UnityEngine.Vector4(x, y, z, w);
return(result);
}
public BitArray Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
else
{
var len = reader.ReadArrayHeader();
var array = new BitArray(len);
for (int i = 0; i < len; i++)
{
array[i] = reader.ReadBoolean();
}
return(array);
}
}
public DateTime[] Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
if (reader.TryReadNil())
{
return(null);
}
else
{
var len = reader.ReadArrayHeader();
var array = new DateTime[len];
for (int i = 0; i < array.Length; i++)
{
var dateData = reader.ReadInt64();
array[i] = DateTime.FromBinary(dateData);
}
return(array);
}
}
public static IListTracker <T> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var tracker = new TrackableListTracker <T>();
var length = reader.ReadArrayHeader();
for (int i = 0; i < length; i++)
{
var operation = reader.ReadInt32();
var index = reader.ReadInt32();
var value = MessagePackSerializer.Deserialize <T>(ref reader, options);
switch ((TrackableListOperation)operation)
{
case TrackableListOperation.Insert:
tracker.TrackInsert(index, value);
break;
case TrackableListOperation.Remove:
tracker.TrackRemove(index, value);
break;
case TrackableListOperation.Modify:
tracker.TrackModify(index, default(T), value);
break;
case TrackableListOperation.PushFront:
tracker.TrackPushFront(value);
break;
case TrackableListOperation.PushBack:
tracker.TrackPushBack(value);
break;
case TrackableListOperation.PopFront:
tracker.TrackPopFront(default(T));
break;
case TrackableListOperation.PopBack:
tracker.TrackPopBack(default(T));
break;
}
}
return(tracker);
}
public ValueTuple <T1> Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
if (reader.IsNil)
{
throw new InvalidOperationException("Data is Nil, ValueTuple can not be null.");
}
else
{
var count = reader.ReadArrayHeader();
if (count != 1)
{
throw new InvalidOperationException("Invalid ValueTuple count");
}
var item1 = resolver.GetFormatterWithVerify <T1>().Deserialize(ref reader, resolver);
return(new ValueTuple <T1>(item1));
}
}
public global::UnityEngine.Gradient Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
return(null);
}
IFormatterResolver resolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __colorKeys__ = default(global::UnityEngine.GradientColorKey[]);
var __alphaKeys__ = default(global::UnityEngine.GradientAlphaKey[]);
var __mode__ = default(global::UnityEngine.GradientMode);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__colorKeys__ = resolver.GetFormatterWithVerify <global::UnityEngine.GradientColorKey[]>().Deserialize(ref reader, options);
break;
case 1:
__alphaKeys__ = resolver.GetFormatterWithVerify <global::UnityEngine.GradientAlphaKey[]>().Deserialize(ref reader, options);
break;
case 2:
__mode__ = resolver.GetFormatterWithVerify <global::UnityEngine.GradientMode>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::UnityEngine.Gradient();
____result.colorKeys = __colorKeys__;
____result.alphaKeys = __alphaKeys__;
____result.mode = __mode__;
return(____result);
}
public global::UnityEngine.AnimationCurve Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
return(null);
}
IFormatterResolver resolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __keys__ = default(global::UnityEngine.Keyframe[]);
var __postWrapMode__ = default(global::UnityEngine.WrapMode);
var __preWrapMode__ = default(global::UnityEngine.WrapMode);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__keys__ = resolver.GetFormatterWithVerify <global::UnityEngine.Keyframe[]>().Deserialize(ref reader, options);
break;
case 1:
__postWrapMode__ = resolver.GetFormatterWithVerify <global::UnityEngine.WrapMode>().Deserialize(ref reader, options);
break;
case 2:
__preWrapMode__ = resolver.GetFormatterWithVerify <global::UnityEngine.WrapMode>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::UnityEngine.AnimationCurve();
____result.keys = __keys__;
____result.postWrapMode = __postWrapMode__;
____result.preWrapMode = __preWrapMode__;
return(____result);
}
public SolutionId?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
try
{
if (reader.TryReadNil())
{
return(null);
}
Contract.ThrowIfFalse(reader.ReadArrayHeader() == 2);
var id = GuidFormatter.Instance.Deserialize(ref reader, options);
var debugName = reader.ReadString();
return(SolutionId.CreateFromSerialized(id, debugName));
}
catch (Exception e) when(e is not MessagePackSerializationException)
{
throw new MessagePackSerializationException(e.Message, e);
}
}
public ValueTuple <T1, T2> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("Data is Nil, ValueTuple can not be null.");
}
else
{
var count = reader.ReadArrayHeader();
if (count != 2)
{
throw new InvalidOperationException("Invalid ValueTuple count");
}
var item1 = options.Resolver.GetFormatterWithVerify <T1>().Deserialize(ref reader, options);
var item2 = options.Resolver.GetFormatterWithVerify <T2>().Deserialize(ref reader, options);
return(new ValueTuple <T1, T2>(item1, item2));
}
}