ElementInfo

java.lang.Object
- gov.nasa.jpf.vm.ElementInfo

All Implemented Interfaces:

java.lang.Cloneable

Direct Known Subclasses:

DynamicElementInfo, StaticElementInfo
```
public abstract class ElementInfo
extends java.lang.Object
implements java.lang.Cloneable
```
Describes an element of memory containing the field values of a class or an object. In the case of a class, contains the values of the static fields. For an object contains the values of the object fields.

See Also:

FieldInfo

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ATTR_ATTRIBUTE_CHANGED`
`static int`	`ATTR_CONSTRUCTED`
`static int`	`ATTR_EXPOSED`
`static int`	`ATTR_FINALIZED`
`static int`	`ATTR_FLI_CHANGED`
`static int`	`ATTR_FREEZE_SHARED`
`static int`	`ATTR_IMMUTABLE`
`static int`	`ATTR_IS_FROZEN`
`static int`	`ATTR_IS_MARKED`
`static int`	`ATTR_LIVE_BIT`
`static int`	`ATTR_MARKED_OR_LIVE_BIT`
`static int`	`ATTR_PINDOWN_MASK`
`static int`	`ATTR_SHARED`
`static int`	`ATTR_TREF_CHANGED`
`protected int`	`attributes`
`protected Memento<ElementInfo>`	`cachedMemento`
`protected ClassInfo`	`ci`
`protected Fields`	`fields`
`protected FieldLockInfo[]`	`fLockInfo`
`protected Monitor`	`monitor`
`protected int`	`objRef`
`protected ThreadInfoSet`	`referencingThreads`
`protected int`	`sid`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`ElementInfo()`
`protected`	`ElementInfo(int id, ClassInfo c, Fields f, Monitor m, ThreadInfo ti)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addElementAttr(int idx, java.lang.Object a)`
`void`	`addElementAttrNoClone(int idx, java.lang.Object a)` <2do> those will be obsolete
`void`	`addFieldAttr(FieldInfo fi, java.lang.Object a)`
`void`	`addObjectAttr(java.lang.Object a)`
`void`	`arrayCopy(ElementInfo src, int srcPos, int dstPos, int len)` NOTE - this doesn't support element type checks or overlapping in-array copy
`int`	`arrayLength()`
`boolean[]`	`asBooleanArray()`
`java.lang.Object`	`asBoxObject()`
`byte[]`	`asByteArray()`
`char[]`	`asCharArray()`
`double[]`	`asDoubleArray()`
`float[]`	`asFloatArray()`
`int[]`	`asIntArray()`
`long[]`	`asLongArray()`
`int[]`	`asReferenceArray()`
`short[]`	`asShortArray()`
`java.lang.String`	`asString()`
`void`	`block(ThreadInfo ti)` from a MONITOR_ENTER or sync INVOKExx if we cannot acquire the lock note: this is not called from a NOTIFIED_UNBLOCKED state, so we don't have to restore NOTIFIED
`boolean`	`canLock(ThreadInfo th)`
`protected void`	`checkArray(int index)`
`void`	`checkArrayBounds(int index)`
`protected void`	`checkAssertion(boolean cond, java.lang.String failMsg)`
`void`	`checkConsistency()`
`protected void`	`checkIsModifiable()`
`ElementInfo`	`clone()`
`void`	`copyElements(ThreadInfo ti, ElementInfo eiSrc, int srcIdx, int dstIdx, int length)` this is the backend for System.arraycopy implementations, but since it only throws general exceptions it can also be used in other contexts that require type and objRef checking note that we have to do some additional type checking here because we store reference arrays as int[], i.e.
`ElementInfo`	`deepClone()`
`void`	`defreeze()`
`ObjectList.Iterator`	`elementAttrIterator(int idx)`
`<T> ObjectList.TypedIterator<T>`	`elementAttrIterator(int idx, java.lang.Class<T> type)`
`boolean`	`equals(java.lang.Object o)`
`boolean`	`equalsString(java.lang.String s)` just a helper to avoid creating objects just for the sake of comparing
`ObjectList.Iterator`	`fieldAttrIterator(FieldInfo fi)`
`<T> ObjectList.TypedIterator<T>`	`fieldAttrIterator(FieldInfo fi, java.lang.Class<T> type)`
`void`	`freeze()`
`void`	`freezeSharedness(boolean freeze)`
`int`	`get1SlotField(FieldInfo fi)`
`long`	`get2SlotField(FieldInfo fi)`
`ArrayFields`	`getArrayFields()`
`java.lang.String`	`getArrayType()`
`java.lang.Object`	`getBacktrackData()`
`ThreadInfo[]`	`getBlockedOrWaitingThreads()`
`ThreadInfo[]`	`getBlockedThreads()`
`boolean`	`getBooleanElement(int idx)`
`boolean`	`getBooleanField(FieldInfo fi)`
`boolean`	`getBooleanField(java.lang.String fname)`
`byte`	`getByteElement(int idx)`
`byte`	`getByteField(FieldInfo fi)`
`byte`	`getByteField(java.lang.String fname)`
`Memento<ElementInfo>`	`getCachedMemento()`
`char`	`getCharElement(int idx)`
`char`	`getCharField(FieldInfo fi)`
`char`	`getCharField(java.lang.String fname)`
`ClassInfo`	`getClassInfo()`
`boolean`	`getDeclaredBooleanField(java.lang.String fname, java.lang.String refType)`
`byte`	`getDeclaredByteField(java.lang.String fname, java.lang.String refType)`
`char`	`getDeclaredCharField(java.lang.String fname, java.lang.String refType)`
`double`	`getDeclaredDoubleField(java.lang.String fname, java.lang.String refType)`
`protected abstract FieldInfo`	`getDeclaredFieldInfo(java.lang.String clsBase, java.lang.String fname)`
`float`	`getDeclaredFloatField(java.lang.String fname, java.lang.String refType)`
`int`	`getDeclaredIntField(java.lang.String fname, java.lang.String clsBase)`
`long`	`getDeclaredLongField(java.lang.String fname, java.lang.String clsBase)`
`ElementInfo`	`getDeclaredObjectField(java.lang.String fname, java.lang.String referenceType)`
`int`	`getDeclaredReferenceField(java.lang.String fname, java.lang.String clsBase)`
`short`	`getDeclaredShortField(java.lang.String fname, java.lang.String refType)`
`double`	`getDoubleElement(int idx)`
`double`	`getDoubleField(FieldInfo fi)`
`double`	`getDoubleField(java.lang.String fname)`
`java.lang.Object`	`getElementAttr(int idx)` this returns all of them - use either if you know there will be only one attribute at a time, or check/process result with ObjectList
`<T> T`	`getElementAttr(int idx, java.lang.Class<T> attrType)` this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general
`ElementInfo`	`getEnclosingElementInfo()`
`ElementInfo`	`getExposedInstance(ThreadInfo ti, ElementInfo eiFieldOwner)`
`java.lang.Object`	`getFieldAttr(FieldInfo fi)` this returns all of them - use either if you know there will be only one attribute at a time, or check/process result with ObjectList
`<T> T`	`getFieldAttr(FieldInfo fi, java.lang.Class<T> attrType)` this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general
`abstract FieldInfo`	`getFieldInfo(int fieldIndex)`
`protected abstract FieldInfo`	`getFieldInfo(java.lang.String fname)`
`FieldLockInfo`	`getFieldLockInfo(FieldInfo fi)`
`Fields`	`getFields()` BEWARE - never change the returned object without knowing about the ElementInfo change status, this field is state managed!
`java.lang.Object`	`getFieldValueObject(java.lang.String fname)`
`float`	`getFloatElement(int idx)`
`float`	`getFloatField(FieldInfo fi)`
`float`	`getFloatField(java.lang.String fname)`
`int`	`getHeapSize()` answer an estimate of the heap size in bytes (this is of course VM dependent, but we can give an upper bound for the fields/elements, and that should be good in terms of application specific properties)
`int`	`getIndex()` Deprecated.
`int`	`getIntElement(int idx)`
`int`	`getIntField(FieldInfo fi)`
`int`	`getIntField(java.lang.String fname)`
`int`	`getLockCount()`
`ThreadInfo[]`	`getLockedThreads()` return all threads that are trying to acquire this lock (blocked, waiting, interrupted) NOTE - this is not a copy, don't modify the array
`ThreadInfo`	`getLockingThread()`
`long`	`getLongElement(int idx)`
`long`	`getLongField(FieldInfo fi)`
`long`	`getLongField(java.lang.String fname)`
`abstract ElementInfo`	`getModifiableInstance()`
`Monitor`	`getMonitor()` BEWARE - never change the returned object without knowing about the ElementInfo change status, this field is state managed!
`<T> T`	`getNextElementAttr(int idx, java.lang.Class<T> attrType, java.lang.Object prev)`
`<T> T`	`getNextFieldAttr(FieldInfo fi, java.lang.Class<T> attrType, java.lang.Object prev)`
`<T> T`	`getNextObjectAttr(java.lang.Class<T> attrType, java.lang.Object prev)`
`abstract int`	`getNumberOfFields()`
`protected abstract int`	`getNumberOfFieldsOrElements()`
`java.lang.Object`	`getObjectAttr()` this returns all of them - use either if you know there will be only one attribute at a time, or check/process result with ObjectList
`<T> T`	`getObjectAttr(java.lang.Class<T> attrType)` this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general
`ElementInfo`	`getObjectField(java.lang.String fname)`
`int`	`getObjectRef()`
`int`	`getPinDownCount()`
`int`	`getReferenceElement(int idx)`
`int`	`getReferenceField(FieldInfo fi)`
`int`	`getReferenceField(java.lang.String fname)`
`ThreadInfoSet`	`getReferencingThreads()`
`short`	`getShortElement(int idx)`
`short`	`getShortField(FieldInfo fi)`
`short`	`getShortField(java.lang.String fname)`
`int`	`getSid()`
`char[]`	`getStringChars()`
`java.lang.String`	`getStringField(java.lang.String fname)`
`java.lang.String`	`getType()`
`ThreadInfo[]`	`getWaitingThreads()` get a cloned list of the waiters for this object
`boolean`	`hasChanged()`
`boolean`	`hasElementAttr()`
`boolean`	`hasElementAttr(java.lang.Class<?> attrType)`
`boolean`	`hasFieldAttr()`
`boolean`	`hasFieldAttr(java.lang.Class<?> attrType)`
`abstract boolean`	`hasFinalizer()`
`void`	`hash(HashData hd)`
`int`	`hashCode()`
`boolean`	`hasObjectAttr()`
`boolean`	`hasObjectAttr(java.lang.Class<?> attrType)`
`boolean`	`hasRefField(int objRef)` do we have a reference field with value objRef?
`boolean`	`hasWaitingThreads()`
`boolean`	`instanceOf(java.lang.String type)`
`boolean`	`isAlive(boolean liveBitValue)`
`boolean`	`isArray()`
`boolean`	`isBoxObject()` is this a Number, a Boolean or a Character object Note these classes are all final, so we don't have to check for subtypes <2do> we should probably use a regular expression here
`boolean`	`isCharArray()`
`boolean`	`isConstructed()`
`boolean`	`isDoubleArray()`
`boolean`	`isExposed()`
`boolean`	`isExposedOrShared()`
`boolean`	`isFinalized()`
`boolean`	`isFloatArray()`
`boolean`	`isFrozen()`
`boolean`	`isImmutable()`
`boolean`	`isLocked()`
`boolean`	`isLockedBy(ThreadInfo ti)`
`boolean`	`isLocking(ThreadInfo ti)`
`boolean`	`isLockProtected(FieldInfo fi)`
`boolean`	`isMarked()`
`boolean`	`isMarkedOrAlive(boolean liveBitValue)`
`boolean`	`isNull()`
`abstract boolean`	`isObject()`
`boolean`	`isPinnedDown()`
`boolean`	`isReferenceArray()`
`boolean`	`isReferencedBySameThreads(ElementInfo eiOther)`
`boolean`	`isReferencedByThread(ThreadInfo ti)`
`boolean`	`isRegisteredLockContender(ThreadInfo ti)`
`boolean`	`isShared()`
`boolean`	`isSharednessFrozen()`
`boolean`	`isStringObject()`
`void`	`lock(ThreadInfo ti)` from a MONITOR_ENTER or sync INVOKExx if we can acquire the lock
`void`	`lockNotified(ThreadInfo ti)` re-acquire lock after being notified.
`void`	`markUnchanged()`
`boolean`	`notifies(SystemState ss, ThreadInfo ti)` notifies one of the waiters.
`boolean`	`notifies(SystemState ss, ThreadInfo ti, boolean hasToHoldLock)` return true if this did notify any waiters
`boolean`	`notifiesAll()` notify all waiters.
`int`	`numberOfUserThreads()`
`ObjectList.Iterator`	`objectAttrIterator()`
`<T> ObjectList.TypedIterator<T>`	`objectAttrIterator(java.lang.Class<T> type)`
`void`	`processReleaseActions()` object is recycled (after potential finalization)
`protected boolean`	`recycle()` this is called before the system attempts to reclaim the object.
`void`	`registerLockContender(ThreadInfo ti)` threads that will grab our lock on their next execution have to be registered, so that they can be blocked in case somebody else gets scheduled
`void`	`removeElementAttr(int idx, java.lang.Object a)`
`void`	`removeElementAttrNoClone(int idx, java.lang.Object a)`
`void`	`removeFieldAttr(FieldInfo fi, java.lang.Object a)`
`void`	`removeObjectAttr(java.lang.Object a)`
`void`	`replaceElementAttr(int idx, java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`replaceElementAttrNoClone(int idx, java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`replaceFieldAttr(FieldInfo fi, java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`replaceObjectAttr(java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`restore(int index, int attributes, Fields fields, Monitor monitor)`
`void`	`restoreAttributes(int a)`
`void`	`restoreFields(Fields f)`
`void`	`restoreMonitor(Monitor m)`
`void`	`resumeNonlockedWaiter(ThreadInfo ti)` this is for waiters that did not own the lock
`void`	`set1SlotField(FieldInfo fi, int newValue)`
`void`	`set2SlotField(FieldInfo fi, long newValue)`
`void`	`setAlive(boolean liveBitValue)`
`void`	`setBooleanElement(int idx, boolean value)`
`void`	`setBooleanField(FieldInfo fi, boolean newValue)`
`void`	`setBooleanField(java.lang.String fname, boolean value)`
`void`	`setByteElement(int idx, byte value)`
`void`	`setByteField(FieldInfo fi, byte newValue)`
`void`	`setByteField(java.lang.String fname, byte value)`
`void`	`setCachedMemento(Memento<ElementInfo> memento)`
`void`	`setCharElement(int idx, char value)`
`void`	`setCharField(FieldInfo fi, char newValue)`
`void`	`setCharField(java.lang.String fname, char value)`
`void`	`setConstructed()`
`void`	`setDeclaredIntField(java.lang.String fname, java.lang.String clsBase, int value)`
`void`	`setDeclaredLongField(java.lang.String fname, java.lang.String clsBase, long value)`
`void`	`setDeclaredReferenceField(java.lang.String fname, java.lang.String clsBase, int value)`
`void`	`setDoubleElement(int idx, double value)`
`void`	`setDoubleField(FieldInfo fi, double newValue)`
`void`	`setDoubleField(java.lang.String fname, double value)`
`void`	`setElementAttr(int idx, java.lang.Object attr)` this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()
`void`	`setElementAttrNoClone(int idx, java.lang.Object attr)` this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()
`protected void`	`setExposed()`
`void`	`setExposed(ThreadInfo ti, ElementInfo eiFieldOwner)`
`void`	`setFieldAttr(FieldInfo fi, java.lang.Object attr)` this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()
`void`	`setFieldLockInfo(FieldInfo fi, FieldLockInfo flInfo)`
`void`	`setFinalized()`
`void`	`setFloatElement(int idx, float value)`
`void`	`setFloatField(FieldInfo fi, float newValue)`
`void`	`setFloatField(java.lang.String fname, float value)`
`void`	`setIntElement(int idx, int value)`
`void`	`setIntField(FieldInfo fi, int newValue)`
`void`	`setIntField(java.lang.String fname, int value)`
`void`	`setLongElement(int idx, long value)`
`void`	`setLongField(FieldInfo fi, long newValue)`
`void`	`setLongField(java.lang.String fname, long value)`
`void`	`setMarked()`
`void`	`setObjectAttr(java.lang.Object a)` this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()
`void`	`setObjectAttrNoClone(java.lang.Object a)` this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()
`void`	`setObjectRef(int newObjRef)`
`void`	`setReferenceElement(int idx, int value)`
`void`	`setReferenceField(FieldInfo fi, int newValue)`
`void`	`setReferenceField(java.lang.String fname, int value)`
`void`	`setReferencingThreads(ThreadInfoSet refThreads)` set the referencing threads.
`void`	`setShared(ThreadInfo ti, boolean isShared)`
`void`	`setShortElement(int idx, short value)`
`void`	`setShortField(FieldInfo fi, short newValue)`
`void`	`setShortField(java.lang.String fname, short value)`
`void`	`setSid(int id)`
`void`	`setUnmarked()`
`java.lang.String`	`toString()`
`boolean`	`unlock(ThreadInfo ti)` from a MONITOR_EXIT or sync method RETURN release a possibly recursive lock if lockCount goes to zero return true if this unblocked any waiters
`void`	`unregisterLockContender(ThreadInfo ti)` somebody made up his mind and decided not to enter a synchronized section of code it had registered before (e.g.
`void`	`wait(ThreadInfo ti, long timeout)` wait to be notified.
`void`	`wait(ThreadInfo ti, long timeout, boolean hasToHoldLock)`

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

ATTR_PINDOWN_MASK
```
public static final int ATTR_PINDOWN_MASK
```
See Also:

Constant Field Values

ATTR_IS_FROZEN
```
public static final int ATTR_IS_FROZEN
```
See Also:

Constant Field Values

ATTR_IMMUTABLE
```
public static final int ATTR_IMMUTABLE
```
See Also:

Constant Field Values

ATTR_CONSTRUCTED
```
public static final int ATTR_CONSTRUCTED
```
See Also:

Constant Field Values

ATTR_FINALIZED
```
public static final int ATTR_FINALIZED
```
See Also:

Constant Field Values

ATTR_EXPOSED
```
public static final int ATTR_EXPOSED
```
See Also:

Constant Field Values

ATTR_SHARED
```
public static final int ATTR_SHARED
```
See Also:

Constant Field Values

ATTR_FREEZE_SHARED
```
public static final int ATTR_FREEZE_SHARED
```
See Also:

Constant Field Values

ATTR_TREF_CHANGED
```
public static final int ATTR_TREF_CHANGED
```
See Also:

Constant Field Values

ATTR_FLI_CHANGED
```
public static final int ATTR_FLI_CHANGED
```
See Also:

Constant Field Values

ATTR_ATTRIBUTE_CHANGED
```
public static final int ATTR_ATTRIBUTE_CHANGED
```
See Also:

Constant Field Values

ATTR_IS_MARKED
```
public static final int ATTR_IS_MARKED
```
See Also:

Constant Field Values

ATTR_LIVE_BIT
```
public static final int ATTR_LIVE_BIT
```
See Also:

Constant Field Values

ATTR_MARKED_OR_LIVE_BIT
```
public static final int ATTR_MARKED_OR_LIVE_BIT
```
See Also:

Constant Field Values

ci
```
protected ClassInfo ci
```

fields
```
protected Fields fields
```

monitor
```
protected Monitor monitor
```

referencingThreads

protected ThreadInfoSet referencingThreads

fLockInfo
```
protected FieldLockInfo[] fLockInfo
```

objRef
```
protected int objRef
```

attributes
```
protected int attributes
```

cachedMemento

protected Memento<ElementInfo> cachedMemento

sid
```
protected int sid
```

Constructor Detail

ElementInfo

protected ElementInfo(int id,
                      ClassInfo c,
                      Fields f,
                      Monitor m,
                      ThreadInfo ti)

ElementInfo
```
protected ElementInfo()
```

Method Detail

getModifiableInstance

public abstract ElementInfo getModifiableInstance()

isObject
```
public abstract boolean isObject()
```

hasFinalizer

public abstract boolean hasFinalizer()

hasChanged
```
public boolean hasChanged()
```

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

getFieldLockInfo

public FieldLockInfo getFieldLockInfo(FieldInfo fi)

setFieldLockInfo

public void setFieldLockInfo(FieldInfo fi,
                             FieldLockInfo flInfo)

isLockProtected

public boolean isLockProtected(FieldInfo fi)

processReleaseActions
```
public void processReleaseActions()
```
object is recycled (after potential finalization)

setSid
```
public void setSid(int id)
```

getSid
```
public int getSid()
```

getCachedMemento

public Memento<ElementInfo> getCachedMemento()

setCachedMemento

public void setCachedMemento(Memento<ElementInfo> memento)

hasRefField
```
public boolean hasRefField(int objRef)
```
do we have a reference field with value objRef?

numberOfUserThreads
```
public int numberOfUserThreads()
```

isImmutable
```
public boolean isImmutable()
```

freeze
```
public void freeze()
```

defreeze
```
public void defreeze()
```

isFrozen
```
public boolean isFrozen()
```

setReferencingThreads
```
public void setReferencingThreads(ThreadInfoSet refThreads)
```
set the referencing threads. Unless you know this is from a non-shared context, make sure to update sharedness by calling setShared()

getReferencingThreads

public ThreadInfoSet getReferencingThreads()

freezeSharedness

public void freezeSharedness(boolean freeze)

isSharednessFrozen
```
public boolean isSharednessFrozen()
```

isShared
```
public boolean isShared()
```

setShared

public void setShared(ThreadInfo ti,
                      boolean isShared)

isReferencedBySameThreads

public boolean isReferencedBySameThreads(ElementInfo eiOther)

isReferencedByThread

public boolean isReferencedByThread(ThreadInfo ti)

isExposed
```
public boolean isExposed()
```

isExposedOrShared
```
public boolean isExposedOrShared()
```

getExposedInstance

public ElementInfo getExposedInstance(ThreadInfo ti,
                                      ElementInfo eiFieldOwner)

setExposed
```
protected void setExposed()
```

setExposed

public void setExposed(ThreadInfo ti,
                       ElementInfo eiFieldOwner)

recycle
```
protected boolean recycle()
```
this is called before the system attempts to reclaim the object. If we return 'false', the object will *not* be removed

hash
```
public void hash(HashData hd)
```

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class java.lang.Object

equals
```
public boolean equals(java.lang.Object o)
```
Overrides:

equals in class java.lang.Object

getClassInfo
```
public ClassInfo getClassInfo()
```

getDeclaredFieldInfo

protected abstract FieldInfo getDeclaredFieldInfo(java.lang.String clsBase,
                                                  java.lang.String fname)

getFieldInfo

protected abstract FieldInfo getFieldInfo(java.lang.String fname)

getNumberOfFieldsOrElements

protected abstract int getNumberOfFieldsOrElements()

hasObjectAttr
```
public boolean hasObjectAttr()
```

hasObjectAttr

public boolean hasObjectAttr(java.lang.Class<?> attrType)

getObjectAttr
```
public java.lang.Object getObjectAttr()
```
this returns all of them - use either if you know there will be only one attribute at a time, or check/process result with ObjectList

setObjectAttr
```
public void setObjectAttr(java.lang.Object a)
```
this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()

setObjectAttrNoClone
```
public void setObjectAttrNoClone(java.lang.Object a)
```
this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()

addObjectAttr

public void addObjectAttr(java.lang.Object a)

removeObjectAttr

public void removeObjectAttr(java.lang.Object a)

replaceObjectAttr

public void replaceObjectAttr(java.lang.Object oldAttr,
                              java.lang.Object newAttr)

getObjectAttr
```
public <T> T getObjectAttr(java.lang.Class<T> attrType)
```
this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general

getNextObjectAttr

public <T> T getNextObjectAttr(java.lang.Class<T> attrType,
                               java.lang.Object prev)

objectAttrIterator

public ObjectList.Iterator objectAttrIterator()

objectAttrIterator

public <T> ObjectList.TypedIterator<T> objectAttrIterator(java.lang.Class<T> type)

hasFieldAttr
```
public boolean hasFieldAttr()
```

hasFieldAttr

public boolean hasFieldAttr(java.lang.Class<?> attrType)

getFieldAttr
```
public java.lang.Object getFieldAttr(FieldInfo fi)
```
this returns all of them - use either if you know there will be only one attribute at a time, or check/process result with ObjectList

setFieldAttr
```
public void setFieldAttr(FieldInfo fi,
                         java.lang.Object attr)
```
this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()

addFieldAttr

public void addFieldAttr(FieldInfo fi,
                         java.lang.Object a)

removeFieldAttr

public void removeFieldAttr(FieldInfo fi,
                            java.lang.Object a)

replaceFieldAttr

public void replaceFieldAttr(FieldInfo fi,
                             java.lang.Object oldAttr,
                             java.lang.Object newAttr)

getFieldAttr
```
public <T> T getFieldAttr(FieldInfo fi,
                          java.lang.Class<T> attrType)
```
this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general

getNextFieldAttr

public <T> T getNextFieldAttr(FieldInfo fi,
                              java.lang.Class<T> attrType,
                              java.lang.Object prev)

fieldAttrIterator

public ObjectList.Iterator fieldAttrIterator(FieldInfo fi)

fieldAttrIterator

public <T> ObjectList.TypedIterator<T> fieldAttrIterator(FieldInfo fi,
                                                         java.lang.Class<T> type)

hasElementAttr
```
public boolean hasElementAttr()
```

hasElementAttr

public boolean hasElementAttr(java.lang.Class<?> attrType)

getElementAttr
```
public java.lang.Object getElementAttr(int idx)
```
this returns all of them - use either if you know there will be only one attribute at a time, or check/process result with ObjectList

setElementAttr
```
public void setElementAttr(int idx,
                           java.lang.Object attr)
```
this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()

setElementAttrNoClone
```
public void setElementAttrNoClone(int idx,
                                  java.lang.Object attr)
```
this replaces all of them - use only if you know - there will be only one attribute at a time - you obtained the value you set by a previous getXAttr() - you constructed a multi value list with ObjectList.createList()

addElementAttr

public void addElementAttr(int idx,
                           java.lang.Object a)

removeElementAttr

public void removeElementAttr(int idx,
                              java.lang.Object a)

replaceElementAttr

public void replaceElementAttr(int idx,
                               java.lang.Object oldAttr,
                               java.lang.Object newAttr)

addElementAttrNoClone

public void addElementAttrNoClone(int idx,
                                  java.lang.Object a)

<2do> those will be obsolete

removeElementAttrNoClone

public void removeElementAttrNoClone(int idx,
                                     java.lang.Object a)

replaceElementAttrNoClone

public void replaceElementAttrNoClone(int idx,
                                      java.lang.Object oldAttr,
                                      java.lang.Object newAttr)

getElementAttr
```
public <T> T getElementAttr(int idx,
                            java.lang.Class<T> attrType)
```
this only returns the first attr of this type, there can be more if you don't use client private types or the provided type is too general

getNextElementAttr

public <T> T getNextElementAttr(int idx,
                                java.lang.Class<T> attrType,
                                java.lang.Object prev)

elementAttrIterator

public ObjectList.Iterator elementAttrIterator(int idx)

elementAttrIterator

public <T> ObjectList.TypedIterator<T> elementAttrIterator(int idx,
                                                           java.lang.Class<T> type)

setDeclaredIntField

public void setDeclaredIntField(java.lang.String fname,
                                java.lang.String clsBase,
                                int value)

setBooleanField

public void setBooleanField(java.lang.String fname,
                            boolean value)

setByteField

public void setByteField(java.lang.String fname,
                         byte value)

setCharField

public void setCharField(java.lang.String fname,
                         char value)

setShortField

public void setShortField(java.lang.String fname,
                          short value)

setIntField

public void setIntField(java.lang.String fname,
                        int value)

setLongField

public void setLongField(java.lang.String fname,
                         long value)

setFloatField

public void setFloatField(java.lang.String fname,
                          float value)

setDoubleField

public void setDoubleField(java.lang.String fname,
                           double value)

setReferenceField

public void setReferenceField(java.lang.String fname,
                              int value)

getFieldValueObject

public java.lang.Object getFieldValueObject(java.lang.String fname)

getEnclosingElementInfo

public ElementInfo getEnclosingElementInfo()

setBooleanField

public void setBooleanField(FieldInfo fi,
                            boolean newValue)

setByteField

public void setByteField(FieldInfo fi,
                         byte newValue)

setCharField

public void setCharField(FieldInfo fi,
                         char newValue)

setShortField

public void setShortField(FieldInfo fi,
                          short newValue)

setIntField

public void setIntField(FieldInfo fi,
                        int newValue)

setLongField

public void setLongField(FieldInfo fi,
                         long newValue)

setFloatField

public void setFloatField(FieldInfo fi,
                          float newValue)

setDoubleField

public void setDoubleField(FieldInfo fi,
                           double newValue)

setReferenceField

public void setReferenceField(FieldInfo fi,
                              int newValue)

set1SlotField

public void set1SlotField(FieldInfo fi,
                          int newValue)

set2SlotField

public void set2SlotField(FieldInfo fi,
                          long newValue)

setDeclaredReferenceField

public void setDeclaredReferenceField(java.lang.String fname,
                                      java.lang.String clsBase,
                                      int value)

getDeclaredReferenceField

public int getDeclaredReferenceField(java.lang.String fname,
                                     java.lang.String clsBase)

getReferenceField

public int getReferenceField(java.lang.String fname)

getDeclaredIntField

public int getDeclaredIntField(java.lang.String fname,
                               java.lang.String clsBase)

getIntField

public int getIntField(java.lang.String fname)

setDeclaredLongField

public void setDeclaredLongField(java.lang.String fname,
                                 java.lang.String clsBase,
                                 long value)

getDeclaredLongField

public long getDeclaredLongField(java.lang.String fname,
                                 java.lang.String clsBase)

getLongField

public long getLongField(java.lang.String fname)

getDeclaredBooleanField

public boolean getDeclaredBooleanField(java.lang.String fname,
                                       java.lang.String refType)

getBooleanField

public boolean getBooleanField(java.lang.String fname)

getDeclaredByteField

public byte getDeclaredByteField(java.lang.String fname,
                                 java.lang.String refType)

getByteField

public byte getByteField(java.lang.String fname)

getDeclaredCharField

public char getDeclaredCharField(java.lang.String fname,
                                 java.lang.String refType)

getCharField

public char getCharField(java.lang.String fname)

getDeclaredDoubleField

public double getDeclaredDoubleField(java.lang.String fname,
                                     java.lang.String refType)

getDoubleField

public double getDoubleField(java.lang.String fname)

getDeclaredFloatField

public float getDeclaredFloatField(java.lang.String fname,
                                   java.lang.String refType)

getFloatField

public float getFloatField(java.lang.String fname)

getDeclaredShortField

public short getDeclaredShortField(java.lang.String fname,
                                   java.lang.String refType)

getShortField

public short getShortField(java.lang.String fname)

getBooleanField

public boolean getBooleanField(FieldInfo fi)

getByteField

public byte getByteField(FieldInfo fi)

getCharField

public char getCharField(FieldInfo fi)

getShortField

public short getShortField(FieldInfo fi)

getIntField
```
public int getIntField(FieldInfo fi)
```

getLongField

public long getLongField(FieldInfo fi)

getFloatField

public float getFloatField(FieldInfo fi)

getDoubleField

public double getDoubleField(FieldInfo fi)

getReferenceField

public int getReferenceField(FieldInfo fi)

get1SlotField

public int get1SlotField(FieldInfo fi)

get2SlotField

public long get2SlotField(FieldInfo fi)

checkArray
```
protected void checkArray(int index)
```

isReferenceArray
```
public boolean isReferenceArray()
```

copyElements
```
public void copyElements(ThreadInfo ti,
                         ElementInfo eiSrc,
                         int srcIdx,
                         int dstIdx,
                         int length)
```
this is the backend for System.arraycopy implementations, but since it only throws general exceptions it can also be used in other contexts that require type and objRef checking note that we have to do some additional type checking here because we store reference arrays as int[], i.e. for reference arrays we can't rely on System.arraycopy to do the element type checking for us

Throws:

java.lang.ArrayIndexOutOfBoundsException

java.lang.ArrayStoreException

setBooleanElement

public void setBooleanElement(int idx,
                              boolean value)

setByteElement

public void setByteElement(int idx,
                           byte value)

setCharElement

public void setCharElement(int idx,
                           char value)

setShortElement

public void setShortElement(int idx,
                            short value)

setIntElement

public void setIntElement(int idx,
                          int value)

setLongElement

public void setLongElement(int idx,
                           long value)

setFloatElement

public void setFloatElement(int idx,
                            float value)

setDoubleElement

public void setDoubleElement(int idx,
                             double value)

setReferenceElement

public void setReferenceElement(int idx,
                                int value)

arrayCopy

public void arrayCopy(ElementInfo src,
                      int srcPos,
                      int dstPos,
                      int len)

NOTE - this doesn't support element type checks or overlapping in-array copy

getBooleanElement

public boolean getBooleanElement(int idx)

getByteElement
```
public byte getByteElement(int idx)
```

getCharElement
```
public char getCharElement(int idx)
```

getShortElement

public short getShortElement(int idx)

getIntElement
```
public int getIntElement(int idx)
```

getLongElement
```
public long getLongElement(int idx)
```

getFloatElement

public float getFloatElement(int idx)

getDoubleElement

public double getDoubleElement(int idx)

getReferenceElement

public int getReferenceElement(int idx)

setObjectRef

public void setObjectRef(int newObjRef)

getObjectRef
```
public int getObjectRef()
```

getIndex
```
@Deprecated
public int getIndex()
```
Deprecated.

use getObjectRef() - this is not an index

getLockCount
```
public int getLockCount()
```

getLockingThread
```
public ThreadInfo getLockingThread()
```

isLocked
```
public boolean isLocked()
```

isArray
```
public boolean isArray()
```

isCharArray
```
public boolean isCharArray()
```

isFloatArray
```
public boolean isFloatArray()
```

isDoubleArray
```
public boolean isDoubleArray()
```

getArrayType

public java.lang.String getArrayType()

getBacktrackData

public java.lang.Object getBacktrackData()

asBooleanArray
```
public boolean[] asBooleanArray()
```

asByteArray
```
public byte[] asByteArray()
```

asShortArray
```
public short[] asShortArray()
```

asCharArray
```
public char[] asCharArray()
```

asIntArray
```
public int[] asIntArray()
```

asLongArray
```
public long[] asLongArray()
```

asFloatArray
```
public float[] asFloatArray()
```

asDoubleArray
```
public double[] asDoubleArray()
```

asReferenceArray
```
public int[] asReferenceArray()
```

isNull
```
public boolean isNull()
```

getDeclaredObjectField

public ElementInfo getDeclaredObjectField(java.lang.String fname,
                                          java.lang.String referenceType)

getObjectField

public ElementInfo getObjectField(java.lang.String fname)

getHeapSize
```
public int getHeapSize()
```
answer an estimate of the heap size in bytes (this is of course VM dependent, but we can give an upper bound for the fields/elements, and that should be good in terms of application specific properties)

getStringField

public java.lang.String getStringField(java.lang.String fname)

getType
```
public java.lang.String getType()
```

getLockedThreads
```
public ThreadInfo[] getLockedThreads()
```
return all threads that are trying to acquire this lock (blocked, waiting, interrupted) NOTE - this is not a copy, don't modify the array

getWaitingThreads
```
public ThreadInfo[] getWaitingThreads()
```
get a cloned list of the waiters for this object

hasWaitingThreads
```
public boolean hasWaitingThreads()
```

getBlockedThreads

public ThreadInfo[] getBlockedThreads()

getBlockedOrWaitingThreads

public ThreadInfo[] getBlockedOrWaitingThreads()

arrayLength
```
public int arrayLength()
```

isStringObject
```
public boolean isStringObject()
```

asString
```
public java.lang.String asString()
```

getStringChars
```
public char[] getStringChars()
```

equalsString
```
public boolean equalsString(java.lang.String s)
```
just a helper to avoid creating objects just for the sake of comparing

isBoxObject
```
public boolean isBoxObject()
```
is this a Number, a Boolean or a Character object Note these classes are all final, so we don't have to check for subtypes <2do> we should probably use a regular expression here

asBoxObject
```
public java.lang.Object asBoxObject()
```

canLock

public boolean canLock(ThreadInfo th)

checkArrayBounds

public void checkArrayBounds(int index)
                      throws ArrayIndexOutOfBoundsExecutiveException

Throws:: ArrayIndexOutOfBoundsExecutiveException

clone
```
public ElementInfo clone()
```
Overrides:

clone in class java.lang.Object

deepClone
```
public ElementInfo deepClone()
```

instanceOf

public boolean instanceOf(java.lang.String type)

getNumberOfFields

public abstract int getNumberOfFields()

getFieldInfo

public abstract FieldInfo getFieldInfo(int fieldIndex)

registerLockContender
```
public void registerLockContender(ThreadInfo ti)
```
threads that will grab our lock on their next execution have to be registered, so that they can be blocked in case somebody else gets scheduled

isRegisteredLockContender

public boolean isRegisteredLockContender(ThreadInfo ti)

unregisterLockContender
```
public void unregisterLockContender(ThreadInfo ti)
```
somebody made up his mind and decided not to enter a synchronized section of code it had registered before (e.g. INVOKECLINIT)

block
```
public void block(ThreadInfo ti)
```
from a MONITOR_ENTER or sync INVOKExx if we cannot acquire the lock note: this is not called from a NOTIFIED_UNBLOCKED state, so we don't have to restore NOTIFIED

lock
```
public void lock(ThreadInfo ti)
```
from a MONITOR_ENTER or sync INVOKExx if we can acquire the lock

unlock
```
public boolean unlock(ThreadInfo ti)
```
from a MONITOR_EXIT or sync method RETURN release a possibly recursive lock if lockCount goes to zero return true if this unblocked any waiters

notifies
```
public boolean notifies(SystemState ss,
                        ThreadInfo ti)
```
notifies one of the waiters. Note this is a potentially non-deterministic action if we have several waiters, since we have to try all possible choices. Note that even if we notify a thread here, it still remains in the lockedThreads list until the lock is released (notified threads cannot run right away)

notifies

public boolean notifies(SystemState ss,
                        ThreadInfo ti,
                        boolean hasToHoldLock)

return true if this did notify any waiters

notifiesAll
```
public boolean notifiesAll()
```
notify all waiters. This is a deterministic action all waiters remain in the locked list, since they still have to be unblocked, which happens in the unlock (monitor_exit or sync return) following the notifyAll()

wait
```
public void wait(ThreadInfo ti,
                 long timeout)
```
wait to be notified. thread has to hold the lock, but gives it up in the wait. Make sure lockCount can be restored properly upon notification

wait

public void wait(ThreadInfo ti,
                 long timeout,
                 boolean hasToHoldLock)

lockNotified
```
public void lockNotified(ThreadInfo ti)
```
re-acquire lock after being notified. This is the notified thread, i.e. the one that will come out of a wait()

resumeNonlockedWaiter
```
public void resumeNonlockedWaiter(ThreadInfo ti)
```
this is for waiters that did not own the lock

getPinDownCount
```
public int getPinDownCount()
```

isPinnedDown
```
public boolean isPinnedDown()
```

isConstructed
```
public boolean isConstructed()
```

setConstructed
```
public void setConstructed()
```

restoreFields
```
public void restoreFields(Fields f)
```

getFields
```
public Fields getFields()
```
BEWARE - never change the returned object without knowing about the ElementInfo change status, this field is state managed!

getArrayFields
```
public ArrayFields getArrayFields()
```

restore

public void restore(int index,
                    int attributes,
                    Fields fields,
                    Monitor monitor)

restoreMonitor

public void restoreMonitor(Monitor m)

getMonitor
```
public Monitor getMonitor()
```
BEWARE - never change the returned object without knowing about the ElementInfo change status, this field is state managed!

restoreAttributes
```
public void restoreAttributes(int a)
```

isAlive

public boolean isAlive(boolean liveBitValue)

setAlive

public void setAlive(boolean liveBitValue)

isMarked
```
public boolean isMarked()
```

isFinalized
```
public boolean isFinalized()
```

setFinalized
```
public void setFinalized()
```

setMarked
```
public void setMarked()
```

isMarkedOrAlive

public boolean isMarkedOrAlive(boolean liveBitValue)

markUnchanged
```
public void markUnchanged()
```

setUnmarked
```
public void setUnmarked()
```

checkIsModifiable
```
protected void checkIsModifiable()
```

isLockedBy

public boolean isLockedBy(ThreadInfo ti)

isLocking

public boolean isLocking(ThreadInfo ti)

checkConsistency
```
public void checkConsistency()
```

checkAssertion

protected void checkAssertion(boolean cond,
                              java.lang.String failMsg)

Class ElementInfo

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ATTR_PINDOWN_MASK

ATTR_IS_FROZEN

ATTR_IMMUTABLE

ATTR_CONSTRUCTED

ATTR_FINALIZED

ATTR_EXPOSED

ATTR_SHARED

ATTR_FREEZE_SHARED

ATTR_TREF_CHANGED

ATTR_FLI_CHANGED

ATTR_ATTRIBUTE_CHANGED

ATTR_IS_MARKED

ATTR_LIVE_BIT

ATTR_MARKED_OR_LIVE_BIT

ci

fields

monitor

referencingThreads

fLockInfo

objRef

attributes

cachedMemento

sid

Constructor Detail

ElementInfo

ElementInfo

Method Detail

getModifiableInstance

isObject

hasFinalizer

hasChanged

toString

getFieldLockInfo

setFieldLockInfo

isLockProtected

processReleaseActions

setSid

getSid

getCachedMemento

setCachedMemento

hasRefField

numberOfUserThreads

isImmutable

freeze

defreeze

isFrozen

setReferencingThreads

getReferencingThreads

freezeSharedness

isSharednessFrozen

isShared

setShared

isReferencedBySameThreads

isReferencedByThread

isExposed

isExposedOrShared

getExposedInstance

setExposed

setExposed

recycle

hash

hashCode

equals

getClassInfo

getDeclaredFieldInfo

getFieldInfo

getNumberOfFieldsOrElements

hasObjectAttr

hasObjectAttr

getObjectAttr

setObjectAttr

setObjectAttrNoClone

addObjectAttr

removeObjectAttr