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

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

Packages that use Participant
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.bridge Implementations and examples of the Bridge design pattern [Gamma95, p.151]. 
dk.rode.thesis.builder Implementations and examples of the Builder design pattern [Gamma95, p.97]. 
dk.rode.thesis.chainofresponsibility Implementations and examples of the Chain of Responsibility design pattern [Gamma95, p.223]. 
dk.rode.thesis.command Implementations and examples of the Command design pattern [Gamma95, p.233]. 
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.factorymethod Implementations and examples of the Factory Method design pattern [Gamma95, p.107]. 
dk.rode.thesis.flyweight Implementations and examples of the Flyweight design pattern [Gamma95, p.195]. 
dk.rode.thesis.interpreter Implementations and examples of the Interpreter design pattern [Gamma95, p.243]. 
dk.rode.thesis.iterator Implementations and examples of the Iterator design pattern [Gamma95, p.257]. 
dk.rode.thesis.memento Implementations and examples of the Memento design pattern [Gamma95, p.283]. 
dk.rode.thesis.observer Implementations and examples of the Observer design pattern [Gamma95, p.293]. 
dk.rode.thesis.prototype Implementations and examples of the Prototype design pattern [Gamma95, p.117]. 
dk.rode.thesis.proxy Implementations and examples of the Proxy design pattern [Gamma95, p.207]. 
dk.rode.thesis.singleton Implementations and examples of the Singleton design pattern [Gamma95, p.127]. 
dk.rode.thesis.state Implementations and examples of the State design pattern [Gamma95, p.305]. 
dk.rode.thesis.strategy Implementations and examples of the Strategy design pattern [Gamma95, p.315]. 
dk.rode.thesis.templatemethod Implementations and examples of the Template Method design pattern [Gamma95, p.325]. 
dk.rode.thesis.visitor Implementations and examples of the Visitor design pattern [Gamma95, p.331]. 
 

Uses of Participant in dk.rode.thesis.abstractfactory
 

Classes in dk.rode.thesis.abstractfactory with annotations of type Participant
 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 Main
          Abstract Factory tests.
 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.
 interface SequenceFactory<E,P>
          A sequence factory provides a general creation method to create initialised sequences in a single step.
 class StandardAbstractionFactory<E>
          A standard abstraction factory creates sequence abstractions.
 class StandardFactory<E,P>
          A standard factory can create sequence abstractions as well as the sequence value generators used as the implementations for the abstractions, and further more provides a convenient creation method to create sequences in a single step.
 class SynchronisedAbstractionFactory<E>
          A synchronised abstraction factory creates synchronised sequence abstractions.
 

Uses of Participant in dk.rode.thesis.adapter
 

Classes in dk.rode.thesis.adapter with annotations of type Participant
 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 Main
          Adapter tests.
 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.
 

Fields in dk.rode.thesis.adapter with annotations of type Participant
(package private)  Sequence<E> SequenceAdapter.sequence
          The original sequence handling type E.
 

Constructor parameters in dk.rode.thesis.adapter with annotations of type Participant
IteratorSequence(Sequence<E> sequence)
          Constructor, which creates this iterator sequence to iterate through the sequence value from sequence, starting from its current value.
SequenceAdapter(Sequence<E> sequence, AdapterDelegate<? super E,? extends T> adapterDelegate)
          Constructor.
 

Uses of Participant in dk.rode.thesis.bridge
 

Classes in dk.rode.thesis.bridge with annotations of type Participant
 class MemorizableSequenceAbstraction<E>
          A memorizable sequence abstraction refines a sequence abstraction so it can save and restore its internal implementation in form of mementos.
 class SequenceAbstraction<E>
          A sequence abstraction defers the creation of sequence values to a value generator.
 class SequenceValueArrayList<E extends Serializable>
          A sequence value array list stores sequence values in a java.util.ArrayList instance.
 class SequenceValueCollection<E extends Serializable,C extends Collection<E>>
          A sequence value collection is a finite collection of non-null sequence values that can be used as the implementation for a sequence abstraction.
 interface SequenceValueGenerator<E>
          A sequence value generator can be used as the implementation for a sequence abstraction as it generates non-null sequence values that can be delivered by the sequence in question.
 class SequenceValueHashSet<E extends Serializable>
          A sequence value hash set stores sequence values in a java.util.HashSet instance.
 class SequenceValueLinkedHashSet<E extends Serializable>
          A sequence value linked hash set stores sequence values in a java.util.LinkedHashSet instance.
 class SequenceValueRange
          A sequence value range generates unique Integer values within a given range determined at construction time.
 class SequenceValueSet<E extends Serializable,C extends Set<E>>
          A sequence value set stores sequence values in a specific java.util.Set implementation as specified by the type parameter C.
 class SequenceValueTreeSet<E extends Serializable>
          A sequence value tree set stores sequence values in a java.util.TreeSet instance.
 class SynchronisedSequenceAbstraction<E>
          A synchronised sequence abstraction refines a sequence abstraction by making it thread-safe.
 

Fields in dk.rode.thesis.bridge with annotations of type Participant
protected  SequenceValueGenerator<? extends E> SequenceAbstraction.generator
          The generator used to generate the next sequence value on an invocation of SequenceAbstraction.next().
 

Method parameters in dk.rode.thesis.bridge with annotations of type Participant
 SequenceAbstraction<E> SynchronisedSequenceAbstraction.setGenerator(SequenceValueGenerator<? extends E> generator)
           
 SequenceAbstraction<E> SequenceAbstraction.setGenerator(SequenceValueGenerator<? extends E> generator)
          Sets the generator to use for this sequence to generator.
 

Constructor parameters in dk.rode.thesis.bridge with annotations of type Participant
MemorizableSequenceAbstraction(SequenceValueGenerator<E> generator)
          Constructor, which creates this memorizable sequence abstraction to use the value generator supplied as generator.
SequenceAbstraction(SequenceValueGenerator<? extends E> generator)
          Constructor, which creates this sequence abstraction to use the value generator supplied as generator.
SynchronisedSequenceAbstraction(SequenceValueGenerator<? extends E> generator)
          Constructor, which creates this synchronised sequence abstraction to use the value generator supplied as generator.
 

Uses of Participant in dk.rode.thesis.builder
 

Classes in dk.rode.thesis.builder with annotations of type Participant
 class AbstractExpressionBuilder<E>
          An abstract expression builder implements the basic traits of the ExpressionBuilder interface, while ensuring that the constructed terminal expressions will all manipulate the same sequence instance.
 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.
 class CountingComparableExpressionBuilder<E extends Comparable<? super E>>
          A counting comparable expression builder performs the same functionality as a standard expression builder, but also registers the number of times each expression type is created based on expression names.
 class CountingExpressionBuilder<E>
          A counting expression builder performs the same functionality as a standard expression builder, but also registers the number of times each expression type is created based on expression names.
 interface ExpressionBuilder<E>
          An expression builder construct various Expression types having no bounds on the values produced by the constructed expressions.
 class Main
          Builder tests.
 class StandardComparableExpressionBuilder<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 on the expression operands used.
 class StandardExpressionBuilder<E>
          A standard expression builder construct various Expression types having no bounds on the values produced by constructed expressions.
 class TypedComparableExpressionBuilder<E extends Comparable<? super E>>
          A typed comparable expression builder construct various TypedExpression types having a Comparable bound on the value produced by the constructed expressions and on the expression operands used.
 class TypedExpressionBuilder<E>
          A typed expression builder builds typed expressions.
 

Uses of Participant in dk.rode.thesis.chainofresponsibility
 

Classes in dk.rode.thesis.chainofresponsibility with annotations of type Participant
 class CharacterHandler
          An abstract character handler implements the basic traits of handlers handling Character objects.
 interface Handler<R>
          A handler can handle a given type of request by taking appropriate action or by forwarding the request to the next handler in the current chain of handlers.
 class LetterCaseHandler
          A letter case handler is a handler that can handle letter characters in either upper or lower case only.
 class LetterHandler
          A letter handler is a handler that can handle letter characters.
 class Main
          Chain of Responsibility tests.
 class SymbolHandler
          A symbol handler is a handler that can handle symbol characters.
 class WhitespaceHandler
          A whitespace handler is a handler that can handle whitespace characters.
 

Uses of Participant in dk.rode.thesis.command
 

Classes in dk.rode.thesis.command with annotations of type Participant
 interface Command<E>
          A command represents a possibly undoable operation on a given receiver.
 class CommandProcessor
          A command processor can execute and possibly undo a given group of commands.
 class CompositeCommand<E>
          A composite command is a command that represents an number of other contained commands, possibly composite as well, thus forming a tree-like structure.
 class EvilCommand<E>
          An evil command is a test command that will always fail during execution and perhaps on undo as well by specifying that it is undoable while in reality it is not.
 class LogCommand<E>
          A log command simply logs the operation performed on the receiver object.
 class Main
          Command tests.
 class NextCommand<E>
          A next command command will invoke next() on its receiving sequence when it is executed.
 class NullCommand<E>
          A null command performs no operation on execute or on undo, is always considered undoable, and carries no state.
 class ResetCommand<E>
          A reset command command will invoke reset() on its receiving sequence when it is executed.
 class ReverseCommand<E>
          A reserve command command will reverse a given sequence when it is executed, if possible.
 class SequenceCommand<E>
          A sequence command is a command that manipulates the state of a sequence when it is executed.
 

Fields in dk.rode.thesis.command with annotations of type Participant
private  Object LogCommand.receiver
          The receiver object.
protected  Sequence<E> SequenceCommand.sequence
          The sequence receiver used by this command.
 

Constructor parameters in dk.rode.thesis.command with annotations of type Participant
LogCommand(Object receiver)
          Constructor.
NextCommand(Sequence<E> sequence)
          Constructor.
ResetCommand(Sequence<E> sequence)
          Constructor.
ReverseCommand(Sequence<E> sequence)
          Constructor.
ReverseCommand(Sequence<E> sequence, Command<E>... commands)
          Constructor.
SequenceCommand(Sequence<E> sequence)
          Constructor, which creates this sequence command to use the Sequence supplied as sequence as the receiver.
 

Uses of Participant in dk.rode.thesis.composite
 

Classes in dk.rode.thesis.composite with annotations of type Participant
 class AbstractCompositeSequence<E>
          An abstract composite sequence implements the basic traits of the CompositeSequence interface.
 class CharSequenceCompositeSequence
          A char-sequence composite sequence is a composite sequence parameterised with the CharSequence type.
 interface CompositeSequence<E>
          A composite sequence is a sequence that represents an number of other contained sequences, possibly composite as well.
 class Main
          Composite tests.
 

Uses of Participant in dk.rode.thesis.decorator
 

Classes in dk.rode.thesis.decorator with annotations of type Participant
 class AppenderDecorator
          An appender decorator returns the String value from a decorated sequence prefixed and/or postfixed with values supplied at construction time, respectively.
 class DuplexDecorator
          A duplex sequence decorator returns the String value returned by the decorated sequence concatenated with the same value, for example x -> xx.
 class SequenceDecorator<E>
          A sequence decorator is a decorator that forwards all request to the decorated Sequence without performing additional operations except for toString().
 class UppercaseDecorator
          An upper-case sequence decorator returns the string value returned by the decorated sequence in upper-case, for example a -> A.
 

Constructor parameters in dk.rode.thesis.decorator with annotations of type Participant
AppenderDecorator(Sequence<String> sequence, CharSequence prefix, CharSequence postfix)
          Constructor.
DuplexDecorator(Sequence<String> sequence)
          Constructor.
SequenceDecorator(Sequence<E> sequence)
          Constructor, which creates this decorator to decorate the Sequence supplied as sequence.
SequenceDecorator(Sequence<E> sequence, StringablePolicy<Sequence<?>> policy)
          Constructor, which creates this decorator to decorate the Sequence supplied as sequence and use the default stringable policy supplied as policy.
UppercaseDecorator(Sequence<String> sequence)
          Constructor.
UppercaseDecorator(Sequence<String> sequence, boolean firstOnly)
          Constructor.
 

Uses of Participant in dk.rode.thesis.facade
 

Classes in dk.rode.thesis.facade with annotations of type Participant
(package private)  class AckermannSequence
          An Ackermann sequence calculates the next value of the Ackermann function, v = A(m, n), each time AckermannSequence.next() is invoked, using a fixed value for m and thus increasing n, either indefinitely, or until a maximum value has been reached.
 class FibonacciSequence
          A Fibonacci sequence represents an integer sequence, where each number delivered by FibonacciSequence.next() is the sum of the two preceding numbers, except one which is the initial value: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, ..
 class MathFacade
          A math facade is a small math library that represents an-easy-to-use high-level interface for complex mathematical functions.
 class RandomSequence
          A random sequence returns a pseudo integer random number with each call to RandomSequence.next() between [0, maximum], where maximum is supplied at construction time.
(package private)  class UnboundedRandomSequence
          An unbounded random sequence returns a pseudo integer random number with each call to UnboundedRandomSequence.next() with no upper bound.
 

Uses of Participant in dk.rode.thesis.factorymethod
 

Classes in dk.rode.thesis.factorymethod with annotations of type Participant
 class CommandCreator<E,T>
          A command creator creates commands to manipulate a given receiver sequence using the CommandCreator.getCommand(Sequence, Object) method.
 class EvilSequenceCommandCreator<E>
          An evil sequence command creator is a test creator that flips the functionality offered by the sequence command creator, and may decide to return a new evil command as a default command.
 class Factory<T>
          A generic factory that will create products of type T.
 class ReflectiveCommandCreator<E>
          A reflective command creator creates new commands based on type literals as tokens.
 class ReversibleSequenceCommandCreator<E>
          A reversible sequence command creator extends the sequence command creator to allow for the creation of reverse commands for reversible sequences.
 class SequenceCommandCreator<E>
          A standard command creator creates new commands based on sequence states as tokens.
 class TypedFactory<T,P>
          A generic factory that will create products of type T while only accepting constructor arguments of type P (for all arguments).
 

Uses of Participant in dk.rode.thesis.flyweight
 

Classes in dk.rode.thesis.flyweight with annotations of type Participant
 class AbstractCharacter
          An abstract character implements the basic traits of the Character interface.
 interface Character
          A character represents a letter, symbol, or whitespace in a Word.
 class CharacterFactory
          A character factory creates and manages Character, Word, and Sentence objects.
 class Letter
          A letter represents a single letter that is not a whitespace or contain symbolic characters.
 class Main
          Flyweight tests.
 class Sentence
          A sentence represents an ordered sequence of words making up that sentence.
 class Symbol
          A symbol represents a single symbol that is not a whitespace or a letter.
 interface Textual<T>
          A textual object represents a flyweight object that is a char sequence and comparable to its own type.
 class Whitespace
          A whitespace represents a single white space character.
 class Word
          A word represents an ordered sequence of characters making up that word.
 

Uses of Participant in dk.rode.thesis.interpreter
 

Classes in dk.rode.thesis.interpreter with annotations of type Participant
 class AndExpression
          A logical and expression for two expressions evaluating to a Boolean value.
 class BreakExpression<E>
          A break expression allows the interpretation of a given expression syntax-tree to break at the point of the break expression, and possibly continue the interpretation starting from a specified target expression.
 class ConditionalExpression<E>
          A conditional expression represents an if-then-else expression.
 class ConstantExpression<E>
          A constant expression represents an expression that can be assigned a constant value.
 class Context
          A context represents an evaluation context where variables (and constants) are stored during interpretation.
 class CurrentExpression<E>
          A current expression will invoke current() on a given sequence when evaluated.
 class EqualExpression
          An equal expression can determine if the result of evaluating two expressions is equal or not, regardless of types.
 interface Expression<E>
          An expression represents grammar rules in form or non terminal expressions and actual functionality in form of terminal expressions that will be enforced when the expression is evaluated.
 class FlowExpression<E>
          A flow expression represents one or more expressions to be evaluated in order, one at a time.
 class Main
          Interpreter tests.
 class NextExpression<E>
          A next expression will invoke next() a number of times on a given sequence when evaluated.
 class OrExpression
          A logical or expression for two expressions evaluating to a Boolean value.
 class ResetExpression<E>
          A reset expression will invoke reset() on a given sequence when evaluated.
 class ReverseExpression<E>
          A reverse expression will invoke reverse() on a given reversible sequence when evaluated, if so specified and only if possible.
 class SetExpression<E extends Comparable<? super E>>
          A set expression will fast-forward the value of a given bounded sequence to match a specific value, if possible.
 class VariableExpression<E>
          A variable expression represents an expression that can be assigned a given value, which will be stored in a given context supplied at evaluation time.
 

Uses of Participant in dk.rode.thesis.iterator
 

Classes in dk.rode.thesis.iterator with annotations of type Participant
 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 Participant in dk.rode.thesis.memento
 

Classes in dk.rode.thesis.memento with annotations of type Participant
 class Main
          Memento tests.
 class MemorizableEnglishAlphabetSequence
          A memorizable alphabet sequence for letters in the English alphabet, i.e.
 interface MemorizableSequence<E>
          A memorizable sequence can memorise its internal state at a given time and have it restored again later by using mementos.
 class RangeSequence
          A range sequence represents a positive Integer value that is increased with each call to RangeSequence.next(), which can be reversed to deliver previous values as well unless unbounded.
 class SequenceMemento<E>
          A sequence memento represents a snap-shot of a given sequence at the time the SequenceMemento.SequenceMemento(Sequence) constructor or the SequenceMemento.setSequence(Sequence) method was invoked.
 

Uses of Participant in dk.rode.thesis.observer
 

Classes in dk.rode.thesis.observer with annotations of type Participant
 class AnnotatedObserversSequence<E>
          An annotated observers sequence implements the basic traits of any 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.
 class AnnotatedObserversSequenceDecorator<E>
          An annotated observers sequence decorator decorates any 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.
 interface AspectObservable<O,A>
          An aspect observable object is an object that has a collection of associated observers to be notified in case the object changes its internal state, or aspect, and where the observers can subscribe certain aspects only.
 interface AspectObservableSequence<O,A,E>
          An aspect observable sequence is a sequence that allows for observers of the type supplied as the type parameter O to subscribe to specific sequence aspect values and be notified when the sequence changes its aspect to such a value.
 class BirthdayRegistry
          A birthday registry is a simple application that stores the name and date of birth of people registered to it.
 class CorrelatedSequenceObserver
          A correlated sequence observer correlates the behaviour of an observable sequence with another (perhaps observable) Sequence.
 class DateSequence
          An observable date sequence is a sequence that will advance an initial date by one day each time next() is invoked and then notify relevant observers of its state changes.
 interface Observable<O>
          An observable object is an object that has a collection of associated observers to be notified in case the object changes its internal state, or aspect.
 interface ObservableSequence<O,A,E>
          An observable sequence is a sequence that allows for observers of the type supplied as the type parameter O to be notified when the sequence changes its aspect.
 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.
 class PrintSequenceObserver
          A print sequence observer prints the state of any observable sequence it is observing.
 class ProbeSequenceObserver
          A probe sequence observer prints the internal attributes that has changed for a given sequence since the last time the observer was notified about that sequence, based on equality using equals(Object) (and hashCode()).
 interface SequenceObserver<A>
          A sequence observer is an object that is notified when the observable sequence it is attached to changes its aspect value.
 class SequenceObserversSequence<E,A>
          A sequence observers sequence implements the basic traits of any observable sequence that uses a sequence observer as the notification mechanism.
 class SequenceObserversSequenceDecorator<E,A>
          A sequence observers sequence decorator decorates any sequence to become an observable sequence that uses a sequence observer as the notification mechanism.
 

Method parameters in dk.rode.thesis.observer with annotations of type Participant
<T> boolean
ObserverManager.addObserver(Class<? extends T> clazz, T observer)
          Adds the observer supplied as 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.
 boolean Observable.addObserver(O observer)
          Adds the observer supplied as observer to this observable, if not already.
 boolean AspectObservable.addObserver(O observer, A aspect)
          Adds the observer supplied as observer to this observable for the aspect supplied as aspect, if not already.
 boolean ObserverManager.addObserver(Object observer)
          Adds the observer supplied as 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.
 boolean AnnotatedObserversSequence.addObserver(Object object)
           
 boolean SequenceObserversSequence.addObserver(SequenceObserver<A> observer)
           
 boolean SequenceObserversSequence.addObserver(SequenceObserver<A> observer, A aspect)
           
 

Uses of Participant in dk.rode.thesis.prototype
 

Classes in dk.rode.thesis.prototype with annotations of type Participant
 interface Copyable<T>
          A copyable object can return a deep copy of it self any type implementing this interface can act as a prototype.
 class CountdownSequence
          A non-copyable count-down sequence is a singleton sequence used for count-downs: Five, Four, Three, Two, One, FIRE!
 class Main
          Prototype tests.
 interface StrictCopyable<T extends StrictCopyable<T>>
          A strict copyable object can return a deep copy of it self any type implementing this interface can act as a prototype.
 class SymbolSequence
          A cloneable symbol sequence can be cloned by using the SymbolSequence.copy() method, or by using Java's built-in clone mechanism by calling SymbolSequence.clone().
 

Uses of Participant in dk.rode.thesis.proxy
 

Classes in dk.rode.thesis.proxy with annotations of type Participant
 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.
 

Method parameters in dk.rode.thesis.proxy with annotations of type Participant
<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.getSharedSequence(Sequence<E> sequence)
          Creates a smart pointer based on the sequence supplied as sequence.
<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.
 

Constructor parameters in dk.rode.thesis.proxy with annotations of type Participant
ImmutableSequence(Sequence<E> sequence)
          Constructor.
NonResettableSequence(Sequence<E> sequence)
          Constructor.
SynchronisedSequence(Sequence<E> sequence)
          Constructor.
SynchronisedSequence(Sequence<E> sequence, Object lock)
          Constructor.
 

Uses of Participant in dk.rode.thesis.singleton
 

Classes in dk.rode.thesis.singleton with annotations of type Participant
 class DanishAlphabetSequence
          A singleton alphabet sequence for letters in the Danish alphabet: a though z as well as , , and , all lower-cased.
 class NorwegianAlphabetSequence
          A singleton alphabet sequence for letters in the Norwegian alphabet: a though z as well as , , and , all lower-cased.
 class SimpsonsAndBouvierFamilySequence
          A Simpsons and Bouvier family sequence is a singleton sequence representing the primary family members in the The Simpsons and Bouvier families.
 class SimpsonsFamilySequence
          A Simpsons family sequence is a singleton sequence representing the primary family members in the one and only The Simpsons family.
 class SmileySequence
          A smiley sequence is a sequence delivering different smileys, e.g. :), *<;), :(, etc.
 

Uses of Participant in dk.rode.thesis.state
 

Classes in dk.rode.thesis.state with annotations of type Participant
 class AbstractStateableSequence<E>
          An abstract stateable sequence implements the basic traits of a stateable sequence.
(package private)  class EvenSequence
          The even sequence represents the state generating even step sequence values.
 interface FunctionalState<E>
          A functional state encapsulates specific state related functionality of a stateable sequence.
(package private)  class OddSequence
          The odd sequence represents the state generating odd step sequence values.
 class ReversiblePrimeSequence
          A reversible prime sequence returns with each call to next() the next prime number in the sequence of prime numbers smaller than maximum, where maximum is supplied at construction time, or a previously calculated prime number with each call to next() after ReversiblePrimeSequence.reverse() has been invoked.
 interface StateableSequence<E>
          A stateable sequence is implemented internally using functional state objects to determine the current functional state.
 interface StepSequence
          A step sequence represents an unbounded integer value that is increased/decreased with a given step with each call to Sequence.next().
(package private)  class StepSequenceImpl
          An abstract class representing the basic traits of the StepSequence interface.
 

Uses of Participant in dk.rode.thesis.strategy
 

Classes in dk.rode.thesis.strategy with annotations of type Participant
 interface Stringable<T extends Stringable<? super T>>
          A stringable object can be formatted into different textual char sequence representations using a given policy to determine the format.
 interface StringablePolicy<T>
          Returns a textual representation in form of a char sequence of a given stringable object.
 

Uses of Participant in dk.rode.thesis.templatemethod
 

Classes in dk.rode.thesis.templatemethod with annotations of type Participant
 class FileSequence
          A file sequence delivers byte arrays as sequence values, where each array corresponds to the contents of the current file or directory in a given directory.
 class NegativeSequence
          A negative sequence represents a perhaps bounded integer value that is decreased with each call to next(), starting at minus one.
 class SequenceTemplate<K,E>
          A sequence template forms a template for sequences requiring several steps to construct, deliver, and dispose sequence values.
 class ZipSequence
          A zip sequence delivers input streams as sequence values, where each stream correspond to the current zip file entry.
 

Uses of Participant in dk.rode.thesis.visitor
 

Classes in dk.rode.thesis.visitor with annotations of type Participant
 class AbstractVisitableSequence<E>
          Any sequence decorated by an abstract visitable sequence implementation is value and type visitable.
 class CountingVisitor
          A counting visitor counts the different types of value visitable sequences encountered during traversal, and is thus independent of any given scanner implementation.
 class DateValuedVisitableSequence
          A date valued visitable sequence allows any sequence delivering Date values to become value visitable using the SequenceValueVisitor.visitDateValued(Sequence, Object) visitation method and is type visitable for any known sub-interface of Sequence that is implemented by the sequence.
 class IntegerValuedVisitableSequence
          An integer valued visitable sequence allows any sequence delivering Integer values to become value visitable using the SequenceValueVisitor.visitIntegerValued(Sequence, Object) visitation method and is type visitable for any known sub-interface of Sequence that is implemented by the sequence.
 class LoggingVisitor
          A logging visitor logs each visited sequence to a log supplied at execution time using a given sequence policy supplied at construction time.
 class ReflectiveVisitableSequence<E>
          A reflective visitable sequence decorates a sequence to become value and type visitable.
 interface SequenceTypeScanner
          A sequence type scanner performs the actual traversal of the sequence structure to be visited by a type visitor, invoking the TypeVisitableSequence.accept(SequenceTypeVisitor, Object) visitation method on each found type visitable sequence.
 interface SequenceTypeVisitor<P>
          A sequence type visitor visits a sequence based on its actual type, for example ReversibleSequence or MemorizableSequence.
 interface SequenceValueScanner
          A sequence value scanner performs the actual traversal of the sequence structure to be visited by a value visitor, invoking the ValueVisitableSequence.accept(SequenceValueVisitor, Object) visitation method on each found value visitable sequence.
 interface SequenceValueVisitor<P>
          A sequence value visitor visits a sequence based on the type of values it deliver, for example Integer or Date.
 interface SequenceVisitor<P>
          A sequence visitor is the super type for all visitors that can visit a sequence type.
 class SimpleScanner
          A simple scanner can traverse both type and value visitable sequences based on a traversal strategy that can be supplied at construction time, or changed runtime using the SimpleScanner.setCompositeStrategy(CompositeStrategy) method.
 class StringValuedVisitableSequence<E extends CharSequence>
          A string valued visitable sequence allows any sequence delivering any CharSequence type to become value visitable using the SequenceValueVisitor.visitStringValued(Sequence, Object) visitation method and is type visitable for any known sub-interface of Sequence that is implemented by the sequence.
 interface TypeVisitableSequence<E>
          A type visitable sequence allows visitation by type visitors.
 class TypeVisitor
          A type visitor collects visited sequences based on acceptance of specific sequence types.
 interface ValueVisitableSequence<E>
          A value visitable sequence allows visitation by value visitors.
 class VisitableCompositeSequence
          An visitable composite sequence is value and type visitable, storing sequences regardless of the type of value they deliver.
 class VisitableLongSequence
          A visitable long sequence is a LongSequence that is value visitable using the SequenceValueVisitor.visitLongValued(Sequence, Object) visitation method and is type visitable as well.
 class VisitableReversiblePrimeSequence
          A visitable reversible prime sequence is a ReversiblePrimeSequence that is value visitable using the SequenceValueVisitor.visitIntegerValued(Sequence, Object) visitation method and is type visitable as well.
 


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.