MemoryProfilerResolver.cs

/*
 
namespace UnityEditor.Profiler.Memory
{
    using MessagePack;
    using System;

    [MessagePackObject]
    public class PackedMemorySnapshot
    {
        [Key(0)]
        public PackedNativeUnityEngineObject[] nativeObjects;
        [Key(1)]
        public PackedGCHandle[] gcHandles;
        [Key(2)]
        public Connection[] connections;
        [Key(3)]
        public ManagedHeap managedHeap;
        [Key(4)]
        public TypeDescription[] typeDescriptions;
        [Key(5)]
        public string[] classIDNames;
    }

    [Serializable]
    [MessagePackObject]
    public struct PackedNativeUnityEngineObject
    {
        [Key(0)]
        public string name;
        [Key(1)]
        public int instanceID;
        [Key(2)]
        public int size;
        [Key(3)]
        public int classID;
    }

    [Serializable]
    [MessagePackObject]
    public struct PackedGCHandle
    {
        [Key(0)]
        public UInt64 target;
    }

    [Serializable]
    [MessagePackObject]
    public struct Connection
    {
        [Key(0)]
        public int from;
        [Key(1)]
        public int to;
    }

    [Serializable]
    [MessagePackObject]
    public class ManagedHeap
    {
        [Key(0)]
        public HeapSegment[] segments;
        [Key(1)]
        public VirtualMachineInformation virtualMachineInformation;
    }

    [Serializable]
    [MessagePackObject]
    public class HeapSegment
    {
        [Key(0)]
        public byte[] bytes;
        [Key(1)]
        public UInt64 startAddress;
    }

    [Serializable]
    [MessagePackObject]
    public struct VirtualMachineInformation
    {
        [Key(0)]
        public int pointerSize;
        [Key(1)]
        public int objectHeaderSize;
        [Key(2)]
        public int arrayHeaderSize;
        [Key(3)]
        public int arrayBoundsOffsetInHeader;
        [Key(4)]
        public int arraySizeOffsetInHeader;
        [Key(5)]
        public int allocationGranularity;
    };

    [Serializable]
    [MessagePackObject]
    public class TypeDescription
    {
        [Key(0)]
        public string name;
        [Key(1)]
        public string fullname;
        [Key(2)]
        public int @namespace;
        [Key(3)]
        public int assembly;
        [Key(4)]
        public FieldDescription[] fields;
        [Key(5)]
        public byte[] staticFieldBytes;
        [Key(6)]
        public int baseOrElementTypeIndex;
        [Key(7)]
        public int size;
        [Key(8)]
        public UInt64 typeInfoAddress;
        [Key(9)]
        public int typeIndex;

        [IgnoreMember]
        public bool IsValueType
        {
            get { return (flags & TypeFlags.kValueType) != 0; }
        }

        [IgnoreMember]
        public bool IsArray
        {
            get { return (flags & TypeFlags.kArray) != 0; }
        }

        [IgnoreMember]
        public int ArrayRank
        {
            get { return (int)(flags & TypeFlags.kArrayRankMask) >> 16; }
        }

        // note:flags can't serialize but must serialize...!
        [IgnoreMember]
        private TypeFlags flags;

        private enum TypeFlags
        {
            kNone = 0,
            kValueType = 1 << 0,
            kArray = 1 << 1,
            kArrayRankMask = unchecked((int)0xFFFF0000)
        };

        public void Mutate()
        {
            flags = TypeFlags.kArrayRankMask;
        }
    }

    [Serializable]
    [MessagePackObject]
    public class FieldDescription
    {
        [Key(0)]
        public string name;
        [Key(1)]
        public int offset;
        [Key(2)]
        public int typeIndex;
        [Key(3)]
        public bool isStatic;
    }
}
*/

namespace MessagePack.Resolvers
{
    using System;
    using MessagePack;

    public class MemoryProfilerResolver : global::MessagePack.IFormatterResolver
    {
        public static readonly global::MessagePack.IFormatterResolver Instance = new MemoryProfilerResolver();

        MemoryProfilerResolver()
        {

        }

        public global::MessagePack.Formatters.IMessagePackFormatter<T> GetFormatter<T>()
        {
            return FormatterCache<T>.formatter;
        }

        static class FormatterCache<T>
        {
            public static readonly global::MessagePack.Formatters.IMessagePackFormatter<T> formatter;

            static FormatterCache()
            {
                var f = MemoryProfilerResolverGetFormatterHelper.GetFormatter(typeof(T));
                if (f != null)
                {
                    formatter = (global::MessagePack.Formatters.IMessagePackFormatter<T>)f;
                }
            }
        }
    }

    internal static class MemoryProfilerResolverGetFormatterHelper
    {
        static readonly global::System.Collections.Generic.Dictionary<Type, int> lookup;

        static MemoryProfilerResolverGetFormatterHelper()
        {
            lookup = new global::System.Collections.Generic.Dictionary<Type, int>(15)
            {
                {typeof(global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject[]), 0 },
                {typeof(global::UnityEditor.Profiler.Memory.PackedGCHandle[]), 1 },
                {typeof(global::UnityEditor.Profiler.Memory.Connection[]), 2 },
                {typeof(global::UnityEditor.Profiler.Memory.HeapSegment[]), 3 },
                {typeof(global::UnityEditor.Profiler.Memory.FieldDescription[]), 4 },
                {typeof(global::UnityEditor.Profiler.Memory.TypeDescription[]), 5 },
                {typeof(global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject), 6 },
                {typeof(global::UnityEditor.Profiler.Memory.PackedGCHandle), 7 },
                {typeof(global::UnityEditor.Profiler.Memory.Connection), 8 },
                {typeof(global::UnityEditor.Profiler.Memory.HeapSegment), 9 },
                {typeof(global::UnityEditor.Profiler.Memory.VirtualMachineInformation), 10 },
                {typeof(global::UnityEditor.Profiler.Memory.ManagedHeap), 11 },
                {typeof(global::UnityEditor.Profiler.Memory.FieldDescription), 12 },
                {typeof(global::UnityEditor.Profiler.Memory.TypeDescription), 13 },
                {typeof(global::UnityEditor.Profiler.Memory.PackedMemorySnapshot), 14 },
            };
        }

        internal static object GetFormatter(Type t)
        {
            int key;
            if (!lookup.TryGetValue(t, out key)) return null;

            switch (key)
            {
                case 0: return new global::MessagePack.Formatters.ArrayFormatter<global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject>();
                case 1: return new global::MessagePack.Formatters.ArrayFormatter<global::UnityEditor.Profiler.Memory.PackedGCHandle>();
                case 2: return new global::MessagePack.Formatters.ArrayFormatter<global::UnityEditor.Profiler.Memory.Connection>();
                case 3: return new global::MessagePack.Formatters.ArrayFormatter<global::UnityEditor.Profiler.Memory.HeapSegment>();
                case 4: return new global::MessagePack.Formatters.ArrayFormatter<global::UnityEditor.Profiler.Memory.FieldDescription>();
                case 5: return new global::MessagePack.Formatters.ArrayFormatter<global::UnityEditor.Profiler.Memory.TypeDescription>();
                case 6: return new MessagePack.Formatters.UnityEditor.Profiler.Memory.PackedNativeUnityEngineObjectFormatter();
                case 7: return new MessagePack.Formatters.UnityEditor.Profiler.Memory.PackedGCHandleFormatter();
                case 8: return new MessagePack.Formatters.UnityEditor.Profiler.Memory.ConnectionFormatter();
                case 9: return new MessagePack.Formatters.UnityEditor.Profiler.Memory.HeapSegmentFormatter();
                case 10: return new MessagePack.Formatters.UnityEditor.Profiler.Memory.VirtualMachineInformationFormatter();
                case 11: return new MessagePack.Formatters.UnityEditor.Profiler.Memory.ManagedHeapFormatter();
                case 12: return new MessagePack.Formatters.UnityEditor.Profiler.Memory.FieldDescriptionFormatter();
                case 13: return new MessagePack.Formatters.UnityEditor.Profiler.Memory.TypeDescriptionFormatter();
                case 14: return new MessagePack.Formatters.UnityEditor.Profiler.Memory.PackedMemorySnapshotFormatter();
                default: return null;
            }
        }
    }
}

namespace MessagePack.Formatters.UnityEditor.Profiler.Memory
{
    using System;
    using MessagePack;


    public sealed class PackedNativeUnityEngineObjectFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject>
    {

        public int Serialize(ref byte[] bytes, int offset, global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject value, global::MessagePack.IFormatterResolver formatterResolver)
        {

            var startOffset = offset;
            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4);
            offset += formatterResolver.GetFormatterWithVerify<string>().Serialize(ref bytes, offset, value.name, formatterResolver);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.instanceID);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.size);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.classID);
            return offset - startOffset;
        }

        public global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
        {
            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
            {
                throw new InvalidOperationException("typecode is null, struct not supported");
            }

            var startOffset = offset;
            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
            offset += readSize;

            var __name__ = default(string);
            var __instanceID__ = default(int);
            var __size__ = default(int);
            var __classID__ = default(int);

            for (int i = 0; i < length; i++)
            {
                var key = i;

                switch (key)
                {
                    case 0:
                        __name__ = formatterResolver.GetFormatterWithVerify<string>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 1:
                        __instanceID__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 2:
                        __size__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 3:
                        __classID__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    default:
                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                        break;
                }
                offset += readSize;
            }

            readSize = offset - startOffset;

            var ____result = new global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject();
            ____result.name = __name__;
            ____result.instanceID = __instanceID__;
            ____result.size = __size__;
            ____result.classID = __classID__;
            return ____result;
        }
    }


    public sealed class PackedGCHandleFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEditor.Profiler.Memory.PackedGCHandle>
    {

        public int Serialize(ref byte[] bytes, int offset, global::UnityEditor.Profiler.Memory.PackedGCHandle value, global::MessagePack.IFormatterResolver formatterResolver)
        {

            var startOffset = offset;
            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 1);
            offset += MessagePackBinary.WriteUInt64(ref bytes, offset, value.target);
            return offset - startOffset;
        }

        public global::UnityEditor.Profiler.Memory.PackedGCHandle Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
        {
            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
            {
                throw new InvalidOperationException("typecode is null, struct not supported");
            }

            var startOffset = offset;
            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
            offset += readSize;

            var __target__ = default(ulong);

            for (int i = 0; i < length; i++)
            {
                var key = i;

                switch (key)
                {
                    case 0:
                        __target__ = MessagePackBinary.ReadUInt64(bytes, offset, out readSize);
                        break;
                    default:
                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                        break;
                }
                offset += readSize;
            }

            readSize = offset - startOffset;

            var ____result = new global::UnityEditor.Profiler.Memory.PackedGCHandle();
            ____result.target = __target__;
            return ____result;
        }
    }


    public sealed class ConnectionFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEditor.Profiler.Memory.Connection>
    {

        public int Serialize(ref byte[] bytes, int offset, global::UnityEditor.Profiler.Memory.Connection value, global::MessagePack.IFormatterResolver formatterResolver)
        {

            var startOffset = offset;
            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.from);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.to);
            return offset - startOffset;
        }

        public global::UnityEditor.Profiler.Memory.Connection Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
        {
            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
            {
                throw new InvalidOperationException("typecode is null, struct not supported");
            }

            var startOffset = offset;
            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
            offset += readSize;

            var __from__ = default(int);
            var __to__ = default(int);

            for (int i = 0; i < length; i++)
            {
                var key = i;

                switch (key)
                {
                    case 0:
                        __from__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 1:
                        __to__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    default:
                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                        break;
                }
                offset += readSize;
            }

            readSize = offset - startOffset;

            var ____result = new global::UnityEditor.Profiler.Memory.Connection();
            ____result.from = __from__;
            ____result.to = __to__;
            return ____result;
        }
    }


    public sealed class HeapSegmentFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEditor.Profiler.Memory.HeapSegment>
    {

        public int Serialize(ref byte[] bytes, int offset, global::UnityEditor.Profiler.Memory.HeapSegment value, global::MessagePack.IFormatterResolver formatterResolver)
        {
            if (value == null)
            {
                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
            }

            var startOffset = offset;
            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2);
            offset += formatterResolver.GetFormatterWithVerify<byte[]>().Serialize(ref bytes, offset, value.bytes, formatterResolver);
            offset += MessagePackBinary.WriteUInt64(ref bytes, offset, value.startAddress);
            return offset - startOffset;
        }

        public global::UnityEditor.Profiler.Memory.HeapSegment Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
        {
            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
            {
                readSize = 1;
                return null;
            }

            var startOffset = offset;
            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
            offset += readSize;

            var __bytes__ = default(byte[]);
            var __startAddress__ = default(ulong);

            for (int i = 0; i < length; i++)
            {
                var key = i;

                switch (key)
                {
                    case 0:
                        __bytes__ = formatterResolver.GetFormatterWithVerify<byte[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 1:
                        __startAddress__ = MessagePackBinary.ReadUInt64(bytes, offset, out readSize);
                        break;
                    default:
                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                        break;
                }
                offset += readSize;
            }

            readSize = offset - startOffset;

            var ____result = new global::UnityEditor.Profiler.Memory.HeapSegment();
            ____result.bytes = __bytes__;
            ____result.startAddress = __startAddress__;
            return ____result;
        }
    }


    public sealed class VirtualMachineInformationFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEditor.Profiler.Memory.VirtualMachineInformation>
    {

        public int Serialize(ref byte[] bytes, int offset, global::UnityEditor.Profiler.Memory.VirtualMachineInformation value, global::MessagePack.IFormatterResolver formatterResolver)
        {

            var startOffset = offset;
            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 6);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.pointerSize);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.objectHeaderSize);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.arrayHeaderSize);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.arrayBoundsOffsetInHeader);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.arraySizeOffsetInHeader);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.allocationGranularity);
            return offset - startOffset;
        }

        public global::UnityEditor.Profiler.Memory.VirtualMachineInformation Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
        {
            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
            {
                throw new InvalidOperationException("typecode is null, struct not supported");
            }

            var startOffset = offset;
            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
            offset += readSize;

            var __pointerSize__ = default(int);
            var __objectHeaderSize__ = default(int);
            var __arrayHeaderSize__ = default(int);
            var __arrayBoundsOffsetInHeader__ = default(int);
            var __arraySizeOffsetInHeader__ = default(int);
            var __allocationGranularity__ = default(int);

            for (int i = 0; i < length; i++)
            {
                var key = i;

                switch (key)
                {
                    case 0:
                        __pointerSize__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 1:
                        __objectHeaderSize__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 2:
                        __arrayHeaderSize__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 3:
                        __arrayBoundsOffsetInHeader__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 4:
                        __arraySizeOffsetInHeader__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 5:
                        __allocationGranularity__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    default:
                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                        break;
                }
                offset += readSize;
            }

            readSize = offset - startOffset;

            var ____result = new global::UnityEditor.Profiler.Memory.VirtualMachineInformation();
            ____result.pointerSize = __pointerSize__;
            ____result.objectHeaderSize = __objectHeaderSize__;
            ____result.arrayHeaderSize = __arrayHeaderSize__;
            ____result.arrayBoundsOffsetInHeader = __arrayBoundsOffsetInHeader__;
            ____result.arraySizeOffsetInHeader = __arraySizeOffsetInHeader__;
            ____result.allocationGranularity = __allocationGranularity__;
            return ____result;
        }
    }


    public sealed class ManagedHeapFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEditor.Profiler.Memory.ManagedHeap>
    {

        public int Serialize(ref byte[] bytes, int offset, global::UnityEditor.Profiler.Memory.ManagedHeap value, global::MessagePack.IFormatterResolver formatterResolver)
        {
            if (value == null)
            {
                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
            }

            var startOffset = offset;
            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2);
            offset += formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.HeapSegment[]>().Serialize(ref bytes, offset, value.segments, formatterResolver);
            offset += formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.VirtualMachineInformation>().Serialize(ref bytes, offset, value.virtualMachineInformation, formatterResolver);
            return offset - startOffset;
        }

        public global::UnityEditor.Profiler.Memory.ManagedHeap Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
        {
            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
            {
                readSize = 1;
                return null;
            }

            var startOffset = offset;
            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
            offset += readSize;

            var __segments__ = default(global::UnityEditor.Profiler.Memory.HeapSegment[]);
            var __virtualMachineInformation__ = default(global::UnityEditor.Profiler.Memory.VirtualMachineInformation);

            for (int i = 0; i < length; i++)
            {
                var key = i;

                switch (key)
                {
                    case 0:
                        __segments__ = formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.HeapSegment[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 1:
                        __virtualMachineInformation__ = formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.VirtualMachineInformation>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    default:
                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                        break;
                }
                offset += readSize;
            }

            readSize = offset - startOffset;

            var ____result = new global::UnityEditor.Profiler.Memory.ManagedHeap();
            ____result.segments = __segments__;
            ____result.virtualMachineInformation = __virtualMachineInformation__;
            return ____result;
        }
    }


    public sealed class FieldDescriptionFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEditor.Profiler.Memory.FieldDescription>
    {

        public int Serialize(ref byte[] bytes, int offset, global::UnityEditor.Profiler.Memory.FieldDescription value, global::MessagePack.IFormatterResolver formatterResolver)
        {
            if (value == null)
            {
                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
            }

            var startOffset = offset;
            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4);
            offset += formatterResolver.GetFormatterWithVerify<string>().Serialize(ref bytes, offset, value.name, formatterResolver);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.offset);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.typeIndex);
            offset += MessagePackBinary.WriteBoolean(ref bytes, offset, value.isStatic);
            return offset - startOffset;
        }

        public global::UnityEditor.Profiler.Memory.FieldDescription Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
        {
            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
            {
                readSize = 1;
                return null;
            }

            var startOffset = offset;
            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
            offset += readSize;

            var __name__ = default(string);
            var __offset__ = default(int);
            var __typeIndex__ = default(int);
            var __isStatic__ = default(bool);

            for (int i = 0; i < length; i++)
            {
                var key = i;

                switch (key)
                {
                    case 0:
                        __name__ = formatterResolver.GetFormatterWithVerify<string>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 1:
                        __offset__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 2:
                        __typeIndex__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 3:
                        __isStatic__ = MessagePackBinary.ReadBoolean(bytes, offset, out readSize);
                        break;
                    default:
                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                        break;
                }
                offset += readSize;
            }

            readSize = offset - startOffset;

            var ____result = new global::UnityEditor.Profiler.Memory.FieldDescription();
            ____result.name = __name__;
            ____result.offset = __offset__;
            ____result.typeIndex = __typeIndex__;
            ____result.isStatic = __isStatic__;
            return ____result;
        }
    }


    public sealed class TypeDescriptionFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEditor.Profiler.Memory.TypeDescription>
    {
        // private TypeFlags flags;
        static readonly Func<global::UnityEditor.Profiler.Memory.TypeDescription, int> getFlags;
        static readonly Action<global::UnityEditor.Profiler.Memory.TypeDescription, int> setFlags;

        static TypeDescriptionFormatter()
        {
            var fieldInfo = typeof(global::UnityEditor.Profiler.Memory.TypeDescription)
                .GetField("flags", System.Reflection.BindingFlags.GetField | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);

            var getField = new System.Reflection.Emit.DynamicMethod("GetField", typeof(int), new[] { typeof(global::UnityEditor.Profiler.Memory.TypeDescription) }, typeof(global::UnityEditor.Profiler.Memory.TypeDescription).Module, true);
            {
                var il = getField.GetILGenerator();
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
                il.Emit(System.Reflection.Emit.OpCodes.Ldfld, fieldInfo);
                il.Emit(System.Reflection.Emit.OpCodes.Ret);
            }

            var setField = new System.Reflection.Emit.DynamicMethod("SetField", null, new[] { typeof(global::UnityEditor.Profiler.Memory.TypeDescription), typeof(int) }, typeof(global::UnityEditor.Profiler.Memory.TypeDescription).Module, true);
            {
                var il = setField.GetILGenerator();
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
                il.Emit(System.Reflection.Emit.OpCodes.Stfld, fieldInfo);
                il.Emit(System.Reflection.Emit.OpCodes.Ret);
            }

            getFlags = (Func<global::UnityEditor.Profiler.Memory.TypeDescription, int>)getField.CreateDelegate(typeof(Func<global::UnityEditor.Profiler.Memory.TypeDescription, int>));
            setFlags = (Action<global::UnityEditor.Profiler.Memory.TypeDescription, int>)setField.CreateDelegate(typeof(Action<global::UnityEditor.Profiler.Memory.TypeDescription, int>));
        }

        public int Serialize(ref byte[] bytes, int offset, global::UnityEditor.Profiler.Memory.TypeDescription value, global::MessagePack.IFormatterResolver formatterResolver)
        {
            if (value == null)
            {
                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
            }

            var startOffset = offset;
            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 11);
            offset += formatterResolver.GetFormatterWithVerify<string>().Serialize(ref bytes, offset, value.name, formatterResolver);
            offset += formatterResolver.GetFormatterWithVerify<string>().Serialize(ref bytes, offset, value.fullname, formatterResolver);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.@namespace);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.assembly);
            offset += formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.FieldDescription[]>().Serialize(ref bytes, offset, value.fields, formatterResolver);
            offset += formatterResolver.GetFormatterWithVerify<byte[]>().Serialize(ref bytes, offset, value.staticFieldBytes, formatterResolver);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.baseOrElementTypeIndex);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.size);
            offset += MessagePackBinary.WriteUInt64(ref bytes, offset, value.typeInfoAddress);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.typeIndex);
            offset += MessagePackBinary.WriteInt32(ref bytes, offset, getFlags(value));
            return offset - startOffset;
        }

        public global::UnityEditor.Profiler.Memory.TypeDescription Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
        {
            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
            {
                readSize = 1;
                return null;
            }

            var startOffset = offset;
            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
            offset += readSize;

            var __name__ = default(string);
            var __fullname__ = default(string);
            var __namespace__ = default(int);
            var __assembly__ = default(int);
            var __fields__ = default(global::UnityEditor.Profiler.Memory.FieldDescription[]);
            var __staticFieldBytes__ = default(byte[]);
            var __baseOrElementTypeIndex__ = default(int);
            var __size__ = default(int);
            var __typeInfoAddress__ = default(ulong);
            var __typeIndex__ = default(int);
            var __flags__ = default(int);

            for (int i = 0; i < length; i++)
            {
                var key = i;

                switch (key)
                {
                    case 0:
                        __name__ = formatterResolver.GetFormatterWithVerify<string>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 1:
                        __fullname__ = formatterResolver.GetFormatterWithVerify<string>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 2:
                        __namespace__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 3:
                        __assembly__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 4:
                        __fields__ = formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.FieldDescription[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 5:
                        __staticFieldBytes__ = formatterResolver.GetFormatterWithVerify<byte[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 6:
                        __baseOrElementTypeIndex__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 7:
                        __size__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 8:
                        __typeInfoAddress__ = MessagePackBinary.ReadUInt64(bytes, offset, out readSize);
                        break;
                    case 9:
                        __typeIndex__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    case 10:
                        __flags__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
                        break;
                    default:
                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                        break;
                }
                offset += readSize;
            }

            readSize = offset - startOffset;

            var ____result = new global::UnityEditor.Profiler.Memory.TypeDescription();
            ____result.name = __name__;
            ____result.fullname = __fullname__;
            ____result.@namespace = __namespace__;
            ____result.assembly = __assembly__;
            ____result.fields = __fields__;
            ____result.staticFieldBytes = __staticFieldBytes__;
            ____result.baseOrElementTypeIndex = __baseOrElementTypeIndex__;
            ____result.size = __size__;
            ____result.typeInfoAddress = __typeInfoAddress__;
            ____result.typeIndex = __typeIndex__;
            setFlags(____result, __flags__);
            return ____result;
        }
    }

    public sealed class PackedMemorySnapshotFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEditor.Profiler.Memory.PackedMemorySnapshot>
    {
        public int Serialize(ref byte[] bytes, int offset, global::UnityEditor.Profiler.Memory.PackedMemorySnapshot value, global::MessagePack.IFormatterResolver formatterResolver)
        {
            if (value == null)
            {
                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
            }

            var startOffset = offset;
            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 6);
            offset += formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject[]>().Serialize(ref bytes, offset, value.nativeObjects, formatterResolver);
            offset += formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.PackedGCHandle[]>().Serialize(ref bytes, offset, value.gcHandles, formatterResolver);
            offset += formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.Connection[]>().Serialize(ref bytes, offset, value.connections, formatterResolver);
            offset += formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.ManagedHeap>().Serialize(ref bytes, offset, value.managedHeap, formatterResolver);
            offset += formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.TypeDescription[]>().Serialize(ref bytes, offset, value.typeDescriptions, formatterResolver);
            offset += formatterResolver.GetFormatterWithVerify<string[]>().Serialize(ref bytes, offset, value.classIDNames, formatterResolver);
            return offset - startOffset;
        }

        public global::UnityEditor.Profiler.Memory.PackedMemorySnapshot Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
        {
            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
            {
                readSize = 1;
                return null;
            }

            var startOffset = offset;
            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
            offset += readSize;

            var __nativeObjects__ = default(global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject[]);
            var __gcHandles__ = default(global::UnityEditor.Profiler.Memory.PackedGCHandle[]);
            var __connections__ = default(global::UnityEditor.Profiler.Memory.Connection[]);
            var __managedHeap__ = default(global::UnityEditor.Profiler.Memory.ManagedHeap);
            var __typeDescriptions__ = default(global::UnityEditor.Profiler.Memory.TypeDescription[]);
            var __classIDNames__ = default(string[]);

            for (int i = 0; i < length; i++)
            {
                var key = i;

                switch (key)
                {
                    case 0:
                        __nativeObjects__ = formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.PackedNativeUnityEngineObject[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 1:
                        __gcHandles__ = formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.PackedGCHandle[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 2:
                        __connections__ = formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.Connection[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 3:
                        __managedHeap__ = formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.ManagedHeap>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 4:
                        __typeDescriptions__ = formatterResolver.GetFormatterWithVerify<global::UnityEditor.Profiler.Memory.TypeDescription[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    case 5:
                        __classIDNames__ = formatterResolver.GetFormatterWithVerify<string[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
                        break;
                    default:
                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                        break;
                }
                offset += readSize;
            }

            readSize = offset - startOffset;

            var ____result = new global::UnityEditor.Profiler.Memory.PackedMemorySnapshot();
            ____result.nativeObjects = __nativeObjects__;
            ____result.gcHandles = __gcHandles__;
            ____result.connections = __connections__;
            ____result.managedHeap = __managedHeap__;
            ____result.typeDescriptions = __typeDescriptions__;
            ____result.classIDNames = __classIDNames__;
            return ____result;
        }
    }
}