|
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 |