ChoiceGenerator

All Superinterfaces:

java.lang.Cloneable

All Known Subinterfaces:

DoubleChoiceGenerator, FloatChoiceGenerator, IntChoiceGenerator, LongChoiceGenerator, ReferenceChoiceGenerator, ThreadChoiceGenerator

All Known Implementing Classes:

BooleanChoiceGenerator, BreakGenerator, ChoiceGeneratorBase, CompoundChoiceGenerator, DoubleChoiceFromList, DoubleChoiceFromSet, DoubleThresholdGenerator, EventChoiceGenerator, EventGenerator, ExceptionThreadChoiceFromSet, ExposureCG, FloatChoiceFromList, IntChoiceFromList, IntChoiceFromSet, IntIntervalGenerator, InvocationCG, LongChoiceFromList, NumberChoiceFromList, PermutationCG, RandomIntIntervalGenerator, RandomOrderIntCG, RandomOrderLongCG, ThreadChoiceFromSet, TypedObjectChoice
```
public interface ChoiceGenerator<T>
extends java.lang.Cloneable
```
generic interface for configurable choice generators

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`addAttr(java.lang.Object a)`
`void`	`advance()` advance to the next choice.
`void`	`advance(int nChoices)`
`ObjectList.Iterator`	`attrIterator()`
`<A> ObjectList.TypedIterator<A>`	`attrIterator(java.lang.Class<A> attrType)`
`ChoiceGenerator<?>`	`clone()`
`ChoiceGenerator<?>`	`deepClone()`
`ChoiceGenerator<?>[]`	`getAll()` return array with all parents and this CG, in registration order
`T[]`	`getAllChoices()`
`<C extends ChoiceGenerator<?>> C[]`	`getAllOfType(java.lang.Class<C> cgType)` return array with all CGs (including this one) of given 'cgType', in registration order
`java.lang.Object`	`getAttr()` 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
`<A> A`	`getAttr(java.lang.Class<A> 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
`ChoiceGenerator<?>[]`	`getCascade()` return array with all cascaded parents and this CG, in registration order
`ChoiceGenerator<?>`	`getCascadedParent()` returns the prev CG if it was registered for the same insn
`T`	`getChoice(int i)`
`java.lang.Class<T>`	`getChoiceType()`
`java.lang.String`	`getId()`
`int`	`getIdRef()`
`Instruction`	`getInsn()`
`<A> A`	`getNextAttr(java.lang.Class<A> attrType, java.lang.Object prev)`
`T`	`getNextChoice()`
`int`	`getNumberOfParents()`
`ChoiceGenerator<?>`	`getPreviousChoiceGenerator()`
`<T extends ChoiceGenerator<?>> T`	`getPreviousChoiceGeneratorOfType(java.lang.Class<T> cls)`
`T[]`	`getProcessedChoices()`
`int`	`getProcessedNumberOfChoices()`
`java.lang.String`	`getSourceLocation()`
`int`	`getStateId()`
`ThreadInfo`	`getThreadInfo()`
`int`	`getTotalNumberOfChoices()`
`T[]`	`getUnprocessedChoices()`
`boolean`	`hasAttr()`
`boolean`	`hasAttr(java.lang.Class<?> attrType)`
`boolean`	`hasMoreChoices()`
`boolean`	`isCascaded()`
`boolean`	`isDone()`
`boolean`	`isProcessed()`
`boolean`	`isSchedulingPoint()`
`ChoiceGenerator<T>`	`randomize()` turn the order of choices random (if it isn't already).
`void`	`removeAttr(java.lang.Object a)`
`ChoiceGenerator<T>`	`reorder(java.util.Comparator<T> comparator)` reorder according to a user provided comparator
`void`	`replaceAttr(java.lang.Object oldAttr, java.lang.Object newAttr)`
`void`	`reset()` this has to reset the CG to its initial state, which includes resetting 'isDone'
`void`	`select(int nChoice)`
`void`	`setAttr(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`	`setCascaded()`
`void`	`setContext(ThreadInfo tiCreator)`
`void`	`setCurrent()` to be called before the first advance().
`void`	`setDone()`
`void`	`setId(java.lang.String id)`
`void`	`setIdRef(int idRef)`
`void`	`setInsn(Instruction insn)`
`void`	`setPreviousChoiceGenerator(ChoiceGenerator<?> cg)`
`void`	`setStateId(int stateId)`
`void`	`setThreadInfo(ThreadInfo ti)`
`boolean`	`supportsReordering()`

- Method Detail
  - getNextChoice
```
T getNextChoice()
```
  - getChoiceType
```
java.lang.Class<T> getChoiceType()
```
  - hasMoreChoices
```
boolean hasMoreChoices()
```
  - setCurrent
```
void setCurrent()
```
    to be called before the first advance(). Can be used in implementors to initialize choices from context (similar to what listeners can do from choiceGeneratorSet() notifications)
  - advance
```
void advance()
```
    advance to the next choice. This is the only method that really advances our enumeration
  - advance
```
void advance(int nChoices)
```
  - select
```
void select(int nChoice)
```
  - isDone
```
boolean isDone()
```
  - setDone
```
void setDone()
```
  - isProcessed
```
boolean isProcessed()
```
  - reset
```
void reset()
```
    this has to reset the CG to its initial state, which includes resetting 'isDone'
  - getTotalNumberOfChoices
```
int getTotalNumberOfChoices()
```
  - getProcessedNumberOfChoices
```
int getProcessedNumberOfChoices()
```
  - getChoice
```
T getChoice(int i)
```
  - getAllChoices
```
T[] getAllChoices()
```
  - getProcessedChoices
```
T[] getProcessedChoices()
```
  - getUnprocessedChoices
```
T[] getUnprocessedChoices()
```
  - getPreviousChoiceGenerator
```
ChoiceGenerator<?> getPreviousChoiceGenerator()
```
  - getNumberOfParents
```
int getNumberOfParents()
```
  - randomize
```
ChoiceGenerator<T> randomize()
```
    turn the order of choices random (if it isn't already). Only drawback of this generic method (which might be a decorator factory) is that our type layer (e.g. IntChoiceGenerator) has to guarantee type safety. But hey - this is the first case where we can use covariant return types! NOTES: - this method may alter this ChoiceGenerator and return that or return a new "decorated" version. - random data can be read from the "Random random" field in this class.
  - clone
```
ChoiceGenerator<?> clone()
                  throws java.lang.CloneNotSupportedException
```
    Throws:
    
    java.lang.CloneNotSupportedException
  - deepClone
```
ChoiceGenerator<?> deepClone()
                      throws java.lang.CloneNotSupportedException
```
    Throws:
    
    java.lang.CloneNotSupportedException
  - getId
```
java.lang.String getId()
```
  - getIdRef
```
int getIdRef()
```
  - setIdRef
```
void setIdRef(int idRef)
```
  - setId
```
void setId(java.lang.String id)
```
  - isSchedulingPoint
```
boolean isSchedulingPoint()
```
  - setThreadInfo
```
void setThreadInfo(ThreadInfo ti)
```
  - getThreadInfo
```
ThreadInfo getThreadInfo()
```
  - setInsn
```
void setInsn(Instruction insn)
```
  - getInsn
```
Instruction getInsn()
```
  - setContext
```
void setContext(ThreadInfo tiCreator)
```
  - setStateId
```
void setStateId(int stateId)
```
  - getStateId
```
int getStateId()
```
  - getSourceLocation
```
java.lang.String getSourceLocation()
```
  - supportsReordering
```
boolean supportsReordering()
```
  - reorder
```
ChoiceGenerator<T> reorder(java.util.Comparator<T> comparator)
```
    reorder according to a user provided comparator
  - setPreviousChoiceGenerator
```
void setPreviousChoiceGenerator(ChoiceGenerator<?> cg)
```
  - setCascaded
```
void setCascaded()
```
  - isCascaded
```
boolean isCascaded()
```
  - getPreviousChoiceGeneratorOfType
```
<T extends ChoiceGenerator<?>> T getPreviousChoiceGeneratorOfType(java.lang.Class<T> cls)
```
  - getCascadedParent
```
ChoiceGenerator<?> getCascadedParent()
```
    returns the prev CG if it was registered for the same insn
  - getCascade
```
ChoiceGenerator<?>[] getCascade()
```
    return array with all cascaded parents and this CG, in registration order
  - getAll
```
ChoiceGenerator<?>[] getAll()
```
    return array with all parents and this CG, in registration order
  - getAllOfType
```
<C extends ChoiceGenerator<?>> C[] getAllOfType(java.lang.Class<C> cgType)
```
    return array with all CGs (including this one) of given 'cgType', in registration order
  - hasAttr
```
boolean hasAttr()
```
  - hasAttr
```
boolean hasAttr(java.lang.Class<?> attrType)
```
  - getAttr
```
java.lang.Object getAttr()
```
    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
  - setAttr
```
void setAttr(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()
  - addAttr
```
void addAttr(java.lang.Object a)
```
  - removeAttr
```
void removeAttr(java.lang.Object a)
```
  - replaceAttr
```
void replaceAttr(java.lang.Object oldAttr,
                 java.lang.Object newAttr)
```
  - getAttr
```
<A> A getAttr(java.lang.Class<A> 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
  - getNextAttr
```
<A> A getNextAttr(java.lang.Class<A> attrType,
                  java.lang.Object prev)
```
  - attrIterator
```
ObjectList.Iterator attrIterator()
```
  - attrIterator
```
<A> ObjectList.TypedIterator<A> attrIterator(java.lang.Class<A> attrType)
```

Interface ChoiceGenerator<T>

Method Summary

Method Detail

getNextChoice

getChoiceType

hasMoreChoices

setCurrent

advance

advance

select

isDone

setDone

isProcessed

reset

getTotalNumberOfChoices

getProcessedNumberOfChoices

getChoice

getAllChoices

getProcessedChoices

getUnprocessedChoices

getPreviousChoiceGenerator

getNumberOfParents

randomize

clone

deepClone

getId

getIdRef

setIdRef

setId

isSchedulingPoint

setThreadInfo

getThreadInfo

setInsn

getInsn

setContext

setStateId

getStateId

getSourceLocation

supportsReordering

reorder

setPreviousChoiceGenerator

setCascaded

isCascaded

getPreviousChoiceGeneratorOfType

getCascadedParent

getCascade

getAll

getAllOfType

hasAttr

hasAttr

getAttr

setAttr

addAttr

removeAttr

replaceAttr

getAttr

getNextAttr

attrIterator

attrIterator