All Classes and Interfaces

Class
Description
Represents a set of IFixedPointStatements to be solved by a IFixedPointSolver
Basic functionality for a Graph that delegates node and edge management.
 
Abstract superclass for meet operators
Basic functionality for a graph that delegates node and edge management, and tracks node numbers
 
operator for a step in an iterative solver This is an abstract class and not an interface in order to force subclasses to re-implement equals(), hashCode(), and toString()
Represents a single step in an iterative solver
Represents a single variable in a fixed-point system.
Utilities for dealing with acyclic subgraphs
an Iterator of array elements
Iterator that only returns non-null elements of the array hasNext() return true when there is a non-null element, false otherwise next() returns the current element and advances the counter up to the next non-null element or beyond the limit of the array
A set implementation backed by an array.
 
WALA-specific assertion checking.
a basic implementation of the dataflow framework
A generic process launcher
A relation between non-negative integers This implementation uses n IntVectors, to hold the first n y's associated with each x, and then 1 extra vector of SparseIntSet to hold the remaining ys.
Simple implementation of a NodeManager.
An implementation of NullaryStep that carries its operator explicitly
Inefficient implementation of OrderedMultiGraph.
A simple, extremely inefficient tree implementation
An implementation of UnaryStatement that carries its operator explicitly
This class implements breadth-first search over a Graph, returning an Iterator of the nodes of the graph in order of discovery.
This class searches breadth-first for node that matches some criteria.
This implementation of Map chooses between one of two implementations, depending on the size of the map.
An implementation of MutableIntSet that delegates to either a MutableSparseIntSet or a BitVectorIntSet
An object that creates some bimodal mutable int sets.
utilities for manipulating values at the bit-level.
A bit set is a set of elements, each of which corresponds to a unique integer from [0,MAX].
 
Abstract base class for implementations of bitvectors
Operator OUT = IN - filterSet
a basic implementation of the dataflow framework
Operator OUT = IN
Operator U(n) = U(n) n U(j)
A BitVector implementation of MutableIntSet.
 
Just kills everything
Operator OUT = (IN - kill) U gen
Operator OUT = IN / v
Operator OUT = IN U v
A repository for shared bit vectors as described by Heintze
Operator U(n) = U(n) U U(j)
Operator OUT = IN U c
Operator lhs = lhs U rhs U v
A bit vector variable for dataflow analysis.
Operator OUT = IN
A DataflowSolver specialized for BooleanVariables
Operator U(n) = U(n) U U(j)
A boolean variable for dataflow analysis.
This class implements breadth-first search over a Graph, returning an Iterator of the nodes of the graph in order of discovery.
An exception for when work is canceled in eclipse.
A filter defined by set membership
utilities for parsing a command line
A 2-level iterator.
An Iterator which provides a concatenation of two IntIterators.
An iterator which provides a logical concatenation of the lists from two other iterators
Iterative solver for a Killdall dataflow framework
A debugging factory that creates debugging bitsets that are implemented as two bitsets that perform consistency checks for every operation.
Default implementation of a fixed point solver.
Default implementation of a dataflow graph
A utility class.
An object that delegates edge management to the nodes, INodeWithNumberedEdges
Basic functionality for a graph that delegates node and edge management, and tracks node numbers
Basic implementation of a numbered graph -- this implementation relies on nodes that carry numbers and edges.
utilities related to depth-first search.
Extends DFSPathFinder to discover all paths from a set of root nodes to nodes passing some Predicate.
This class implements depth-first search over a NumberedGraph, return an enumeration of the nodes of the graph in order of increasing discover time.
This class implements depth-first search over a Graph, return an enumeration of the nodes of the graph in order of increasing finishing time.
This class searches depth-first search for node that matches some criteria.
An object that computes the dominance frontiers of a graph
Calculate dominators using Langauer and Tarjan's fastest algorithm.
utilities for interfacing with DOT
possible output formats for dot
View of a NumberedGraph in which some edges have been filtered out
An object which manages edges in a directed graph.
A singleton instance of an empty iterator; this is better than Collections.EMPTY_SET.iterator(), which allocates an iterator object;
 
A singleton instance of an empty iterator; this is better than Collections.EMPTY_SET.iterator(), which allocates an iterator object;
 
Factorial utilities
 
FIFO work queue management of Objects that prevents an object from being added to the queue if it is already enqueued and has not yet been popped.
FIFO work queue management of Objects that prevents an Object from being added to the queue if it was ever previously enqueued.
An object which represents a set of classes read from a text file.
Simple utilities for accessing files.
A FilterIterator filters an Iterator to generate a new one.
intersection of two filters
Constants used in the fixed-point solver framework
 
Floyd-Warshall algorithm to compute all-pairs shortest path in graph with no negative cycles.
 
 
Represents a single step in an iterative solver
Calculate dominators using Langauer and Tarjan's fastest algorithm.
Basic interface for a directed graph.
Utility class to check integrity of a graph data structure.
 
A graph view that reverses the edges in a graph
Simple graph printing utility
A dataflow system that computes, for each graph node, the set of "interesting" nodes that are reachable
Utilities related to simple graph subset operations.
Utility methods for graphs.
 
 
A debugging aid.
A debugging aid.
 
Simple Heap data structure.
Simple utility that uses reflection to trace memory
a relation R(x,y) where x >= 0
Solves a set of constraints
The general form of a statement definition in an iterative solver is: x >= term, where term can be any complex expression whose free variables are among the IVariables of the constraint system this IFixedPointStatementis part of (x represents the left-hand side of the constraint).
Represents a set of IFixedPointStatements to be solved by a IFixedPointSolver
A dataflow framework in the style of Kildall, POPL 73 This represents a dataflow problem induced over a graph.
An immutable stack of objects.
A filter that accepts everything.
TODO: Move this somewhere.
Basic interface for a node which lives in one graph ...
Basic interface for a node which lives in one graph ...
An implementation of Tarjan's union-find, using path compression and balancing, for non-negative integers
a more efficient iterator for sets of integers
An IntMapIterator maps an Iterator contents to produce a new Iterator
A pair of ints.
Set of integers; not necessary mutable TODO: extract a smaller interface?
 
Utilities for dealing with IntSets
A variable for dataflow analysis, representing a set of integers.
A stack of integer primitives.
interface for array of integer
A graph view that reverses the edges in a graph
A graph view that reverses the edges in a graph
An edge manager that reverses the edges in a graph
An edge manager that reverses the edges in a graph
Converts an Iterator to a Collection.
Converts an Iterator to an Iterable.
 
 
A utility to efficiently compose an iterator and a singleton
 
utilities dealing with Iterators
The DataflowSolver builds system over graphs, with dataflow transfer functions on the nodes, the edges or both.
Represents a single variable in a fixed-point iterative system.
simple interface for a vector.
 
A Java process launcher
An object which tracks labeled edges in a graph.
A graph with labeled edges.
Abstract base class for a process launcher
A stop watch that prints log messages.
simple utilities with logarithms
a more efficient iterator for sets of longs
Set of longs; not necessary mutable TODO: extract a smaller interface?
 
Utilities for dealing with LongSets
 
An MapIterator maps an Iterator contents to produce a new Iterator
utilities for managing Maps
Simple utilities for Eclipse progress monitors
Use this interface to decouple core utilities from the Eclipse layer
 
an implementation of IntVector that uses a mix of backing arrays of type int, char, and byte array, in an attempt to save space for common data structures.
An IntSet that can be changed.
An object that creates some flavor of mutable int set.
 
An object that creates some flavor of mutable int set.
A bit set mapping based on an object array.
The shared bit vector implementation described by [Heintze 1999] TODO: much optimization possible.
A factory for mutable shared bit vector int sets
A sparse ordered, mutable duplicate-free, fully-encapsulated set of integers.
An object that creates mutable sparse int sets.
A sparse ordered, mutable duplicate-free, fully-encapsulated set of longs.
An object that creates mutable sparse int sets.
 
An object which tracks graph nodes.
A node which carries it's own number; which identifies it in a NumberedGraph implementation.
Simple implementation of INodeWithNumberedEdges
A singleton iterator for an object which is guaranteed to be not-null.
An operator of the form lhs = op
Represents a single step, restricted to a nullary operator.
This class implements depth-first search over a NumberedGraph, return an enumeration of the nodes of the graph in order of increasing discover time.
This class implements depth-first search over a NumberedGraph, return an enumeration of the nodes of the graph in order of increasing discover time.
Calculate dominators using Langauer and Tarjan's fastest algorithm.
Additional functionality for edges in numbered graphs
A numbered graph is a Graph where each node has a unique persistent non-negative integer id.
 
 
 
An object which tracks nodes with numbers.
 
A bit set mapping based on an immutable object array.
 
 
An ordinal set mapping, backed a delegate, but adding an offset to each index.
 
A Set backed by a set of integers.
An object that implements a bijection between whole numbers and objects.
 
a debugging aid.
a debugging aid.
We represent a path in a numbered graph as a vector of integers <i_1, ..., i_n> where node i_1 is the src and node i_n is the sink
Platform-specific utility functions.
Misc SQL-like support for queries on tables
An iterator that reverses an input iterator.
 
This class computes strongly connected components for a Graph (or a subset of it).
 
 
 
 
Logically, a set of Class.
simple implementation of IntVector
simple implementation of IVector
This class implements depth-first search over a Graph, return an enumeration of the nodes of the graph in order of increasing discover time.
This class implements depth-first search over a Graph, return an enumeration of the nodes of the graph in order of increasing finishing time.
An object which manages node numbers via a mapping.
A graph of numbered nodes, expected to have a fairly sparse edge structure.
A labeled graph implementation suitable for sparse graphs.
A simple implementation of Map; intended for Maps with few elements.
A sparse ordered, duplicate-free, fully-encapsulated set of integers; not necessary mutable
an int vector implementation designed for low occupancy.
an int vector implementation designed for low occupancy.
A sparse ordered, duplicate-free, fully-encapsulated set of longs; not necessary mutable
An object which tracks edges for nodes that have numbers.
A graph of numbered nodes, expected to have a fairly sparse edge structure.
 
An IVector implementation designed for low occupancy.
Basic class to time events
A Stopwatch that also queries the free memory from the GC.
utilities for IO streams
 
 
 
Utilities for iterating over graphs in topological order.
A comparator based on lexicographical ordering of toString()
Operator U(n) = true
A MutableSparseIntSet that allows for tuning of its initial size and expansion factor.
a simple implementation of int vector that can be tuned to control space usage
an int vector implementation which delegates to pages of int vectors.
An IVector implementation which delegates to pages of int vectors.
Operator U(n) = U(n) U U(j)
An operator of the form lhs = op (rhs)
Operator U(n) = U(n) | U(j)
Represents a single step, restricted to a unary operator.
Something that's not implemented yet.
Miscellaneous utility functions.
An optional interface for data structures that provide a verbose option for debugging purposes.
An exception to raise for some WALA failure
Runtime exception for some WALA failure.
 
 
Worklist for fixed-point solver implementation