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.