public global::TeamSystem.TeamAllocationData Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                throw new global::System.InvalidOperationException("typecode is null, struct not supported");
            }

            options.Security.DepthStep(ref reader);
            global::MessagePack.IFormatterResolver formatterResolver = options.Resolver;
            var length     = reader.ReadArrayHeader();
            var ____result = new global::TeamSystem.TeamAllocationData();

            for (int i = 0; i < length; i++)
            {
                switch (i)
                {
                case 0:
                    ____result.c = formatterResolver.GetFormatterWithVerify <int[]>().Deserialize(ref reader, options);
                    break;

                case 1:
                    ____result.t = formatterResolver.GetFormatterWithVerify <global::TeamSystem.Team[]>().Deserialize(ref reader, options);
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            reader.Depth--;
            return(____result);
        }
        public global::MultiSyncRequest Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                throw new global::System.InvalidOperationException("typecode is null, struct not supported");
            }

            options.Security.DepthStep(ref reader);
            global::MessagePack.IFormatterResolver formatterResolver = options.Resolver;
            var length     = reader.ReadArrayHeader();
            var ____result = new global::MultiSyncRequest();

            for (int i = 0; i < length; i++)
            {
                switch (i)
                {
                case 0:
                    ____result.ID = reader.ReadInt32();
                    break;

                case 1:
                    ____result.tfs = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <global::SerializableTransform> >().Deserialize(ref reader, options);
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            reader.Depth--;
            return(____result);
        }
        public global::MultiSyncPlayer Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                throw new global::System.InvalidOperationException("typecode is null, struct not supported");
            }

            options.Security.DepthStep(ref reader);
            var length = reader.ReadArrayHeader();
            var __C__  = default(int);
            var __S__  = default(byte[]);

            for (int i = 0; i < length; i++)
            {
                switch (i)
                {
                case 0:
                    __C__ = reader.ReadInt32();
                    break;

                case 1:
                    __S__ = reader.ReadBytes()?.ToArray();
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            var ____result = new global::MultiSyncPlayer(__C__, __S__);

            reader.Depth--;
            return(____result);
        }
Beispiel #4
0
        public global::TestData2.Nest2.IdType Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            reader.Skip();
            var ____result = new global::TestData2.Nest2.IdType();

            return(____result);
        }
Beispiel #5
0
        public global::DFrame.ExecuteResult Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            options.Security.DepthStep(ref reader);
            global::MessagePack.IFormatterResolver formatterResolver = options.Resolver;
            var length           = reader.ReadArrayHeader();
            var __WorkloadId__   = default(global::DFrame.WorkloadId);
            var __Elapsed__      = default(global::System.TimeSpan);
            var __ExecutionNo__  = default(long);
            var __HasError__     = default(bool);
            var __ErrorMessage__ = default(string);

            for (int i = 0; i < length; i++)
            {
                switch (i)
                {
                case 0:
                    __WorkloadId__ = formatterResolver.GetFormatterWithVerify <global::DFrame.WorkloadId>().Deserialize(ref reader, options);
                    break;

                case 1:
                    __Elapsed__ = formatterResolver.GetFormatterWithVerify <global::System.TimeSpan>().Deserialize(ref reader, options);
                    break;

                case 2:
                    __ExecutionNo__ = reader.ReadInt64();
                    break;

                case 3:
                    __HasError__ = reader.ReadBoolean();
                    break;

                case 4:
                    __ErrorMessage__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            var ____result = new global::DFrame.ExecuteResult(__WorkloadId__, __Elapsed__, __ExecutionNo__, __HasError__, __ErrorMessage__);

            reader.Depth--;
            return(____result);
        }
Beispiel #6
0
        public global::TestData2.B Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            options.Security.DepthStep(ref reader);
            var formatterResolver = options.Resolver;
            var length            = reader.ReadMapHeader();
            var ____result        = new global::TestData2.B();

            for (int i = 0; i < length; i++)
            {
                var stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader);
                switch (stringKey.Length)
                {
                default:
FAIL:
                    reader.Skip();
                    continue;

                case 3:
                    if (global::MessagePack.Internal.AutomataKeyGen.GetKey(ref stringKey) != 7566177UL)
                    {
                        goto FAIL;
                    }

                    ____result.ass = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <global::TestData2.A> >().Deserialize(ref reader, options);
                    continue;

                case 1:
                    switch (global::MessagePack.Internal.AutomataKeyGen.GetKey(ref stringKey))
                    {
                    default: goto FAIL;

                    case 99UL:
                        ____result.c = formatterResolver.GetFormatterWithVerify <global::TestData2.C>().Deserialize(ref reader, options);
                        continue;

                    case 97UL:
                        ____result.a = reader.ReadInt32();
                        continue;
                    }
                }
            }

            reader.Depth--;
            return(____result);
        }
        public global::BaseVRPlayer.PlayerInfo Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                throw new global::System.InvalidOperationException("typecode is null, struct not supported");
            }

            options.Security.DepthStep(ref reader);
            global::MessagePack.IFormatterResolver formatterResolver = options.Resolver;
            var length     = reader.ReadArrayHeader();
            var ____result = new global::BaseVRPlayer.PlayerInfo();

            for (int i = 0; i < length; i++)
            {
                switch (i)
                {
                case 0:
                    ____result.lP = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Vector3>().Deserialize(ref reader, options);
                    break;

                case 1:
                    ____result.lR = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Quaternion>().Deserialize(ref reader, options);
                    break;

                case 2:
                    ____result.hP = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Vector3>().Deserialize(ref reader, options);
                    break;

                case 3:
                    ____result.hR = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Quaternion>().Deserialize(ref reader, options);
                    break;

                case 4:
                    ____result.rP = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Vector3>().Deserialize(ref reader, options);
                    break;

                case 5:
                    ____result.rR = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Quaternion>().Deserialize(ref reader, options);
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            reader.Depth--;
            return(____result);
        }
Beispiel #8
0
        public global::TestData2.PropNameCheck2 Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            options.Security.DepthStep(ref reader);
            var formatterResolver = options.Resolver;
            var length            = reader.ReadMapHeader();
            var ____result        = new global::TestData2.PropNameCheck2();

            for (int i = 0; i < length; i++)
            {
                var stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader);
                switch (stringKey.Length)
                {
                default:
FAIL:
                    reader.Skip();
                    continue;

                case 11:
                    switch (global::MessagePack.Internal.AutomataKeyGen.GetKey(ref stringKey))
                    {
                    default: goto FAIL;

                    case 8243118316933118285UL:
                        switch (global::MessagePack.Internal.AutomataKeyGen.GetKey(ref stringKey))
                        {
                        default: goto FAIL;

                        case 3242356UL:
                            ____result.MyProperty1 = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
                            continue;

                        case 3307892UL:
                            ____result.MyProperty2 = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
                            continue;
                        }
                    }
                }
            }

            reader.Depth--;
            return(____result);
        }
Beispiel #9
0
        public global::TestData2.Nest2 Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            options.Security.DepthStep(ref reader);
            var formatterResolver = options.Resolver;
            var length            = reader.ReadMapHeader();
            var ____result        = new global::TestData2.Nest2();

            for (int i = 0; i < length; i++)
            {
                var stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader);
                switch (stringKey.Length)
                {
                default:
FAIL:
                    reader.Skip();
                    continue;

                case 6:
                    if (global::MessagePack.Internal.AutomataKeyGen.GetKey(ref stringKey) != 110266531802693UL)
                    {
                        goto FAIL;
                    }

                    ____result.EnumId = formatterResolver.GetFormatterWithVerify <global::TestData2.Nest2.Id>().Deserialize(ref reader, options);
                    continue;

                case 7:
                    if (global::MessagePack.Internal.AutomataKeyGen.GetKey(ref stringKey) != 28228257876896835UL)
                    {
                        goto FAIL;
                    }

                    ____result.ClassId = formatterResolver.GetFormatterWithVerify <global::TestData2.Nest2.IdType>().Deserialize(ref reader, options);
                    continue;
                }
            }

            reader.Depth--;
            return(____result);
        }
Beispiel #10
0
        public global::TestData2.Record Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            options.Security.DepthStep(ref reader);
            var formatterResolver = options.Resolver;
            var length            = reader.ReadMapHeader();
            var __SomeProperty__  = default(string);

            for (int i = 0; i < length; i++)
            {
                var stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader);
                switch (stringKey.Length)
                {
                default:
FAIL:
                    reader.Skip();
                    continue;

                case 12:
                    if (!global::System.MemoryExtensions.SequenceEqual(stringKey, GetSpan_SomeProperty().Slice(1)))
                    {
                        goto FAIL;
                    }

                    __SomeProperty__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
                    continue;
                }
            }

            var ____result = new global::TestData2.Record(__SomeProperty__);

            reader.Depth--;
            return(____result);
        }
Beispiel #11
0
        public global::DFrame.WorkloadInfo Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            options.Security.DepthStep(ref reader);
            global::MessagePack.IFormatterResolver formatterResolver = options.Resolver;
            var length        = reader.ReadArrayHeader();
            var __Name__      = default(string);
            var __Arguments__ = default(global::DFrame.WorkloadParameterInfo[]);

            for (int i = 0; i < length; i++)
            {
                switch (i)
                {
                case 0:
                    __Name__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
                    break;

                case 1:
                    __Arguments__ = formatterResolver.GetFormatterWithVerify <global::DFrame.WorkloadParameterInfo[]>().Deserialize(ref reader, options);
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            var ____result = new global::DFrame.WorkloadInfo(__Name__, __Arguments__);

            reader.Depth--;
            return(____result);
        }
Beispiel #12
0
        public global::DFrame.BatchedExecuteResult Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            options.Security.DepthStep(ref reader);
            global::MessagePack.IFormatterResolver formatterResolver = options.Resolver;
            var length             = reader.ReadArrayHeader();
            var __WorkloadId__     = default(global::DFrame.WorkloadId);
            var __BatchedElapsed__ = default(global::DFrame.BatchList);

            for (int i = 0; i < length; i++)
            {
                switch (i)
                {
                case 0:
                    __WorkloadId__ = formatterResolver.GetFormatterWithVerify <global::DFrame.WorkloadId>().Deserialize(ref reader, options);
                    break;

                case 1:
                    __BatchedElapsed__ = formatterResolver.GetFormatterWithVerify <global::DFrame.BatchList>().Deserialize(ref reader, options);
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            var ____result = new global::DFrame.BatchedExecuteResult(__WorkloadId__, __BatchedElapsed__);

            reader.Depth--;
            return(____result);
        }
Beispiel #13
0
        public global::DFrame.WorkloadParameterInfo Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            options.Security.DepthStep(ref reader);
            global::MessagePack.IFormatterResolver formatterResolver = options.Resolver;
            var length            = reader.ReadArrayHeader();
            var __ParameterType__ = default(global::DFrame.AllowParameterType);
            var __IsNullable__    = default(bool);
            var __IsArray__       = default(bool);
            var __DefaultValue__  = default(object);
            var __ParameterName__ = default(string);
            var __EnumNames__     = default(string[]);
            var __EnumTypeName__  = default(string);

            for (int i = 0; i < length; i++)
            {
                switch (i)
                {
                case 0:
                    __ParameterType__ = formatterResolver.GetFormatterWithVerify <global::DFrame.AllowParameterType>().Deserialize(ref reader, options);
                    break;

                case 1:
                    __IsNullable__ = reader.ReadBoolean();
                    break;

                case 2:
                    __IsArray__ = reader.ReadBoolean();
                    break;

                case 3:
                    __DefaultValue__ = formatterResolver.GetFormatterWithVerify <object>().Deserialize(ref reader, options);
                    break;

                case 4:
                    __ParameterName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
                    break;

                case 5:
                    __EnumNames__ = formatterResolver.GetFormatterWithVerify <string[]>().Deserialize(ref reader, options);
                    break;

                case 6:
                    __EnumTypeName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            var ____result = new global::DFrame.WorkloadParameterInfo(__ParameterType__, __IsNullable__, __IsArray__, __DefaultValue__, __ParameterName__, __EnumNames__, __EnumTypeName__);

            reader.Depth--;
            return(____result);
        }
        public global::MultiInitialData Deserialize(ref global::MessagePack.MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                throw new global::System.InvalidOperationException("typecode is null, struct not supported");
            }

            options.Security.DepthStep(ref reader);
            global::MessagePack.IFormatterResolver formatterResolver = options.Resolver;
            var length     = reader.ReadArrayHeader();
            var ____result = new global::MultiInitialData();

            for (int i = 0; i < length; i++)
            {
                switch (i)
                {
                case 0:
                    ____result.T = reader.ReadInt32();
                    break;

                case 1:
                    ____result.sOI = formatterResolver.GetFormatterWithVerify <int[]>().Deserialize(ref reader, options);
                    break;

                case 2:
                    ____result.sOK = formatterResolver.GetFormatterWithVerify <int[]>().Deserialize(ref reader, options);
                    break;

                case 3:
                    ____result.gC = formatterResolver.GetFormatterWithVerify <int[]>().Deserialize(ref reader, options);
                    break;

                case 4:
                    ____result.gT = formatterResolver.GetFormatterWithVerify <int[]>().Deserialize(ref reader, options);
                    break;

                case 5:
                    ____result.gt = formatterResolver.GetFormatterWithVerify <int[]>().Deserialize(ref reader, options);
                    break;

                case 6:
                    ____result.gN = formatterResolver.GetFormatterWithVerify <string[]>().Deserialize(ref reader, options);
                    break;

                case 7:
                    ____result.sI = reader.ReadInt32();
                    break;

                case 8:
                    ____result.sOT = reader.ReadInt32();
                    break;

                case 9:
                    ____result.tN = reader.ReadInt32();
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            reader.Depth--;
            return(____result);
        }