|
Evaluating Software Design Patterns — the "Gang of Four" patterns implemented in Java 6 |
||||||||
| PREV LETTER NEXT LETTER | FRAMES NO FRAMES | ||||||||
Character interface.CompositeSequence interface.expression.ExpressionBuilder interface, while
ensuring that the constructed terminal
expressions will all manipulate the same sequence
instance.HandlerChain interface.abstractions.Log implementation.Sequence interface.reset this sequence
and then initialise the internal state to Sequence.State.START.
reset this sequence
if reset is true and then initialises the internal
state to Sequence.State.START.
stateable sequence.value and
type visitable.type visitor supplied
as visitor.
value visitor supplied
as visitor.
AckermannSequence.next() is invoked, using a fixed value for
m and thus increasing n, either indefinitely, or until a maximum
value has been reached.m.
m.
internalState, the following forms of actions are
inferred:
Sequence.State.START: initialisation requested.
internalState
for the reversible prime sequence supplied as sequence.
value from type E
to T.
SequenceAdapter
objects into char sequences (not part of the core Adapter
implementation).S can be represented as type T.E into type T.
SequenceAdapter instances.expression to
this flow expression.
elements, in order, to the list
supplied as list.
elements, in order, to the set
supplied as set.
name and birthday,
respectively, with this registry.
name and birthday,
respectively, with this registry.
command supplied
as command to this composite command, if
not already.
observer to this observable for
the aspect supplied as aspect, if not already.
observer to this observable,
if not already.
observer to this
manager, associated with the methods annotated in the class
of object with a context type
the owner type of this manager is
assignable to, if any.
observer to this
manager, associated with the methods annotated in the class
supplied as clazz with a context type
the owner type of this manager is
assignable to, if any.
referenced object.
sequence supplied
as sequence to this composite sequence, if
not already.
Boolean value.observable sequence
that uses the Executor annotation to identify notification
methods for observers that accepts a Sequence type as the
first argument and a Sequence.State
type as the second.Sequence to become an observable
sequence that uses the Executor annotation to identify notification
methods for observers that accepts a Sequence type as the
first argument and a Sequence.State
type as the second.Object.
Object or wild-card representation
to a String representation by invoking toString()
on the object.
Appendable object as
the target for log messages, for example a PrintStream
such as System.out.active
is true.
sequence.
array.
type represented
by this type literal as a class literal if and only if the
type has a raw type.
clazz
as the type represented by this type
literal, if possible.
O to subscribe to specific sequence aspect values and
be notified when the sequence changes its aspect to such a
value.value wrapped in the non-primitive
type corresponding to the (primitive) type supplied as type.
value wrapped in the non-primitive
type stored in in primitive.
value to the
variable expression supplied
as expression.
variable.object as a string.
(x && y) if short-circuit, or (x & y),
where x is the symbolic representation of the
first expression operand and y of the second.
x = y, where x is the symbolic
representation of the first expression operand and y
of the the second.
x separator y, where x is the symbolic
representation of the first expression operand and y
of the the second.
x separator y, where x is the symbolic
representation of the first expression operand and y
of the the second.
exit or break[x], where
x is the symbol representation of the target expression
used, if any.
x operator y, where x is the symbolic
representation of the first expression operand, y
of the the second, and operator is the operator used
for the comparison.
x, where x is the value of
this constant, or if type information is included,
Type{x}, where Type is the simple
name of the type.
x == y, where x is the symbolic
representation of the first expression operand and y
of the the second.
Expression.asSymbol(Context).
Expression.asSymbol(Context).
x, y, z, .., where x, y,
z, .., are the symbol representations of the
contained expressions.
next[x], where x is the symbolic
representation of the expression that will determine the
number of times to invoke next(), or next#123[x],
where 123 is the identity hash code of the manipulated
sequence.
(x || y) if short-circuit, or (x | y),
where x is the symbolic representation of the
first expression operand and y of the second.
reverse[x], where x is the symbolic
representation of the expression used to determine if the
sequence should be reversed, or reverse#123[x],
where 123 is the identity hash code of the
manipulated sequence.
name, where name is the
actual name of this expression, or
name#123, where 123 is the identity
hash code of the manipulated sequence.
set[x], where x is the symbolic
representation of the expression that will determine the
value, or set#123[x], where 123 is the
identity hash code of the manipulated sequence.
x, where x is the symbolic
representation of the decorated expression, or if type information
is included, Type{x}, where Type is the simple
name of the type.
x, where x is the name of
this variable, or if type information is included,
Type{x}, where Type is the simple
name of the type.
typeLiteral as the type
represented by this type literal, T instead of
S, if possible.
|
Gunni Rode / rode.dk | ||||||||
| PREV LETTER NEXT LETTER | FRAMES NO FRAMES | ||||||||