Evaluating Software Design Patterns
— the "Gang of Four" patterns implemented in Java 6

Uses of Class
dk.rode.thesis.meta.ParticipantUsage

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
<E> Sequence<E>
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.
<E> Sequence<E>
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.
<E> Sequence<E>
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.
<E> Sequence<E>
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.
<E,T extends Sequence<E>>
T
SequenceProxyFactory.getVirtualSequence(InstantiableTypeLiteral<T> type, Object... arguments)
          Creates a virtual sequence based on the sequence type T.
 


Gunni Rode / rode.dk

Feel free to use and/or modify the Java 6 source code developed for this thesis AT YOUR OWN RISK, but note that the source code comes WITHOUT ANY — and I do mean WITHOUT ANY — form of warranty WHAT SO EVER!

The original thesis and source code are available at rode.dk/thesis.