|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
Action is a wrapper for a void returning
method.t.
ActionPredicate.actionPredicate(T) only for its
side-effects, ignoring its result.
ActionPredicate is a combination of an
Action and a Predicate.elem to this set.
<key, value> to the relation.
this ternary
relation.
elem to this
workset.
coll to
this set.
key in relation to each element of the
collection values.
elems to this
workset.
Relation.addAll(K, java.util.Collection) except that the type of the
collection values allows more flexibility.
ct is included in the set s".
s1 and s2 should be
equal.
WorkSetAbstr.addToOrder(T).
UnionFind structure has knowledge about.
Concat.
Union.
e1 and
e2 are unified in this union-find structure.
ArrayIterator is a read-only iterator over an array of
elements.ArrayIterator.
ArraySet is an immutable, array-backed set.ArraySet containing the elements
present in the set set.
ArraySet containing the distinct
elements from the colection coll.
ArraySet with the elements given as a
variable-length list of arguments (instead of a collection).
ArraySet containing the distinct elements present
in the colection coll.
Constraint.cost()
BasicBlock is a straight-line sequence of
vertices.BasicBlockDiGraph is a basic block representation of
a directed graph.BasicBlockDiGraph representation for
diGraph.
BiDiNavigator interface allows graph algorithms to
detect (and use) the arcs from and to a certain vertex.BijMapBijMap.
BinTreeNavigator models the arcs of a binary tree.BinTreeUtil is a wrapper for binary tree utilities.BoolMCell is a mutable cell with boolean content.BoolMCell with initial value
initValue.
CachedFunction is a caching wrapper around a (presumably pure) function.func.
obj1 is null, and next invokes
equals.
this association
map.
this set.
this relation.
this ternary
relation.
CollectionFactory is a collection-specific instance of
the factory pattern.Constraint models a constraint between several
variables.ConstraintSystem is an efficient solver for a system
of constraints.ConstraintSystem.
getForwardNavigator.
elem belongs to
this set.
<key,value>.
this ternary relation.
this workset contains the element
e.node belongs to this \
strongly connected component.
key
and every element from values.
this association map contains any
association for the key key.
key key in this relation.
s.
x.
this constraint.
HIGH_COST.
HIGH_COST.
T.
T, as a copy of
t.
create() to create
an empty map, and next adds each entry from m to
the newly-created map.
RelationFactory.create() to create an
empty relation, and next add each pair from r to
the new relation.
SetFactory.newColl(Collection).
NFA.
NFA.
jpaul project.
CtConstraint models a constraint of the form
"constant ct is less than the value of the
variable vd".LtConstraint with default cost Constraint.VERY_LOW_COST.
CtConstraint with the meaning "the
constant ct is smaller than the value of the
variable vd."
CtDiffConstraint models a "difference with a constant set" constraint.CtDiffConstraint with the meaning
vIn \ ctSet <= vDest.
Debug contains some simple debugging methods.System.out).
this digraph.
dfs.
DiGraph models a directed graph.DiGraph with no caching (the safest
choice).
DiGraph.
DiGraph object.
DiGraph object.
DSUtil is a wrapper for commonly used data-structure
utilities.BijMap.
this strongly
connected component.
EqualityPredicate is a simple predicate that checks
equality with a reference element.EqualityPredicate.
this Comparator.
e is
part of, as an unmodifiable set containing all elements from
that class (including e).
this strongly
connected component.
this workset
(according to the order specific to this workset.
TRes and returns a TArg.
Factory for the factory pattern.newColl all elements of coll
that satisfy the predicate pred.
FilterConstraint models a filtering constraint.FilterConstraint with the meaning
vIn | pred <= vDest.
e.
<key,value> of
this relation and calls
visitor.visit on each of them.
this directed graph.
ForwardNavigator is a forward-only graph navigator:
given a vertex, it returns its successors in the graph.ActionPredicate whose
actionPredicate method first invokes the action
from action and next returns the constant boolean
value predicateResult.
ActionPredicate wrapper around a
Predicate: it does not perform any side-effect,
it just returns the boolean value of teh predicate.
Function is a wrapper around a function that takes a
TArg and returns a TRes.key in
this association map, or null if no
such value exists.
ith element from the end of the
original list.
this ternary
relation and has a in its 1st position.
this ternary relation.
this
digraph.
this graph.
this digraph.
this SCComponent.
this ternary relation.
LabeledDiGraph.
LabeledDiGraph.
key, if any.
this directed graph.
LabeledDiGraph).
key through this relation.
GraphUtil is a wrapper for various graph utilities.LinkedHashMaps.
LinkedHashSets.
Constraint.cost()
IdentityWrapper is useful when you want to assign some
information to each object, not to each class of equal objects.IdentityWrapper.
IdFunction - identity functionImmutableCompoundIterable allows the construction of an
IMMUTABLE Iterable by merging several smaller
Iterables.ImmutableCompoundIterable.
InterruptTraversalException is a special exception for
prematurely terminating the traversal of a data structure.InterruptTraversalException.
InterruptTraversalException with a
certain message.
IntersectConstraint models a set intersection constraint.IntersectConstraint with the meaning
vIn1 /\ vIn2 <= vDest.
IntMCell is a mutable cell with integer content.IntMCell with initial content
0.
IntMCell with initial content
initValue.
this association map is empty.
this set is empty.
this workset is empty.this relation maps each key to a
single value.
this strongly connected component
corresponds to a loop, ie it has at least one arc to
itself.
Collection view of an
Iterable.
itrbl contains the element
elem.
Iterable.
itrbl has exactly
k elements.
itrbl has more than
k elements.
s2 to
s1.
v by
joining delta to it.
this variable
takes values from.
this relation.
LabeledDiGraph models a labeled directed graph.LabeledDiGraph.
LabeledDiGraph.
node, if any, or
null otherwise.
v.
jpaul project.
LongMCell is a mutable cell with long content.LongMCell.
LongMCell with initial content
initValue.
Constraint.cost()
v.
LtConstraint models a "less than"
constraint: the value of variable vs is smaller than
the value of variable vd, according to the order
relation from the corresponding lattice.LtConstraint with default cost Constraint.LOW_COST.
LtConstraint with the meaning
"value of variable vs is smaller than the
value of the variable vd."
jpaul release.
Function based on a map.
coll into a new collection
(stored in newColl), according to the function
func.
mapColl method, but the
function is given as a map.
mapColl, but filters out all
null elements produced by func.
MapFactory is a map-specific instance of the factory
pattern.MapFacts contains several common map factories.MapFacts.hash() instead.MapFacts.tree(Comparator) instead.TreeMapFactory.
Relations interface backed by a
LinkedHashMap from keys to
LinkedHashSets of values.
Relations interface backed by a Map
from keys to Sets of values.
MapSetRelation is an implementation of the
Relation interface based on a Map from
keys to Sets of values.Relation represented using a
LinkedHashMap from keys to
LinkedHashSets of values.
Relation represented by a
Map from keys to Sets of values.
MapWithDefault is a map that returns default values
for unassigned keys.MapWithDefault, backed by a
LinkedHashMap.
MapWithDefault.
MapWrapper is a map backed by another map.MapWrapper.
MCell is a mutable cell with content of type
T.MutableCell.
c.
Factory.create().
create() to create
an empty set, and next adds all elements from
coll to the newly-created set.
vertex.
this SCC points to in the
component digraph.
NFA models a Non-deterministic Finite Automaton.NFA.
NFA transformations (ex: NFA.simplify()) produce NFAs whose states are sets of
original states.NoCompTreeMap.
NoCompTreeMaps.
NoCompTreeMap is tree map that does not require any
used-defined Comparator.NoCompTreeMap.
NoCompTreeMap with the same mappings as the
given map.
NonIterableMap is a very simple association map that
CANNOT be traversed.NonIterableMap backed by a private
HashMap with the default initial capacity.
NonIterableMap backed by a private
HashMap of a certain initial capacity.
NonIterableSet is a very simple set that CANNOT be
traversed.NonIterableSet backed by a private
HashSet with the default initial capacity.
NonIterableSet backed by a private
HashSet of a certain initial capacity.
this directed
graph.
this directed
graph.
Pair is an immutable pair of two values.Predicate wraps a boolean predicate.vertex.
this SCC in the
component digraph.
key with the value
value in this association map.
RegExp models a regular expression.Atomic regular expression that
matches only the 1-length string consisting of the symbol
a.
Concat regular expression that
matches any string of As consisting of a
string matched by left followed by a string
matched by right.
RegExp that matches any string that
is obtained by the concatenation of a finite number of
strings (possibly none), each matched by the regular
expression regExp.
Union regular expression that
matches any string that is matched by (at least one of)
left and right.
RegExps.Relation is a binary relation, accepting one to many
and many to one mappings.Relation.EntryVisitor is a wrapper for a function
that is called on a relation entry of the form
<key,value>.Relation3 models a simple ternary relation.Relation3MapRelImpl is a simple implementation of
Relation3, backed by a Map from
Ta keys to RelationTb,Tc between
Tb and Tc.Relation3MapRelImpl.
Relation3MapRelImpl object using a
factory of LinkedHashMaps and a factory of
MapSetRelations.
RelationFactory is a relation-specific instance of the
factory pattern.jpaul library.
RelFacts contains common relation factories.RelFacts.cow(RelationFactory) instead.COWRelationFactory.
RelFacts.mapSet() or RelFacts.mapSet(MapFactory,SetFactory) instead.MapSetRelationFactory that generates
relations whose representation uses
LinkedHashMaps and LinkedHashSets.
MapSetRelationFactory that
generates relations whose representation uses maps
generated by mapFact and sets generated by
setFact.
key.
key.
elem from this
set.
key and
value.
this ternary
relation.
key and
any element from values.
key.
predicate.check().
predicate.check().
BijMap.
this directed graph: a
directed graph with the same set of vertices, that contains an
arc from v1 to v2 iff
this graph contains an arc from v2
to v1.
ReverseListIterator takes a List and
produces a ListIterator that traverses the list in
reverse order.ReverseListIterator.
ReverseViewList is an immutable, reverse view of a
List.origList.
this
relation.
this relation and store the result into
the relation result.
this constraint by replacing each
variable with the representative of its equivalence class.
CtDiffConstraint.rewrite(jpaul.DataStructs.UnionFind>) , CtDiffConstraint.equals(java.lang.Object), and CtDiffConstraint.hashCode, such that constraints that are identical after
variable unification are not duplicated needlessly.
IntersectConstraint.rewrite(jpaul.DataStructs.UnionFind>) , IntersectConstraint.equals(java.lang.Object), and IntersectConstraint.hashCode, such that constraints that are identical after
variable unification are not duplicated needlessly.
node, if any, or
null otherwise.
SCComponent models a strongly-connected
component of a directed graph: a set of vertices such that
there is a path between any two of them.SetConstraints is a collection of set constraints.SetFactory is a set-instance of the factory pattern.SetFacts contains common set factories.SetFacts.cow(SetFactory) instead.COWSetFactory.
SetFacts.hash() instead.SetFacts.tree(Comparator) instead.TreeSetFactory.
SetMembership is a predicate that checks whether an
element is member of a specific set.SetMembership that checks membership in
the set set.
NFA that accepts the same
strings as this NFA.
this relation.
this ternary relation.
this workset.isEmpty() iff size() ==
0.this strongly connected
component.
SolAccessor provides access to the values of the
variables from a system of constraints.SolReader provides read-only access to the (possibly
partial) solution of a system of constraints.this system of constraints.
this directed graph
containing only the vertices from verts.
SVar is a variable whose values are sets of Ts.SVar.
SVar using a HashSet
factory (SetFacts.hash)
rel.
TopSortedCompDiGraph is a topologically-sorted
component digraph.digraph.
A,
representing all strings accepted by this NFA.
this variable.
"null" if the argument o is
null, and o.toString() otherwise.
this DiGraph.
this BoolMCell:
"BoolMCell{" + value + "}@" +
System.identityHashCode(this).
this IntMCell:
"IntMCell{" + value + "}@" +
System.identityHashCode(this).
this LongMCell:
"LongMCell{" + value + "}@" +
System.identityHashCode(this).
this MCell:
"MCell{" + value + "}@" +
System.identityHashCode(this).
TreeMaps.
TreeSets.
UComp is an universal comparator, which compares any two
objecs by simply comparing their string representation.this relation with relation
rel.
e1 and e2 and
returns the representative of the resulting equivalence class.
UnionFind is a datastructure for performing
unification and lookup operations.UnionFind.
ForwardNavigator.
Iterable that is the union
of two Iterables.
Iterable that is the union
of several Iterables (in the order thet are given
in its).
List that is the union of
two lists: it contains first the elements from
l1, and next the elements from
l2.
BiDiNavigator.
Iterable into an unmodifiable
one.
Iterator into an unmodifiable
one.
rel.
e has not been
unified yet with any DIFFERENT element.
BijMap.
this relation.
Var models a variable from a system of constraints.VerboseWorkSet - Debugging wrapper for a
WorkSet.VerboseWorkSet.
Version contains fields naming the current
jpaul version.this
digraph: vertices that are (trasitively and reflexively)
reachable from the root vertices by following the forward arcs
provided by the navigator.
this strongly connected
component.
Constraint.cost()
<key,value> entry of a
relation.
None regular expression.
Atomic regular expression.
EmptyStr regular expression.
Union regular expression.
Concat regular expression.
Star regular expression.
WorkList is a WorkSet with FIFO order.WorkPriorityQueue is a WorkSet whose
elements are extracted in the increasing order of their priorities.WorkPriorityQueue.
WorkQueueWorkQueue.
WorkSet is an ordered set-like data structure.WorkStack is a WorkSet with LIFO order.Relation or its subclasses.
hashCode.
|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||