Exemple #1
0
        public static bool TryParseObjectHeader(CachedSnapshot snapshot, ulong ptrObjectHeader, out ManagedObjectInfo info)
        {
            bool resolveFailed = false;
            var  heap          = snapshot.managedHeapSections;

            info = new ManagedObjectInfo();
            info.ManagedObjectIndex = -1;

            ulong ptrIdentity = 0;
            var   boHeader    = heap.Find(ptrObjectHeader, snapshot.virtualMachineInformation);

            if (!boHeader.IsValid)
            {
                resolveFailed = true;
            }
            else
            {
                boHeader.TryReadPointer(out ptrIdentity);

                info.PtrTypeInfo      = ptrIdentity;
                info.ITypeDescription = snapshot.typeDescriptions.TypeInfo2ArrayIndex(info.PtrTypeInfo);

                if (info.ITypeDescription < 0)
                {
                    var boIdentity = heap.Find(ptrIdentity, snapshot.virtualMachineInformation);
                    if (boIdentity.IsValid)
                    {
                        ulong ptrTypeInfo;
                        boIdentity.TryReadPointer(out ptrTypeInfo);
                        info.PtrTypeInfo      = ptrTypeInfo;
                        info.ITypeDescription = snapshot.typeDescriptions.TypeInfo2ArrayIndex(info.PtrTypeInfo);
                        resolveFailed         = info.ITypeDescription < 0;
                    }
                    else
                    {
                        resolveFailed = true;
                    }
                }
            }

            if (resolveFailed)
            {
#if DEBUG_VALIDATION
                UnityEngine.Debug.LogError("Bad object header at address: " + ptrIdentity);
#endif

                info.PtrTypeInfo      = 0;
                info.ITypeDescription = -1;
                info.Size             = 0;
                info.PtrObject        = 0;
                info.data             = default(BytesAndOffset);

                return(false);
            }


            info.Size      = SizeOfObjectInBytes(snapshot, info.ITypeDescription, boHeader, heap);
            info.data      = boHeader;
            info.PtrObject = ptrObjectHeader;
            return(true);
        }
Exemple #2
0
 public ObjectReferenceTable(Database.Schema schema, SnapshotObjectDataFormatter formatter, CachedSnapshot snapshot, ManagedData crawledData, ObjectData obj, ObjectMetaType metaType)
     : base(schema, formatter, snapshot, crawledData, metaType)
 {
     m_Object     = obj;
     m_References = ObjectConnection.GetAllObjectConnectingTo(snapshot, obj);
     InitObjectList();
 }
Exemple #3
0
        public ObjectReferenceTable(Database.Schema schema, SnapshotObjectDataFormatter formatter, CachedSnapshot snapshot, ManagedData crawledData, ObjectData obj, ObjectMetaType metaType)
            : base(schema, formatter, snapshot, crawledData, metaType)
        {
            m_Object     = obj;
            m_References = ObjectConnection.GetAllObjectConnectingTo(snapshot, obj);
#if DEBUG_VALIDATION
            int toUnifiedIndex = m_Object.GetUnifiedObjectIndex(snapshot);
            var toManagedIndex = snapshot.UnifiedObjectIndexToManagedObjectIndex(toUnifiedIndex);

            for (int k = 0; k != m_References.Length; ++k)
            {
                var oFrom = m_References[k];

                switch (oFrom.dataType)
                {
                case ObjectDataType.ReferenceArray:
                case ObjectDataType.ReferenceObject:
                case ObjectDataType.Value:
                    if (oFrom.m_Parent != null)
                    {
                        oFrom = oFrom.m_Parent.obj;
                    }
                    break;
                }

                bool connectionFound = false;
                switch (oFrom.dataType)
                {
                case ObjectDataType.Global:
                {
                    if (snapshot.HasGlobalConnection(toManagedIndex))
                    {
                        connectionFound = true;
                    }
                }
                break;

                case ObjectDataType.Type:
                {
                    if (snapshot.HasManagedTypeConnection(oFrom.managedTypeIndex, toManagedIndex))
                    {
                        connectionFound = true;
                    }
                }
                break;

                case ObjectDataType.Array:
                case ObjectDataType.BoxedValue:
                case ObjectDataType.Object:
                {
                    if (snapshot.HasObjectConnection(oFrom.GetUnifiedObjectIndex(snapshot), toUnifiedIndex))
                    {
                        connectionFound = true;
                        break;
                    }
                }
                break;

                case ObjectDataType.NativeObject:
                {
                    if (snapshot.HasObjectConnection(oFrom.GetUnifiedObjectIndex(snapshot), toUnifiedIndex))
                    {
                        connectionFound = true;
                        break;
                    }
                }
                break;
                }
                if (!connectionFound)
                {
                    UnityEngine.Debug.LogError("Connection not found, index =" + k);
                }
            }
#endif
            InitObjectList();
        }
 string IObjectDataTypeFormatter.Format(CachedSnapshot snapshot, ObjectData od, IDataFormatter formatter)
 {
     return(formatter.Format(od.managedObjectData.ReadUInt32()));
 }
Exemple #5
0
 public TypeBase(CachedSnapshot snapshot)
 {
     ComputeTypeBases(snapshot);
 }
Exemple #6
0
        public static ManagedObjectInfo ParseObjectHeader(CachedSnapshot snapshot, BytesAndOffset byteOffset, bool ignoreBadHeaderError)
        {
            var heap = snapshot.managedHeapSections;
            ManagedObjectInfo objectInfo;

            objectInfo                    = new ManagedObjectInfo();
            objectInfo.PtrObject          = 0;
            objectInfo.ManagedObjectIndex = -1;

            var boHeader    = byteOffset;
            var ptrIdentity = boHeader.ReadPointer();

            objectInfo.PtrTypeInfo      = ptrIdentity;
            objectInfo.ITypeDescription = snapshot.typeDescriptions.TypeInfo2ArrayIndex(objectInfo.PtrTypeInfo);
            bool error = false;

            if (objectInfo.ITypeDescription < 0)
            {
                var boIdentity = heap.Find(ptrIdentity, snapshot.virtualMachineInformation);
                if (boIdentity.IsValid)
                {
                    var ptrTypeInfo = boIdentity.ReadPointer();
                    objectInfo.PtrTypeInfo      = ptrTypeInfo;
                    objectInfo.ITypeDescription = snapshot.typeDescriptions.TypeInfo2ArrayIndex(objectInfo.PtrTypeInfo);
                    error = objectInfo.ITypeDescription < 0;
                }
                else
                {
                    error = true;
                }
            }
            if (!error)
            {
                objectInfo.Size = SizeOfObjectInBytes(snapshot, objectInfo.ITypeDescription, boHeader, heap);
                objectInfo.data = boHeader;
            }
            else
            {
                if (!ignoreBadHeaderError)
                {
                    var    cursor = boHeader;
                    string str    = "";
                    for (int j = 0; j != 4; ++j)
                    {
                        for (int i = 0; i != 8; ++i)
                        {
                            var b = cursor.bytes[cursor.offset + i];
                            str += string.Format(" {0:X2}", b);
                        }

                        var d = cursor.ReadInt64();
                        str   += string.Format(" : 0x{0:X}, {1}", d, d);
                        str   += "\n";
                        cursor = cursor.Add(8);
                    }
#if DEBUG_VALIDATION
                    var ptrIdentityTypeIndex = snapshot.typeDescriptions.TypeInfo2ArrayIndex(ptrIdentity);

                    UnityEngine.Debug.LogWarning("Unknown object header or type. "
                                                 + " header: \n" + str
                                                 + " First pointer as type index = " + ptrIdentityTypeIndex
                                                 );
#endif
                }

                objectInfo.PtrTypeInfo      = 0;
                objectInfo.ITypeDescription = -1;
                objectInfo.Size             = 0;
            }
            return(objectInfo);
        }
Exemple #7
0
        public static ObjectData[] GetAllObjectConnectingTo(CachedSnapshot snapshot, ObjectData obj)
        {
            var o        = new List <ObjectData>();
            int objIndex = -1;

            switch (obj.dataType)
            {
            case ObjectDataType.Array:
            case ObjectDataType.BoxedValue:
            case ObjectDataType.Object:
            {
                ManagedObjectInfo moi;
                if (snapshot.CrawledData.ManagedObjectByAddress.TryGetValue(obj.hostManagedObjectPtr, out moi))
                {
                    objIndex = snapshot.ManagedObjectIndexToUnifiedObjectIndex(moi.ManagedObjectIndex);

                    //add crawled connections
                    for (int i = 0; i != snapshot.CrawledData.Connections.Count; ++i)
                    {
                        var c = snapshot.CrawledData.Connections[i];
                        switch (c.connectionType)
                        {
                        case ManagedConnection.ConnectionType.Global_To_ManagedObject:
                            if (c.toManagedObjectIndex == moi.ManagedObjectIndex)
                            {
                                o.Add(ObjectData.global);
                            }
                            break;

                        case ManagedConnection.ConnectionType.ManagedObject_To_ManagedObject:
                            if (c.toManagedObjectIndex == moi.ManagedObjectIndex)
                            {
                                var objParent = ObjectData.FromManagedObjectIndex(snapshot, c.fromManagedObjectIndex);
                                if (c.fieldFrom >= 0)
                                {
                                    o.Add(objParent.GetInstanceFieldBySnapshotFieldIndex(snapshot, c.fieldFrom, false));
                                }
                                else if (c.arrayIndexFrom >= 0)
                                {
                                    o.Add(objParent.GetArrayElement(snapshot, c.arrayIndexFrom, false));
                                }
                                else
                                {
                                    o.Add(objParent);
                                }
                            }
                            break;

                        case ManagedConnection.ConnectionType.ManagedType_To_ManagedObject:
                            if (c.toManagedObjectIndex == moi.ManagedObjectIndex)
                            {
                                var objType = ObjectData.FromManagedType(snapshot, c.fromManagedType);
                                if (c.fieldFrom >= 0)
                                {
                                    o.Add(objType.GetInstanceFieldBySnapshotFieldIndex(snapshot, c.fieldFrom, false));
                                }
                                else if (c.arrayIndexFrom >= 0)
                                {
                                    o.Add(objType.GetArrayElement(snapshot, c.arrayIndexFrom, false));
                                }
                                else
                                {
                                    o.Add(objType);
                                }
                            }
                            break;

                        case ManagedConnection.ConnectionType.UnityEngineObject:
                            if (c.UnityEngineManagedObjectIndex == moi.ManagedObjectIndex)
                            {
                                o.Add(ObjectData.FromNativeObjectIndex(snapshot, c.UnityEngineNativeObjectIndex));
                            }
                            break;
                        }
                    }
                }
                break;
            }

            case ObjectDataType.NativeObject:
                objIndex = snapshot.NativeObjectIndexToUnifiedObjectIndex(obj.nativeObjectIndex);

                //add crawled connection
                for (int i = 0; i != snapshot.CrawledData.Connections.Count; ++i)
                {
                    switch (snapshot.CrawledData.Connections[i].connectionType)
                    {
                    case ManagedConnection.ConnectionType.Global_To_ManagedObject:
                    case ManagedConnection.ConnectionType.ManagedObject_To_ManagedObject:
                    case ManagedConnection.ConnectionType.ManagedType_To_ManagedObject:
                        break;

                    case ManagedConnection.ConnectionType.UnityEngineObject:
                        if (snapshot.CrawledData.Connections[i].UnityEngineNativeObjectIndex == obj.nativeObjectIndex)
                        {
                            o.Add(ObjectData.FromManagedObjectIndex(snapshot, snapshot.CrawledData.Connections[i].UnityEngineManagedObjectIndex));
                        }
                        break;
                    }
                }
                break;

            default:
                return(null);
            }
            //add connections from the raw snapshot
            if (objIndex >= 0)
            {
                for (int i = 0; i != snapshot.connections.Count; ++i)
                {
                    if (snapshot.connections.to[i] == objIndex)
                    {
                        o.Add(ObjectData.FromUnifiedObjectIndex(snapshot, snapshot.connections.from[i]));
                    }
                }
            }
            return(o.ToArray());
        }
 public void Clear()
 {
     m_Snapshot = null;
     BaseFormatter.Clear();
 }
Exemple #9
0
        // Returns a new ObjectData pointing to the object's (that this ObjectData is currently pointing at) field
        // using the field index from [0, GetInstanceFieldCount()[
        public ObjectData GetInstanceFieldByIndex(CachedSnapshot snapshot, int i)
        {
            int iField = snapshot.typeDescriptions.fieldIndices_instance[managedTypeIndex][i];

            return(GetInstanceFieldBySnapshotFieldIndex(snapshot, iField, true));
        }
Exemple #10
0
        // Returns a new ObjectData pointing to the object's (that this ObjectData is currently pointing at) field
        // using a field index from snapshot.fieldDescriptions
        public ObjectData GetInstanceFieldBySnapshotFieldIndex(CachedSnapshot snapshot, int iField, bool expandToTarget)
        {
            ObjectData obj;
            ulong      objectPtr;

            switch (m_dataType)
            {
            case ObjectDataType.ReferenceObject:
                objectPtr = GetReferencePointer();
                obj       = FromManagedPointer(snapshot, objectPtr);
                break;

            case ObjectDataType.BoxedValue:
            case ObjectDataType.Object:
            case ObjectDataType.Value:
                objectPtr = m_data.managed.objectPtr;
                obj       = this;
                break;

            //case ObjectDataType.ReferenceArray:
            default:
                //TODO: add proper handling for missing types
                //DebugUtility.LogError("Requesting a field on an invalid data type");
                return(new ObjectData());
            }
            var  fieldOffset = snapshot.fieldDescriptions.offset[iField];
            var  fieldType   = snapshot.fieldDescriptions.typeIndex[iField];
            bool isStatic    = snapshot.fieldDescriptions.isStatic[iField];

            switch (m_dataType)
            {
            case ObjectDataType.Value:
                if (!isStatic)
                {
                    fieldOffset -= snapshot.virtualMachineInformation.objectHeaderSize;
                }
                break;

            case ObjectDataType.Object:
            case ObjectDataType.BoxedValue:
                break;

            case ObjectDataType.Type:
                if (!isStatic)
                {
                    DebugUtility.LogError("Requesting a non-static field on a type");
                    return(invalid);
                }
                break;

            default:
                break;
            }

            ObjectData o = new ObjectData();

            o.m_Parent = new ObjectDataParent(obj, iField, -1, expandToTarget);
            o.SetManagedType(snapshot, fieldType);
            o.m_dataType = TypeToSubDataType(snapshot, fieldType);

            if (isStatic)
            {
                //the field requested might come from a base class. make sure we are using the right staticFieldBytes.
                var iOwningType = obj.m_data.managed.iType;
                while (iOwningType >= 0)
                {
                    var fieldIndex = System.Array.FindIndex(snapshot.typeDescriptions.fieldIndicesOwned_static[iOwningType], x => x == iField);
                    if (fieldIndex >= 0)
                    {
                        //field iField is owned by type iCurrentBase
                        break;
                    }
                    iOwningType = snapshot.typeDescriptions.baseOrElementTypeIndex[iOwningType];
                }
                if (iOwningType < 0)
                {
                    DebugUtility.LogError("Field requested is not owned by the type not any of its bases");
                    return(invalid);
                }

                o.m_data.managed.objectPtr = 0;
                var typeStaticData = new BytesAndOffset(snapshot.typeDescriptions.staticFieldBytes[iOwningType], snapshot.virtualMachineInformation.pointerSize);
                o.managedObjectData = typeStaticData.Add(fieldOffset);
            }
            else
            {
                o.m_data.managed.objectPtr = objectPtr;// m_data.managed.objectPtr;
                o.managedObjectData        = obj.managedObjectData.Add(fieldOffset);
            }
            return(o);
        }
Exemple #11
0
 // Returns the name of the field this ObjectData is pointing at.
 // should be called only when IsField() return true
 public string GetFieldName(CachedSnapshot snapshot)
 {
     return(snapshot.fieldDescriptions.fieldDescriptionName[m_Parent.iField]);
 }
Exemple #12
0
 public ObjectData GetArrayElement(CachedSnapshot snapshot, int index, bool expandToTarget)
 {
     return(GetArrayElement(snapshot, GetArrayInfo(snapshot), index, expandToTarget));
 }
Exemple #13
0
        internal static ObjectData[] GetAllObjectConnectingFrom(CachedSnapshot snapshot, ObjectData obj)
        {
            //TODO
            var o = new List <ObjectData>();

            //int objIndex = -1;
            //switch (obj.dataType)
            //{
            //    case ObjectDataType.Array:
            //    case ObjectDataType.BoxedValue:
            //    case ObjectDataType.Object:
            //        {
            //            ManagedObjectInfo moi;
            //            if (snapshot.m_CrawledData.managedObjectByAddress.TryGetValue(obj.hostManagedObjectPtr, out moi))
            //            {
            //                objIndex = moi.managedObjectIndex;
            //                //add crawled connections
            //                for (int i = 0; i != snapshot.m_CrawledData.connections.Length; ++i)
            //                {
            //                    switch (snapshot.m_CrawledData.connections[i].connectionType)
            //                    {
            //                        case ManagedConnection.ConnectionType.ManagedObject_To_ManagedObject:
            //                            if (snapshot.m_CrawledData.connections[i].fromManagedObjectIndex == objIndex)
            //                            {
            //                                o.Add(ObjectData.FromManagedObjectIndex(snapshot, snapshot.m_CrawledData.connections[i].toManagedObjectIndex));
            //                            }
            //                            break;
            //                        case ManagedConnection.ConnectionType.Global_To_ManagedObject:
            //                        case ManagedConnection.ConnectionType.ManagedType_To_ManagedObject:
            //                            break;

            //                    }
            //                }
            //            }
            //            break;
            //        }
            //    case ObjectDataType.Type:
            //        for (int i = 0; i != snapshot.m_CrawledData.connections.Length; ++i)
            //        {
            //            switch (snapshot.m_CrawledData.connections[i].connectionType)
            //            {
            //                case ManagedConnection.ConnectionType.ManagedType_To_ManagedObject:
            //                    if (snapshot.m_CrawledData.connections[i].fromManagedType == obj.managedTypeIndex)
            //                    {
            //                        o.Add(ObjectData.FromManagedObjectIndex(snapshot, snapshot.m_CrawledData.connections[i].toManagedObjectIndex));
            //                    }
            //                    break;
            //                case ManagedConnection.ConnectionType.Global_To_ManagedObject:
            //                case ManagedConnection.ConnectionType.ManagedObject_To_ManagedObject:
            //                    break;

            //            }
            //        }
            //        break;

            //    case ObjectDataType.NativeObject:
            //        objIndex = obj.nativeObjectIndex;
            //        //for (int i = 0; i != snapshot.m_CrawledData.connections.Length; ++i)
            //        //{
            //        //    if (snapshot.m_CrawledData.connections[i].fromPtr == obj.hostManagedObjectPtr)
            //        //    {
            //        //        o.Add(ObjectData.FromManagedPointer(snapshot, snapshot.m_CrawledData.connections[i].toPtr));
            //        //    }
            //        //}
            //        break;
            //    default:
            //        return null;
            //}
            //if (objIndex >= 0)
            //{
            //    for (int i = 0; i != snapshot.connections.Count; ++i)
            //    {
            //        if (snapshot.connections.from[i] == objIndex)
            //        {
            //            o.Add(ObjectData.FromUnifiedObjectIndex(snapshot, snapshot.connections.to[i]));
            //        }
            //    }
            //}
            return(o.ToArray());
        }
Exemple #14
0
 public void Clear()
 {
     m_Snapshot = null;
     m_BaseRenderer.Clear();
 }
Exemple #15
0
 public SortedNativeMemoryRegionEntriesCache(CachedSnapshot snapshot)
 {
     m_Snapshot = snapshot;
 }
Exemple #16
0
        public ObjectListTable(Database.Schema schema, SnapshotObjectDataFormatter formatter, CachedSnapshot snapshot, ManagedData crawledData, ObjectMetaType metaType)
            : base(schema, metaType)
        {
            Formatter   = formatter;
            Snapshot    = snapshot;
            CrawledData = crawledData;

            var col = new List <Database.Column>();

            switch (metaType)
            {
            case ObjectMetaType.All:
            case ObjectMetaType.Managed:
                col.Add(new ObjectListUnifiedIndexColumn(this));
                col.Add(new ObjectListNameColumn(this));
                col.Add(new ObjectListValueColumn(this));
                col.Add(new ObjectListTypeColumn(this));
                col.Add(new ObjectListObjectTypeColumn(this));
                col.Add(new ObjectListNativeObjectNameLinkColumn(this));
                col.Add(new ObjectListLengthColumn(this));
                col.Add(new ObjectListStaticColumn(this));
                col.Add(new ObjectListRefCountColumn(this));
                col.Add(new ObjectListOwnedSizeColumn(this));
                col.Add(new ObjectListTargetSizeColumn(this));
                col.Add(new ObjectListNativeObjectSizeColumn(this));
                col.Add(new ObjectListNativeInstanceIdLinkColumn(this));
                col.Add(new ObjectListAddressColumn(this));
                col.Add(new ObjectListUniqueStringColumn(this));
                break;

            case ObjectMetaType.Native:
                col.Add(new ObjectListUnifiedIndexColumn(this));
                col.Add(new ObjectListNameColumn(this));
                col.Add(new ObjectListValueColumn(this));
                col.Add(new ObjectListTypeColumn(this));
                col.Add(new ObjectListNativeObjectNameColumn(this));
                col.Add(new ObjectListObjectTypeColumn(this));
                col.Add(new ObjectListRefCountColumn(this));
                col.Add(new ObjectListOwnedSizeColumn(this));
                col.Add(new ObjectListTargetSizeColumn(this));
                col.Add(new ObjectListNativeInstanceIdColumn(this));
                col.Add(new ObjectListAddressColumn(this));
                col.Add(new ObjectListUniqueStringColumn(this));
                break;
            }

            InitExpandColumn(col);
        }
Exemple #17
0
 public SortedManagedObjectsCache(CachedSnapshot snapshot)
 {
     m_Snapshot = snapshot;
 }
Exemple #18
0
 public void Clear()
 {
     m_Snapshot = null;
     renderer.Clear();
 }
Exemple #19
0
 public SortedNativeAllocationsCache(CachedSnapshot snapshot)
 {
     m_Snapshot = snapshot;
 }
Exemple #20
0
        public static IEnumerator Crawl(CachedSnapshot snapshot)
        {
            const int stepCount = 5;
            var       status    = new EnumerationUtilities.EnumerationStatus(stepCount);

            IntermediateCrawlData crawlData = new IntermediateCrawlData(snapshot);

            crawlData.ManagedObjectInfos.Capacity = (int)snapshot.gcHandles.Count * 3;
            crawlData.ManagedConnections.Capacity = (int)snapshot.gcHandles.Count * 6;

            //Gather handles and duplicates
            status.StepStatus = "Gathering snapshot managed data.";
            yield return(status);

            GatherIntermediateCrawlData(snapshot, crawlData);

            //crawl handle data
            status.IncrementStep();
            status.StepStatus = "Crawling GC handles.";
            yield return(status);

            while (crawlData.CrawlDataStack.Count > 0)
            {
                CrawlPointer(crawlData);
            }

            //crawl data pertaining to types with static fields and enqueue any heap objects
            status.IncrementStep();
            status.StepStatus = "Crawling data types with static fields";
            yield return(status);

            for (int i = 0; i < crawlData.TypesWithStaticFields.Count; i++)
            {
                var iTypeDescription = crawlData.TypesWithStaticFields[i];
                var bytesOffset      = new BytesAndOffset {
                    bytes = snapshot.typeDescriptions.staticFieldBytes[iTypeDescription], offset = 0, pointerSize = snapshot.virtualMachineInformation.pointerSize
                };
                CrawlRawObjectData(crawlData, bytesOffset, iTypeDescription, true, 0, -1);
            }

            //crawl handles belonging to static instances
            status.IncrementStep();
            status.StepStatus = "Crawling static instances heap data.";
            yield return(status);

            while (crawlData.CrawlDataStack.Count > 0)
            {
                CrawlPointer(crawlData);
            }

            //copy crawled object source data for duplicate objects
            foreach (var i in crawlData.DuplicatedGCHandlesStack)
            {
                var ptr = snapshot.CrawledData.ManagedObjects[i].PtrObject;
                snapshot.CrawledData.ManagedObjects[i] = snapshot.CrawledData.ManagedObjectByAddress[ptr];
            }

            //crawl connection data
            status.IncrementStep();
            status.StepStatus = "Crawling connection data";
            yield return(status);

            ConnectNativeToManageObject(crawlData);
            AddupRawRefCount(crawlData.CachedMemorySnapshot);
        }
Exemple #21
0
 public SortedNativeObjectsCache(CachedSnapshot snapshot)
 {
     m_Snapshot = snapshot;
 }
Exemple #22
0
        public ObjectFieldTable(Schema schema, SnapshotObjectDataFormatter formatter, CachedSnapshot snapshot, ManagedData crawledData, ObjectData obj, ObjectMetaType metaType)
            : base(schema, formatter, snapshot, crawledData, metaType)
        {
            this.obj = obj;
            objBase  = obj.GetBase(snapshot);

            SetFieldsList(BuildFieldList());
            InitObjectList();
        }
 private void SetManagedType(CachedSnapshot snapshot, int iType)
 {
     m_data.managed.iType = iType;
 }