//leakcanary/shark/HeapObject/HeapClass
HeapClass¶
class HeapClass : HeapObject
A class in the heap dump.
Functions¶
| Name | Summary |
|---|---|
| get | operator fun get(fieldName: String): HeapField? |
| instanceFieldName | fun instanceFieldName(fieldRecord: HprofRecord.HeapDumpRecord.ObjectRecord.ClassDumpRecord.FieldRecord): String Returns the name of the field declared in this class for the specified fieldRecord. |
| readFieldsByteSize | fun readFieldsByteSize(): Int The total byte size of fields for instances of this class, computed as the sum of the individual size of each field of this class. This does not include the size of fields from superclasses. |
| readRecord | open override fun readRecord(): HprofRecord.HeapDumpRecord.ObjectRecord.ClassDumpRecord Reads and returns the underlying ClassDumpRecord. |
| readRecordFields | fun readRecordFields(): List<HprofRecord.HeapDumpRecord.ObjectRecord.ClassDumpRecord.FieldRecord> |
| readRecordStaticFields | fun readRecordStaticFields(): List<HprofRecord.HeapDumpRecord.ObjectRecord.ClassDumpRecord.StaticFieldRecord> |
| readStaticField | fun readStaticField(fieldName: String): HeapField? Returns a HeapField object that reflects the specified declared field of the class represented by this HeapClass object, or null if this field does not exist. The name parameter specifies the simple name of the desired field. |
| readStaticFields | fun readStaticFields(): Sequence<HeapField> The static fields of this class, as a sequence of HeapField. |
| subclassOf | infix fun subclassOf(superclass: HeapObject.HeapClass): Boolean Returns true if superclass is a superclass of this HeapClass. |
| superclassOf | infix fun superclassOf(subclass: HeapObject.HeapClass): Boolean Returns true if subclass is a sub class of this HeapClass. |
| toString | open override fun toString(): String |
Properties¶
| Name | Summary |
|---|---|
| asClass | val asClass: HeapObject.HeapClass? This HeapObject as a HeapClass if it is one, or null otherwise |
| asInstance | val asInstance: HeapObject.HeapInstance? This HeapObject as a HeapInstance if it is one, or null otherwise |
| asObjectArray | val asObjectArray: HeapObject.HeapObjectArray? This HeapObject as a HeapObjectArray if it is one, or null otherwise |
| asPrimitiveArray | val asPrimitiveArray: HeapObject.HeapPrimitiveArray? This HeapObject as a HeapPrimitiveArray if it is one, or null otherwise |
| classHierarchy | val classHierarchy: Sequence<HeapObject.HeapClass> The class hierarchy starting at this class (included) and ending at the Object class (included). |
| directInstances | val directInstances: Sequence<HeapObject.HeapInstance> All direct instances of this class, ie excluding any instance of subclasses of this class. |
| graph | open override val graph: HeapGraph The graph of objects in the heap, which you can use to navigate the heap. |
| hasReferenceInstanceFields | val hasReferenceInstanceFields: Boolean |
| instanceByteSize | val instanceByteSize: Int The total byte size of fields for instances of this class, as registered in the class dump. This includes the size of fields from superclasses. |
| instances | val instances: Sequence<HeapObject.HeapInstance> All instances of this class, including instances of subclasses of this class. |
| isArrayClass | val isArrayClass: Boolean Returns true if this class is an array class, and false otherwise. |
| isObjectArrayClass | val isObjectArrayClass: Boolean |
| isPrimitiveArrayClass | val isPrimitiveArrayClass: Boolean |
| isPrimitiveWrapperClass | val isPrimitiveWrapperClass: Boolean Whether this is class is a primitive wrapper type |
| name | val name: String The name of this class, identical to Class.getName. If this class is an array class, the name has a suffix of brackets for each dimension of the array, e.g. com.Foo[][] is a class for 2 dimensional arrays of com.Foo. |
| objectArrayInstances | val objectArrayInstances: Sequence<HeapObject.HeapObjectArray> |
| objectId | open override val objectId: Long The heap identifier of this object. |
| objectIndex | open override val objectIndex: Int An positive object index that’s specific to how Shark stores objects in memory. The index starts at 0 and ends at HeapGraph.objectCount - 1. There are no gaps, every index value corresponds to an object. Classes are first, then instances, then object arrays then primitive arrays. |
| positiveObjectId | val positiveObjectId: Long objectId masked to be a positive unique identifier, as reported in Android Studio. |
| primitiveArrayInstances | val primitiveArrayInstances: Sequence<HeapObject.HeapPrimitiveArray> Primitive arrays are one dimensional arrays of a primitive type. N-dimension arrays of primitive types (e.g. int[][]) are object arrays pointing to primitive arrays. |
| recordSize | open override val recordSize: Int The total byte size for the record of this object in the heap dump. |
| simpleName | val simpleName: String Returns name stripped of any string content before the last period (included). |
| subclasses | val subclasses: Sequence<HeapObject.HeapClass> All the subclasses (direct and indirect) of this class, in the order they were recorded in the heap dump. |
| superclass | val superclass: HeapObject.HeapClass? The HeapClass representing the superclass of this HeapClass. If this HeapClass represents either the Object class or a primitive type, then null is returned. If this HeapClass represents an array class then the HeapClass object representing the Object class is returned. |