public string Format(ObjectData od, IDataFormatter formatter, bool objectBrief = true)
        {
            switch (od.dataType)
            {
            case ObjectDataType.BoxedValue:
                return(FormatValueType(od.GetBoxedValue(m_Snapshot, true), formatter, objectBrief));

            case ObjectDataType.Value:
                return(FormatValueType(od, formatter, objectBrief));

            case ObjectDataType.Object:
                return(FormatObject(od, formatter, objectBrief));

            case ObjectDataType.Array:
                return(FormatArray(od, formatter));

            case ObjectDataType.ReferenceObject:
            {
                ulong ptr = od.GetReferencePointer();
                if (ptr == 0)
                {
                    return(FormatPointer(ptr));
                }
                else
                {
                    var o = ObjectData.FromManagedPointer(m_Snapshot, ptr);
                    return(FormatObject(o, formatter, objectBrief));
                }
            }

            case ObjectDataType.ReferenceArray:
            {
                ulong ptr = od.GetReferencePointer();
                if (ptr == 0)
                {
                    return(FormatPointer(ptr));
                }
                var arr = ObjectData.FromManagedPointer(m_Snapshot, ptr);
                return(FormatArray(arr, formatter));
            }

            case ObjectDataType.Type:
                return(m_Snapshot.typeDescriptions.typeDescriptionName[od.managedTypeIndex]);

            case ObjectDataType.Global:
                return("<global>");

            case ObjectDataType.NativeObject:
                return(FormatPointer(m_Snapshot.nativeObjects.nativeObjectAddress[od.nativeObjectIndex]));

            default:
                return("<uninitialized type>");
            }
        }
Example #2
0
        protected ManagedObjectInfo GetInfo(ObjectData obj)
        {
            int idx = 0;

            switch (obj.dataType)
            {
            case ObjectDataType.Object:
                m_Table.CrawledData.MangedObjectIndexByAddress.TryGetValue(obj.hostManagedObjectPtr, out idx);
                return(m_Table.CrawledData.ManagedObjects[idx]);

            case ObjectDataType.ReferenceObject:
            {
                var ptr = obj.GetReferencePointer();
                if (ptr == 0)
                {
                    return(default(ManagedObjectInfo));
                }
                m_Table.CrawledData.MangedObjectIndexByAddress.TryGetValue(ptr, out idx);
                return(m_Table.CrawledData.ManagedObjects[idx]);
            }

            default:
                return(default(ManagedObjectInfo));
            }
        }
Example #3
0
        public bool IsGroupExpandable(ObjectData od, bool forceExpandAllObject = false)
        {
            switch (od.dataType)
            {
            case ObjectDataType.Array:
            {
                var l = ArrayTools.ReadArrayLength(Snapshot, od.hostManagedObjectPtr, od.managedTypeIndex);
                return(l > 0 || forceExpandAllObject);
            }

            case ObjectDataType.ReferenceArray:
            {
                var ptr = od.GetReferencePointer();
                if (ptr != 0)
                {
                    var arr = ObjectData.FromManagedPointer(Snapshot, ptr);
                    var l   = ArrayTools.ReadArrayLength(Snapshot, arr.hostManagedObjectPtr, arr.managedTypeIndex);
                    return(l > 0 || forceExpandAllObject);
                }
                return(false);
            }

            case ObjectDataType.ReferenceObject:
            {
                ulong ptr = od.GetReferencePointer();
                if (ptr == 0)
                {
                    return(false);
                }
                var obj = ObjectData.FromManagedPointer(Snapshot, ptr);
                if (!obj.IsValid)
                {
                    return(false);
                }
                if (forceExpandAllObject)
                {
                    return(true);
                }
                if (!Formatter.IsExpandable(obj.managedTypeIndex))
                {
                    return(false);
                }
                return(Snapshot.typeDescriptions.HasAnyField(obj.managedTypeIndex));
            }

            case ObjectDataType.BoxedValue:
            case ObjectDataType.Object:
            case ObjectDataType.Value:
                if (forceExpandAllObject)
                {
                    return(true);
                }
                if (!Formatter.IsExpandable(od.managedTypeIndex))
                {
                    return(false);
                }
                return(Snapshot.typeDescriptions.HasAnyField(od.managedTypeIndex));

            case ObjectDataType.Type:
                if (!Formatter.IsExpandable(od.managedTypeIndex))
                {
                    return(false);
                }
                if (Formatter.flattenFields)
                {
                    return(Snapshot.typeDescriptions.HasAnyStaticField(od.managedTypeIndex));
                }
                else
                {
                    return(Snapshot.typeDescriptions.HasStaticField(od.managedTypeIndex));
                }

            default:
                return(false);
            }
        }