|
Evaluating Software Design Patterns — the "Gang of Four" patterns implemented in Java 6 |
||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use ParticipantUsage | |
---|---|
dk.rode.thesis.abstractfactory | Implementations and examples of the Abstract Factory design pattern [Gamma95, p.87]. |
dk.rode.thesis.adapter | Implementations and examples of the Adapter design pattern [Gamma95, p.139]. |
dk.rode.thesis.builder | Implementations and examples of the Builder design pattern [Gamma95, p.97]. |
dk.rode.thesis.composite | Implementations and examples of the Composite design pattern [Gamma95, p.163]. |
dk.rode.thesis.decorator | Implementations and examples of the Decorator design pattern [Gamma95, p.175]. |
dk.rode.thesis.facade | Implementations and examples of the Facade design pattern [Gamma95, p.185]. |
dk.rode.thesis.iterator | Implementations and examples of the Iterator design pattern [Gamma95, p.257]. |
dk.rode.thesis.observer | Implementations and examples of the Observer design pattern [Gamma95, p.293]. |
dk.rode.thesis.proxy | Implementations and examples of the Proxy design pattern [Gamma95, p.207]. |
Uses of ParticipantUsage in dk.rode.thesis.abstractfactory |
---|
Classes in dk.rode.thesis.abstractfactory with annotations of type ParticipantUsage | |
---|---|
interface |
AbstractionFactory<E>
A sequence abstraction factory can create sequence abstractions . |
class |
CollectionValueFactory<E extends Serializable>
A collection value factory creates specific SequenceValueCollection
objects based on the supplied type of collection to the creation method. |
interface |
GeneratorFactory<E,P>
A generator factory can create sequence value generators used as implementations
for sequence abstractions . |
class |
MemorizableAbstractionFactory<E>
A memorizable abstraction factory creates memorizable sequence
abstractions. |
class |
PrototypicalAbstractionFactory<E>
A prototypical abstraction factory creates sequence abstractions based on
a prototype supplied at construction time. |
class |
PrototypicalFactory<T extends StrictCopyable<T>>
A prototypical factory creates instances of a specific type of copyable type based on a prototype supplied at
construction time. |
class |
PrototypicalRegistry
A prototypical registry creates instances of copyable objects based on
registered
prototypes. |
class |
PrototypicalSequenceFactory<E>
A prototypical sequence factory creates sequences
based on a prototype supplied at construction time. |
class |
RangeValueFactory
A range value factory creates value range
generators. |
class |
StandardAbstractionFactory<E>
A standard abstraction factory creates sequence abstractions. |
class |
SynchronisedAbstractionFactory<E>
A synchronised abstraction factory creates synchronised sequence
abstractions. |
Uses of ParticipantUsage in dk.rode.thesis.adapter |
---|
Classes in dk.rode.thesis.adapter with annotations of type ParticipantUsage | |
---|---|
class |
IteratorSequence<E>
An object adapter that adapts a Sequence type
to conform to the Iterator type: when the iterator is
advanced, so is the sequence - hence the adaptation. |
class |
SequenceAdapter<E,T>
The sequence adapter acts as a generic type adapter for sequence parameterised types, i.e. from Sequence<E> to
Sequence<T> , by using an adapter delegate
to perform the representation shift. |
Uses of ParticipantUsage in dk.rode.thesis.builder |
---|
Classes in dk.rode.thesis.builder with annotations of type ParticipantUsage | |
---|---|
interface |
ComparableExpressionBuilder<E extends Comparable<? super E>>
A comparable expression builder construct various Expression
types having a Comparable bound on the value produced by
the constructed expressions and/or on the expression operands used. |
interface |
ExpressionBuilder<E>
An expression builder construct various Expression
types having no bounds on the values produced by the
constructed expressions. |
Uses of ParticipantUsage in dk.rode.thesis.composite |
---|
Classes in dk.rode.thesis.composite with annotations of type ParticipantUsage | |
---|---|
interface |
CompositeSequence<E>
A composite sequence is a sequence that represents an number of other contained sequences, possibly composite as well. |
Uses of ParticipantUsage in dk.rode.thesis.decorator |
---|
Classes in dk.rode.thesis.decorator with annotations of type ParticipantUsage | |
---|---|
class |
SequenceDecorator<E>
A sequence decorator is a decorator that forwards all request to the decorated Sequence without performing
additional operations except for toString() . |
Uses of ParticipantUsage in dk.rode.thesis.facade |
---|
Fields in dk.rode.thesis.facade with annotations of type ParticipantUsage | |
---|---|
private ReversiblePrimeSequence |
MathFacade.primes
The prime sequence to deliver the prime numbers. |
Uses of ParticipantUsage in dk.rode.thesis.iterator |
---|
Classes in dk.rode.thesis.iterator with annotations of type ParticipantUsage | |
---|---|
class |
IterableSequence<E>
An iterable sequence is a bounded sequence that can be accessed as any
other iterable object. |
class |
SequenceIterator<E>
A sequence iterator is an external iterator that can iterate over bounded sequences . |
Uses of ParticipantUsage in dk.rode.thesis.observer |
---|
Classes in dk.rode.thesis.observer with annotations of type ParticipantUsage | |
---|---|
class |
ObserverManager
An observer manager is a stand-alone manager storing any type of observer that will be notified with methods declared in its class that are annotated with a matching Executor annotation. |
Uses of ParticipantUsage in dk.rode.thesis.proxy |
---|
Classes in dk.rode.thesis.proxy with annotations of type ParticipantUsage | |
---|---|
class |
ImmutableSequence<E>
An immutable sequence ensures that invocations of NonResettableSequence.reset() , ImmutableSequence.next() , and ImmutableSequence.copy() are ignored
for the proxied sequence if and only if
the proxied sequence is accessed through the proxy only. |
class |
NonResettableSequence<E>
A non-resettable sequence ensures that invocations of NonResettableSequence.reset() are ignored for the proxied sequence
if and only if the proxied sequence is accessed through
the proxy only. |
class |
SynchronisedSequence<E>
A synchronised sequence ensures thread-safe access to a proxied sequence if and only if the proxied
sequence is accessed through the proxy only. |
Methods in dk.rode.thesis.proxy with annotations of type ParticipantUsage | ||
---|---|---|
|
SequenceProxyFactory.getImmutableSequence(Sequence<E> sequence)
Returns a sequence proxy implementing all interfaces sequence
implements that will disallow Sequence.reset() ,
Sequence.next() , and Sequence.copy() to alter
sequence if and only if all access is though the
returned proxy. |
|
|
SequenceProxyFactory.getLoggableSequence(Sequence<E> sequence)
Returns a sequence proxy implementing all interfaces sequence
implements that will log all access to sequence
if and only if all access is though the returned proxy. |
|
|
SequenceProxyFactory.getNonResettableSequence(Sequence<E> sequence)
Returns a sequence proxy implementing all interfaces sequence
implements that will disallow Sequence.reset() to be invoked
for sequence if and only if all access is though the
returned proxy. |
|
|
SequenceProxyFactory.getSynchronisedSequence(Sequence<E> sequence)
Returns a sequence proxy implementing all interfaces sequence
implements that will ensure synchronised access to sequence
if and only if all access is though the returned proxy. |
|
|
SequenceProxyFactory.getVirtualSequence(InstantiableTypeLiteral<T> type,
Object... arguments)
Creates a virtual sequence based on the sequence
type T . |
|
Gunni Rode / rode.dk | ||||||||
PREV NEXT | FRAMES NO FRAMES |