| Interface | Description |
|---|---|
| Attributable |
interface for types that support attributes
|
| BinaryClassSource.ByteReader | |
| CloneableObject |
the standard java.lang.Cloneable is just a type tag without methods, so
we can't use it to enforce public access of clone()
|
| Cloner<E> |
this is a helper to enable deep copy of generic containers, where the
element types are generic type parameters and therefore can't be
created via ctor or clone.
|
| ElementCreator<T,E> |
create an instance of type E out of a T instance
|
| FixedBitSet |
BitSet like interface for fixed size bit sets
We keep this as an interface so that we can have java.util.BitSet
subclasses as implementations
|
| Growth | |
| IdentityObjectSet<E> |
an ObjectSet that uses reference comparison (identity) for inclusion checks
|
| IndexIterator |
specialized iterator class for index values [0..N]
|
| IntIterator |
just a little helper to iterate over collections of ints without doing
a lot of boxing/unboxing
|
| IntSet | |
| Loggable |
convenience interface that mixes in JPFLogger interface methods
|
| ObjectQueue<E> |
generic interface for object queues
|
| ObjectSet<E> |
generic interface for object sets
this one makes no guarantees about identity or value comparison
|
| Predicate<T> | |
| Printable |
Printable is mainly used to avoid having to create potentially huge
String(via StringBuilders or Writers) which are just used to be
written to std streams
|
| PrintStreamable |
convenience interface to mix in PrintStream interface
|
| Processor<T> | |
| ReadOnlyObjList<E> | |
| RunListener |
little helper interface to facilitate resetting classes and objects
between JPF runs, mostly to avoid memory leaks
|
| StateExtensionClient<T> |
generic interface for state extensions that have to be backtracked/restored
|
| Transformer<T1,T2> |
transforms between two types
a utility interface that esp.
|
| TwoTypeComparator<T1,T2> |
like a normal comparator, but comparing heterogenous objects
|
| Class | Description |
|---|---|
| ArrayByteQueue |
It is a dynamically growing, cyclic array buffer queue for bytes.
|
| ArrayIntSet |
common base for array based IntSet implementations
|
| ArrayObjectQueue<E> |
dynamically growing, cyclic array buffer queue for object references
|
| AvailableBufferedInputStream | |
| BinaryClassSource |
common root for classes that read classes from binary data
|
| BitArray |
Faster version of BitSet for fixed size.
|
| BitSet1024 |
a fixed size BitSet with 1024 bits.
|
| BitSet256 |
a fixed size BitSet with 256 bits.
|
| BitSet64 | |
| BitSetN |
a FixedBitSet implementation that is based on java.util.BitSet
|
| ClassInfoFilter |
utility class that can be used by InstructionFactory implementations to
selectively replace bytecodes for specified class sets.
|
| CommitOutputStream | |
| ConsoleStream |
a utility that can be used to write logs which are displayed in a JTextArea
|
| ConstGrowth | |
| DevNullPrintStream |
a PrintStream that doesn't print anything
|
| DynamicIntArray |
simplistic dynamic array that differentiates from ArrayList by
- using chunks instead of exponential growth, thus efficiently dealing
with sparse arrays
- managing primitive 'int' types, i.e.
|
| DynamicObjectArray<E> |
simplistic Object array that differentiates from ArrayList by
using chunks instead of exponential growth, thus efficiently dealing
with huge, potentially sparse arrays
the motivation for this class is memory optimization, i.e.
|
| ExpGrowth | |
| FeatureSpec |
common base class for MethodSpec and FieldSpec
|
| FieldSpec |
utility class that can match FieldInfos against specs.
|
| FieldSpecMatcher |
a matcher for a collection of FieldSpecs
|
| FileUtils |
utility class to find all files matching (possibly hierarchical)
wildcard path specs
we support single '*' wildcards as in filename matching, plus "**" patterns
that match all (recursive) subdirectories
|
| FinalBitSet |
Faster version of BitSet for those that never change.
|
| HashData |
object to compute complex hash values that can be accumulated and
delegated (to aggregates etc.)
used to obtain hashcodes for states
|
| HashPool<V> |
data structure used to do hash collapsing.
|
| IdentityArrayObjectSet<E> |
simple identity set for objects
we don't sort&bisect, assuming the number of entries will be small
be aware this doesn't scale to large sets
|
| ImmutableList<E> |
utility class for JPF internal linked lists that are tail-immutable
|
| InstructionState |
a abstract SystemAttribute that can be used to store instruction
execution state between top and bottom halves of respective instruction.execute() methods
|
| IntArray |
Wrapper for int[] that provides proper equals() and hashCode() methods.
|
| IntTable<E> |
A hash map that holds int values associated with generic key objects.
|
| IntTable.Entry<E> |
encapsulates an Entry in the table.
|
| IntTable.Snapshot<E> |
helper class to store a compact, invariant representation of this table
|
| IntVector |
(more efficient?) alternative to Vector
|
| Invocation |
a record that includes all information to perform a call
|
| JPFLogger |
this is a decorator for java.util.logging.JPFLogger
We use this to avoid explicit Logger.isLoggable() checks in the code.
|
| JPFSiteUtils |
utility class for JPF site configuration related functions.
|
| Left |
left justified output
<2do> this is not worth a class! use a general TextFormatter
|
| LimitedInputStream | |
| LinkedObjectQueue<E> |
object queue that uses cached link entries
|
| LocationSpec |
support for specification of source locations
This maps sourcefile:line1-range strings into instructions that can be efficiently
checked for by listeners.
|
| LogHandler |
log handler class that deals with output selection and formatting.
|
| LogHandler.DefaultConsoleHandler | |
| LogManager |
this class is responsible for returning properly JPF-configured
Loggers.
|
| LongVector |
(more efficient?) alternative to Vector
|
| MethodInfoRegistry |
just a little helper for java.lang.reflect peers
<2do> - it's overly simplistic for now
|
| MethodSpec |
utility class that can match methods/args against specs.
|
| MethodSpecMatcher |
a matcher for a collection of MethodSpecs
|
| Misc | |
| MutableInteger |
an object that holds a mutable int.
|
| MutableIntegerRestorer |
on-demand restorer for MutableInteger instances
|
| OATHash |
Bob Jenkins One-at-a-Time Hash (http://www.burtleburtle.net/bob/hash/doobs.html),
a simple yet sufficiently avalanching hash that doesn't require a-priori knowledge
of the key length and is much faster than lookup3
|
| ObjArray<E> |
Wrapper for arrays of objects which provides proper equals() and hashCode()
methods, and behaves nicely with Java 1.5 generics.
|
| ObjectConverter |
Object transformer from Java objects to JPF objects
|
| ObjectList |
a minimal container API that transparently handles Object lists which can
degenerate to single values that are stored directly.
|
| ObjectList.Iterator | |
| ObjectList.TypedIterator<A> | |
| ObjVector<E> |
more customizable alternative to java.util.Vector.
|
| ObjVector.MutatingSnapshot<E,T> |
snapshot that can mutate element values, but therefore can't use block operations.
|
| ObjVector.Snapshot<E> |
this is a block operation snapshot that stores chunks of original data with
not more than DEFAULT_MAX_GAP consecutive null elements.
|
| Pair<A,B> |
simple const wrapper utility class for 2-tuple
|
| PairPermutationGenerator |
a generator for pair-wise permutations, which only considers permutations
for each pair of elements, regardless of position.
|
| PathnameExpander |
utility to perform pathname expansion
the following patterns are supported so far:
(1) brace expansion ala bash: foo{Boo,Shoo} => fooBoo, fooShoo
(this doesn't check for existence, its simply lexical)
(2) '*' wildcard pathname expansion ala bash: "*.java" | "*\Main*.java"
(supports wildcards in mutiple path elements and within file/dir name)
(3) recursive dir expansion ala Ant: "**\*.jar"
|
| PermutationGenerator |
base type for permutation generators
|
| PrintUtils | |
| PSIntMap<V> |
Persistent (immutable) associative array that maps integer keys to generic reference values.
|
| PSIntMap.BitmapNode<E> |
A node that holds between 2 and 31 elements.
|
| PSIntMap.FullNode<E> |
newElements node with 32 elements, for which we don't need newElements bitmap.
|
| PSIntMap.Node<E> |
Abstract root class for all node types.
|
| PSIntMap.OneNode<E> |
Node that has only one element and hence does not need an array.
|
| RandomPermutationGenerator |
a permutation generator that uses the Fisher-Yates shuffle
(Durstenfeld, R.
|
| Reflection |
reflection utilities
|
| RepositoryEntry |
simple generic structure to hold repository info for source files
<2do> extend this to find out what the status of the repository is, i.e.
|
| Result |
simple result wrapper that can store a boolean value and a String, to
be used as method return value if we have to keep exceptions in the callee
|
| Right |
right justified output
<2do> this is not worth a class! use a general TextFormatter
|
| RunRegistry |
little helper to enable resetting classes and objects between JPF runs,
mostly to avoid memory leaks
reset() has to be called at the beginning of a new run, causing all
still registered listeners to be notified.
|
| SimplePool<E> |
This is a simplified hash pool that does not support removal or
numbering of elements.
|
| SingleElementList<E> |
a immutable list that just contains a single element
This is just an optimization for constructs such as CGs that inherently can
contain lists, but frequently don't have more than a single element
While java.util.Collections provides optimizations for empty lists, there is
no optimization for single element lists
|
| SortedArrayIntSet |
a set of integers that uses a simple sorted int array and binary search
To be used in a context where
- the number of elements does not have a hard limit
- the number of elements is assumed to be small, but potentially sparse
- the following operations are time critical
+ inclusion check
+ size check
+ cloning
+ iteration over elements
- adding/removing should be better than O(N)
|
| SortedArrayObjectSet<T extends java.lang.Comparable<T>> |
a generic set of comparable objects with value based inclusion check
(i.e.
|
| Source |
utility class to access arbitrary source files by line number
sources can be files inside of root directories, or
can be entries in jars
|
| SourceRef |
a source reference abstraction wrapping file and line information
|
| SparseClusterArray<E> |
A generic sparse reference array that assumes clusters, and more
frequent intra-cluster access.
|
| SparseClusterArray.Chunk | |
| SparseClusterArray.ChunkNode | |
| SparseClusterArray.Entry<E> | |
| SparseClusterArray.Node |
this corresponds to a toplevel cluster (e.g.
|
| SparseClusterArray.Root | |
| SparseClusterArray.Snapshot<T,E> | |
| SparseIntVector |
This has approximately the interface of IntVector but uses a hash table
instead of an array.
|
| SparseIntVector.Snapshot |
a simplistic snapshot implementation that stores set indices/values in order to save space
|
| SparseObjVector<E> |
This has approximately the interface of ObjVector but uses a hash table
instead of an array.
|
| SplitInputStream | |
| SplitOutputStream | |
| StateExtensionListener<T> |
generic listener that keeps track of state extensions, using
state ids as index values into a dynamic array of T objects
the purpose of this utility class is to make state extensions
backtrackable, so that clients don't have to care about this
|
| StringExpander |
utility class to expand regular expression like strings.
|
| StringMatcher |
simple wrapper around Patter/Matcher pairs, with patterns using '*' wildcards
same as StringSetMatcher but for single patterns
|
| StringSetMatcher |
simple utility that can be used to check for string matches in
sets with '*' wildcards, e.g.
|
| StructuredPrinter |
a common base for printers that need to keep track of indentation levels
|
| TotalPermutationGenerator |
a pull mode generator for permutations that executes in constant space,
using Ives' algorithm (F.
|
| Trace<T> |
a generic, listener- created trace over property specific operations
we could register this as a listener itself, but since it usually is used from
a listener, we might as well just delegate from there
|
| TraceElement<T> |
encapsulates a listener-managed trace operation
|
| TypeRef |
this is a utility construct for type references that should
not cause class loading when instantiated, but cannot use a
classname String because of argument type ambiguity (Strings are just
used everywhere).
|
| TypeSpec |
wildcard supporting type specification to be used for JPF configuration.
|
| TypeSpecMatcher |
a matcher for collections of TypeSpecs
|
| UniqueRandomPermGenerator |
a RandomPermutationGenerator that keeps track of previously produced values
to avoid duplicates.
|
| UnsortedArrayIntSet |
a simplistic IntSet implementation that uses an unsorted array to keep elements.
|
| VarSpec |
utility class to specify local variables in JPF options
example:
x.y.MyClass.foo(int,double):x
Note: this is not derived from FeatureSpec, it only used a MethodSpec for delegation
<2do> we don't deal with scopes or types yet
|
| WeakPool<E> |
This is a simplified hash pool that does not support removal or
numbering of elements.
|
| Exception | Description |
|---|---|
| BailOut |
this is just an evil control flow exception for non-local gotos
Useful in a context where you have to terminate execution from different (recursive) levels
|