| Interface | Description |
|---|---|
| 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
|
| 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 | |
| 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
|
| 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 |
|---|---|
| ArrayIntSet |
common base for array based IntSet implementations
|
| ArrayObjectQueue<E> |
dynamically growing, cyclic array buffer queue for object references
|
| AvailableBufferedInputStream | |
| 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 | |
| CommitOutputStream | |
| ConsoleStream |
a utility that can be used to write logs which are displayed in a JTextArea
|
| ConstGrowth | |
| Debug |
logger used to print debugging messages based on the required debug level and
message category.
|
| 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.
|
| 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
|
| InstructionFactoryFilter |
utility class that can be used by InstructionFactory implementations to
selectively replace bytecodes for specified class sets.
|
| 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.
|
| 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
|
| 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"
|
| Permutation | |
| 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.
|
| 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.
|
| 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 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
|
| 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.
|
| 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.
|
| 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.
|