Uses of Interface
dk.rode.thesis.meta.model.Sequence

Packages that use Sequence

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.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.meta.model	Defines the common model objects used, primarily sequences and various general implementations used in the different evaluations.
dk.rode.thesis.meta.test	Various tests.
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 Sequence in dk.rode.thesis.abstractfactory

Methods in dk.rode.thesis.abstractfactory that return Sequence

Sequence<E>	PrototypicalSequenceFactory.create()
Sequence<E>	StandardFactory.createSequence(P argument) Creates a new initialised sequence instance.
Sequence<E>	SequenceFactory.createSequence(P argument) Creates a new initialised sequence instance.
Sequence<E>	PrototypicalSequenceFactory.createSequence(Void unused)
private static <E,P> Sequence<E>	Main.testSequenceFactory(Log out, String index, SequenceFactory<E,P> factory, P argument) Test sequence factories.

Constructors in dk.rode.thesis.abstractfactory with parameters of type Sequence

PrototypicalSequenceFactory(Sequence<E> prototype)
Constructor.

Uses of Sequence in dk.rode.thesis.adapter

Classes in dk.rode.thesis.adapter that implement Sequence

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 declared as Sequence

(package private) Sequence<E>

SequenceAdapter.sequence The original sequence handling type E.

Methods in dk.rode.thesis.adapter that return Sequence

Sequence<T>	SequenceAdapter.copy()
static <V> Sequence<Object>	SequenceAdapter.create(Sequence<V> sequence) Factory method that creates a sequence adapting the type of values supplied by sequence to Object.

Methods in dk.rode.thesis.adapter that return types with arguments of type Sequence

StringablePolicy<? super Sequence<T>>

SequenceAdapter.getStringablePolicy(StringablePolicy<? super Sequence<T>> policy)

Methods in dk.rode.thesis.adapter with parameters of type Sequence

static <V> Sequence<Object>	SequenceAdapter.create(Sequence<V> sequence) Factory method that creates a sequence adapting the type of values supplied by sequence to Object.
abstract CharSequence	AdaptedPolicy.toString(Sequence<?> sequence) Returns a textual representation of the object supplied as object in form of a char sequence.

Method parameters in dk.rode.thesis.adapter with type arguments of type Sequence

StringablePolicy<? super Sequence<T>>	SequenceAdapter.getStringablePolicy(StringablePolicy<? super Sequence<T>> policy)
CharSequence	SequenceAdapter.toString(StringablePolicy<? super Sequence<T>> policy)

Constructors in dk.rode.thesis.adapter with parameters of type Sequence

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 Sequence in dk.rode.thesis.bridge

Classes in dk.rode.thesis.bridge that implement Sequence

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	SynchronisedSequenceAbstraction<E> A synchronised sequence abstraction refines a sequence abstraction by making it thread-safe.

Method parameters in dk.rode.thesis.bridge with type arguments of type Sequence

CharSequence

SequenceAbstraction.toString(StringablePolicy<? super Sequence<E>> policy)

Uses of Sequence in dk.rode.thesis.builder

Fields in dk.rode.thesis.builder declared as Sequence

protected Sequence<? extends E>

AbstractExpressionBuilder.sequence The sequence manipulated by terminal expressions.

Methods in dk.rode.thesis.builder that return Sequence

Sequence<? extends E>	ExpressionBuilder.getSequence() Returns the sequence manipulated by the terminal expressions constructed by this builder.
Sequence<? extends E>	AbstractExpressionBuilder.getSequence()

Constructors in dk.rode.thesis.builder with parameters of type Sequence

AbstractExpressionBuilder(Context context, Sequence<? extends E> sequence)
Constructor.

AbstractExpressionBuilder(Sequence<? extends E> sequence)
Constructor.

CountingComparableExpressionBuilder(Context context, Sequence<? extends E> sequence)
Constructor.

CountingComparableExpressionBuilder(Sequence<? extends E> sequence)
Constructor.

CountingExpressionBuilder(Context context, Sequence<? extends E> sequence)
Constructor.

CountingExpressionBuilder(Sequence<? extends E> sequence)
Constructor.

StandardComparableExpressionBuilder(Context context, Sequence<? extends E> sequence)
Constructor.

StandardComparableExpressionBuilder(Sequence<? extends E> sequence)
Constructor.

StandardExpressionBuilder(Context context, Sequence<? extends E> sequence)
Constructor.

StandardExpressionBuilder(Sequence<? extends E> sequence)
Constructor.

Uses of Sequence in dk.rode.thesis.command

Fields in dk.rode.thesis.command declared as Sequence

protected Sequence<E>

SequenceCommand.sequence The sequence receiver used by this command.

Methods in dk.rode.thesis.command with parameters of type Sequence

(package private) abstract <E> List<Command<E>>	Creator.create(Sequence<E> sequence, Boolean fail) Returns a list of test commands primed with sequence as the receiver.
private static <E> boolean	Main.doTest(Log out, int index, Sequence<E> s, Creator creator, Boolean fail, boolean copy) Executes a given command test for a given sequence.
private static boolean	Main.test(Log out, String heading, Sequence<?>[] sequences, Creator creator, Boolean fail, boolean copy) Executes a given command test for all sequences.
private static <E> List<Command<E>>	Main.test1(Log out, Sequence<E> sequence, Boolean fail) Creates command for the first composite test.
private static <E> List<Command<E>>	Main.test2(Log out, Sequence<E> sequence, Boolean fail) Creates command for the second composite test.

Constructors in dk.rode.thesis.command with parameters of type Sequence

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 Sequence in dk.rode.thesis.composite

Subinterfaces of Sequence in dk.rode.thesis.composite

interface

CompositeSequence<E> A composite sequence is a sequence that represents an number of other contained sequences, possibly composite as well.

Classes in dk.rode.thesis.composite that implement Sequence

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.

Fields in dk.rode.thesis.composite with type parameters of type Sequence

protected List<Sequence<? extends E>>

AbstractCompositeSequence.sequences The sequences associated with this sequence, in order.

Methods in dk.rode.thesis.composite with type parameters of type Sequence

<V extends Sequence<?>> List<V>	CompositeSequence.getSequences(Class<V> clazz) Returns the sequences currently associated with this composite sequence, in order, assignable to the type supplied as clazz.
<V extends Sequence<?>> List<V>	AbstractCompositeSequence.getSequences(Class<V> clazz)
<V extends Sequence<?>> List<V>	CompositeSequence.getSequences(CompositeStrategy strategy, boolean includeSelf, Boolean type, Class<V> clazz) Returns the sequences currently reachable from this composite sequence, in the order specified by strategy.
<V extends Sequence<?>> List<V>	AbstractCompositeSequence.getSequences(CompositeStrategy strategy, boolean includeSelf, Boolean type, Class<V> clazz)
protected abstract <E,C extends List<Sequence<? extends E>>> C	CompositeStrategy.traverse(Sequence<? extends E> sequence, Boolean type, C sequences, CompositeStrategy strategy) Adds all sequences reachable from sequence to sequences as dictated by this strategy, including sequence if not already added.

Methods in dk.rode.thesis.composite that return types with arguments of type Sequence

List<Sequence<? extends E>>	CompositeSequence.getSequences() Returns the sequences currently associated with this composite sequence, in order.
List<Sequence<? extends E>>	AbstractCompositeSequence.getSequences()
List<Sequence<? extends E>>	CompositeSequence.getSequences(CompositeStrategy strategy, boolean includeSelf, Boolean type) Returns the sequences currently reachable from this composite sequence, in the order specified by strategy.
List<Sequence<? extends E>>	AbstractCompositeSequence.getSequences(CompositeStrategy strategy, boolean includeSelf, Boolean type)
Iterator<Sequence<? extends E>>	AbstractCompositeSequence.iterator()
<E> List<Sequence<? extends E>>	CompositeStrategy.traverse(Sequence<? extends E> root, Boolean type) Returns an ordered list containing all sequences reachable from root, including root.

Methods in dk.rode.thesis.composite with parameters of type Sequence

boolean	CompositeSequence.addSequence(Sequence<? extends E> sequence) Associates the sequence supplied as sequence to this composite sequence, if not already.
boolean	AbstractCompositeSequence.addSequence(Sequence<? extends E> sequence)
private static void	Main.print(Log out, int i, String indent, Sequence<?> sequence) Recursive helper method to print the structure of the (composite) sequence supplied as sequence.
boolean	CompositeSequence.removeSequence(Sequence<?> sequence) Removes the sequence supplied as sequence from this composite sequence, if associated.
boolean	AbstractCompositeSequence.removeSequence(Sequence<?> sequence)
<E> List<Sequence<? extends E>>	CompositeStrategy.traverse(Sequence<? extends E> root, Boolean type) Returns an ordered list containing all sequences reachable from root, including root.
protected abstract <E,C extends List<Sequence<? extends E>>> C	CompositeStrategy.traverse(Sequence<? extends E> sequence, Boolean type, C sequences, CompositeStrategy strategy) Adds all sequences reachable from sequence to sequences as dictated by this strategy, including sequence if not already added.

Constructors in dk.rode.thesis.composite with parameters of type Sequence

AbstractCompositeSequence(CompositeStrategy strategy, Sequence<? extends E>... sequences)
Constructor.

Uses of Sequence in dk.rode.thesis.decorator

Classes in dk.rode.thesis.decorator that implement Sequence

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.

Fields in dk.rode.thesis.decorator declared as Sequence

(package private) Sequence<E>

SequenceDecorator.sequence The decorated sequence.

Fields in dk.rode.thesis.decorator with type parameters of type Sequence

private StringablePolicy<Sequence<?>>

SequenceDecorator.policy The default sequence policy used for formatting.

Methods in dk.rode.thesis.decorator that return Sequence

protected Sequence<E>

SequenceDecorator.getSequence(boolean copy) Returns a copy of the decorated sequence if copy is true, otherwise the decorated sequence it self.

Methods in dk.rode.thesis.decorator that return types with arguments of type Sequence

StringablePolicy<? super Sequence<E>>

SequenceDecorator.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)

Method parameters in dk.rode.thesis.decorator with type arguments of type Sequence

StringablePolicy<? super Sequence<E>>	SequenceDecorator.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)
CharSequence	SequenceDecorator.toString(StringablePolicy<? super Sequence<E>> policy)

Constructors in dk.rode.thesis.decorator with parameters of type Sequence

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.

Constructor parameters in dk.rode.thesis.decorator with type arguments of type 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.

Uses of Sequence in dk.rode.thesis.facade

Classes in dk.rode.thesis.facade that implement Sequence

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

Fields in dk.rode.thesis.facade declared as Sequence

private Sequence<? extends Number>

UnboundedRandomSequence.sequence A sequence to deliver unbounded long values.

Constructors in dk.rode.thesis.facade with parameters of type Sequence

UnboundedRandomSequence(Sequence<? extends Number> sequence)
Constructor.

Uses of Sequence in dk.rode.thesis.factorymethod

Methods in dk.rode.thesis.factorymethod with parameters of type Sequence

protected Command<E>	SequenceCommandCreator.create(Sequence<E> sequence, Sequence.State state)
protected Command<E>	ReversibleSequenceCommandCreator.create(Sequence<E> sequence, Sequence.State state)
protected Command<E>	EvilSequenceCommandCreator.create(Sequence<E> sequence, Sequence.State state)
protected abstract Command<E>	CommandCreator.create(Sequence<E> sequence, T token) Factory method to create a new command of the type specified by the token supplied as token.
protected Command<E>	ReflectiveCommandCreator.create(Sequence<E> sequence, TypeLiteral<? extends Command<E>> type)
protected LogCommand<E>	ReversibleSequenceCommandCreator.createDefault(Sequence<E> sequence)
protected EvilCommand<E>	EvilSequenceCommandCreator.createDefault(Sequence<E> sequence)
protected Command<E>	CommandCreator.createDefault(Sequence<E> sequence) Factory method to create a new default command in case the normal command creation failed.
Command<E>	CommandCreator.getCommand(Sequence<E> sequence, T token) Returns a new command instance of the type identified by token associated with the sequence receiver supplied at sequence.
private static <E,T> boolean	Main.testCreator(Log out, CommandCreator<E,T> creator, Sequence<E> sequence, int index, List<T> tokens) Tests the creator supplied as creator using sequence for each token in tokens
private static <E> boolean	Main.testFactory(Log out, Sequence<E> sequence, int index, List<Factory<? extends Command<E>>> factories) Tests the factories supplied in factories that creates commands based on sequence as the single argument.

Uses of Sequence in dk.rode.thesis.flyweight

Classes in dk.rode.thesis.flyweight that implement Sequence

class	Sentence A sentence represents an ordered sequence of words making up that sentence.
class	Word A word represents an ordered sequence of characters making up that word.

Uses of Sequence in dk.rode.thesis.interpreter

Fields in dk.rode.thesis.interpreter declared as Sequence

protected Sequence<? extends T>

SequenceExpression.sequence The sequence manipulated by this expression.

Methods in dk.rode.thesis.interpreter with parameters of type Sequence

private <E extends Comparable<? super E>> Expression<E>	Main.create1(Sequence<E> sequence, Class<E> type, E value, Context context) Creates: next[20], y = current, (reverse[true] ?
private <E extends Number & Comparable<? super E>> Expression<E>	Main.create2(Sequence<E> sequence, Class<E> type, E value, Context context) Creates: next[value], foo = Integer{next[(boo ?
private <E extends Comparable<? super E>> Expression<E>	Main.create3(Sequence<E> sequence, Class<E> type, E value, Context context) Creates a loop-structure by using cyclic expression references without intermediate variables: (current < value ?
private <E extends Number & Comparable<? super E>> Expression<E>	Main.create4(Sequence<E> sequence, Class<E> type, E value1, E value2, Context context) Generates the mother of all sequence expressions: (current < value1 ?
private Expression<Comparable<?>>	Main.create5(Context context, Sequence<String> string, Sequence<Integer> integer, String stringValue, Integer integerValue) Creates an expression with a loop having 15 iterations as well as different sequences and types: ((!
private Expression<Comparable<?>>	Main.create5(Context context, Sequence<String> string, Sequence<Integer> integer, String stringValue, Integer integerValue) Creates an expression with a loop having 15 iterations as well as different sequences and types: ((!

Constructors in dk.rode.thesis.interpreter with parameters of type Sequence

CurrentExpression(Sequence<? extends E> sequence)
Constructor.

CurrentExpression(Sequence<? extends E> sequence, boolean includeHashCode)
Constructor.

NextExpression(Sequence<? extends E> sequence)
Constructor, which will call next() a single time on sequence when this expression is evaluated.

NextExpression(Sequence<? extends E> sequence, boolean includeHashCode)
Constructor, which will call next() a single time on sequence when this expression is evaluated.

NextExpression(Sequence<? extends E> sequence, Expression<? extends Number> count)
Constructor, which will call next() the number of times corresponding to the absolute value of the result of evaluating count when this expression is evaluated.

NextExpression(Sequence<? extends E> sequence, Expression<? extends Number> count, boolean includeHashCode)
Constructor, which will call next() the number of times corresponding to the absolute value of the result of evaluating count when this expression is evaluated.

NextExpression(Sequence<? extends E> sequence, int count)
Constructor, which will call next() count time(s) on sequence when this expression is evaluated.

NextExpression(Sequence<? extends E> sequence, int count, boolean includeHashCode)
Constructor, which will call next() count time(s) on sequence when this expression is evaluated.

ResetExpression(Sequence<? extends E> sequence)
Constructor.

ResetExpression(Sequence<? extends E> sequence, boolean includeHashCode)
Constructor.

ReverseExpression(Sequence<? extends E> sequence)
Constructor.

ReverseExpression(Sequence<? extends E> sequence, boolean reverse)
Constructor.

ReverseExpression(Sequence<? extends E> sequence, boolean reverse, boolean includeHashCode)
Constructor.

ReverseExpression(Sequence<? extends E> sequence, Expression<Boolean> reverse)
Constructor.

ReverseExpression(Sequence<? extends E> sequence, Expression<Boolean> reverse, boolean includeHashCode)
Constructor.

SequenceExpression(Sequence<? extends T> sequence, boolean includeHashCode)
Constructor.

SetExpression(Sequence<? extends E> sequence, Class<E> type, E value)
Constructor.

SetExpression(Sequence<? extends E> sequence, Class<E> type, E value, boolean includeHashCode)
Constructor.

SetExpression(Sequence<? extends E> sequence, Expression<E> value)
Constructor.

SetExpression(Sequence<? extends E> sequence, Expression<E> value, boolean includeHashCode)
Constructor.

Uses of Sequence in dk.rode.thesis.iterator

Classes in dk.rode.thesis.iterator that implement Sequence

class	IterableSequence<E> An iterable sequence is a bounded sequence that can be accessed as any other iterable object.
class	ProcessableSequence<E> A processable sequence represents an internal iterator that can iterate over bounded sequences using a value processor to perform the actual processing of delivered sequence values.

Fields in dk.rode.thesis.iterator declared as Sequence

(package private) Sequence<E>

SequenceIterator.sequence The sequence to iterate over.

Methods in dk.rode.thesis.iterator that return types with arguments of type Sequence

StringablePolicy<? super Sequence<E>>

SequenceIterator.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)

Methods in dk.rode.thesis.iterator with parameters of type Sequence

private static <V> void	Main.iterate(Log out, int index, Sequence<V> sequence, int valuesPerLine, boolean recurse) Iterates over the sequence values in sequence.
static <V> Iterator<V>	SequenceIterator.iterator(Sequence<V> sequence) Creates a new iterator based on sequence.

Method parameters in dk.rode.thesis.iterator with type arguments of type Sequence

StringablePolicy<? super Sequence<E>>	SequenceIterator.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)
CharSequence	SequenceIterator.toString(StringablePolicy<? super Sequence<E>> policy)

Constructors in dk.rode.thesis.iterator with parameters of type Sequence

IterableSequence(Sequence<E> sequence)
Constructor, which creates this iterable sequence to iterate through the sequence values from sequence, starting from its current value.

ProcessableSequence(Sequence<E> sequence)
Constructor, which creates this processable sequence to process through the sequence values from sequence.

SequenceIterator(Sequence<E> sequence)
Constructor.

Uses of Sequence in dk.rode.thesis.memento

Subinterfaces of Sequence in dk.rode.thesis.memento

interface

MemorizableSequence<E> A memorizable sequence can memorise its internal state at a given time and have it restored again later by using mementos.

Classes in dk.rode.thesis.memento that implement Sequence

class	MemorizableEnglishAlphabetSequence A memorizable alphabet sequence for letters in the English alphabet, i.e.
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.

Fields in dk.rode.thesis.memento declared as Sequence

private Sequence<E>

SequenceMemento.sequence A local (copy) sequence instance that stores internal state.

Methods in dk.rode.thesis.memento that return Sequence

Sequence<E>	SequenceMemento.getSequence() Return the sequence memorised by this memento.
Sequence<E>	GuardedSequenceMemento.getSequence() Return the sequence memorised by this memento.

Methods in dk.rode.thesis.memento that return types with arguments of type Sequence

StringablePolicy<? super Sequence<E>>

SequenceMemento.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)

Methods in dk.rode.thesis.memento with parameters of type Sequence

private static <E> boolean	Main.checkAccess(Log out, Map<MemorizableSequence<E>,SequenceMemento<E>> mementos, Sequence<E> sequence) Checks access rules to guarded mementos.
void	SequenceMemento.setSequence(Sequence<E> sequence) Memorises the state of the Sequence supplied as sequence by copying it.
void	GuardedSequenceMemento.setSequence(Sequence<E> sequence) Memorises the state of the Sequence supplied as sequence by copying it.

Method parameters in dk.rode.thesis.memento with type arguments of type Sequence

StringablePolicy<? super Sequence<E>>	SequenceMemento.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)
CharSequence	SequenceMemento.toString(StringablePolicy<? super Sequence<E>> policy)

Constructors in dk.rode.thesis.memento with parameters of type Sequence

GuardedSequenceMemento(Sequence<E> sequence)
Constructor.

SequenceMemento(Sequence<E> sequence)
Constructor.

Uses of Sequence in dk.rode.thesis.meta.model

Subinterfaces of Sequence in dk.rode.thesis.meta.model

interface

ReversibleSequence<E> A reversible sequence allows retrieval of previous values if and only if such previous values are ready for delivery, i.e. have already been calculated.

Classes in dk.rode.thesis.meta.model that implement Sequence

class	AbstractSequence<E> An abstract sequence implements the basic traits of the Sequence interface.
class	ArraySequence<E> A simple abstract array sequence to deliver all the entries in a given array, in order.
class	DigitSequence A digit sequence contains the 10 digits in the decimal system, in order from 0 to 9.
class	EnglishAlphabetSequence An alphabet sequence for letters in the English alphabet: a though z, lower-cased.
class	HexDigitSequence A hex digit sequence contains the 16 digits in the hexidecimal system, in order from 0 to A.
class	LongSequence A long sequence represents an unbounded long value that is increased with each call to LongSequence.next().
class	PrimeSequence A prime sequence returns with each call to PrimeSequence.next() the next prime number in the sequence of prime numbers smaller than maximum, where maximum is supplied at construction time.

Methods in dk.rode.thesis.meta.model that return Sequence

Sequence<E>

Sequence.copy() Returns a copy of this sequence that will start at the same sequence index as this sequence.

Methods in dk.rode.thesis.meta.model that return types with arguments of type Sequence

StringablePolicy<? super Sequence<E>>

AbstractSequence.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)

Method parameters in dk.rode.thesis.meta.model with type arguments of type Sequence

StringablePolicy<? super Sequence<E>>	AbstractSequence.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)
CharSequence	AbstractSequence.toString(StringablePolicy<? super Sequence<E>> policy)

Constructors in dk.rode.thesis.meta.model with parameters of type Sequence

AbstractSequence(Sequence<? super E> sequence)
Copy constructor.

Uses of Sequence in dk.rode.thesis.meta.test

Methods in dk.rode.thesis.meta.test with parameters of type Sequence

private <E> boolean

IntegrityTests.test(Log out, boolean log, int index, Sequence<E> sequence, int iterations, int maxErrors) Performs an integrity test of the Sequence supplied as sequence, and returns true upon success or false if the test failed.

Uses of Sequence in dk.rode.thesis.observer

Subinterfaces of Sequence in dk.rode.thesis.observer

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

Classes in dk.rode.thesis.observer that implement Sequence

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

Fields in dk.rode.thesis.observer declared as Sequence

private Sequence<E>	SequenceObserversSequenceDecorator.sequence The decorated sequence.
private Sequence<?>	CorrelatedSequenceObserver.sequence The correlated sequence.
private Sequence<E>	AnnotatedObserversSequenceDecorator.sequence The decorated sequence.

Fields in dk.rode.thesis.observer with type parameters of type Sequence

private StringablePolicy<Sequence<?>>	PrintSequenceObserver.policy The policy to use to print the observable sequence.
private Map<Sequence<?>,Sequence<?>>	ProbeSequenceObserver.sequences The map of currently probed sequences.
private Map<Sequence<?>,Sequence<?>>	ProbeSequenceObserver.sequences The map of currently probed sequences.

Methods in dk.rode.thesis.observer that return types with arguments of type Sequence

StringablePolicy<? super Sequence<E>>	SequenceObserversSequenceDecorator.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)
StringablePolicy<? super Sequence<E>>	AnnotatedObserversSequenceDecorator.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)

Methods in dk.rode.thesis.observer with parameters of type Sequence

(package private) static void	ProbeSequenceObserver.externalProbe(Sequence<?> sequence, Sequence.State state) Probe method that will only be invoked by an observable ReversiblePrimeSequence instance (decorated by the AnnotatedObserversSequenceDecorator type).
(package private) void	ProbeSequenceObserver.internalProbe(Sequence<?> sequence, Sequence.State state) Probes the sequence supplied as sequence, and logs all attributes that has changed value (based on equals(Object)) since the last time this method was invoked with the same sequence (based on equals(Object)) as the first argument.
void	SequenceObserversSequence.sequenceEvent(Sequence<?> sequence, A aspect)
void	SequenceObserver.sequenceEvent(Sequence<?> sequence, A aspect) Notification method that is invoked when the sequence supplied as sequence has changed its state to state.
void	BirthdayRegistry.RegistryObserver.sequenceEvent(Sequence<?> sequence, A aspect)
void	PrintSequenceObserver.sequenceEvent(Sequence<?> sequence, Sequence.State state) Notification method that is invoked when the sequence supplied as sequence has changed its state to state.
void	CorrelatedSequenceObserver.sequenceEvent(Sequence<?> sequence, Sequence.State state)
void	AnnotatedObserversSequence.sequenceEvent(Sequence<?> sequence, Sequence.State state)

Method parameters in dk.rode.thesis.observer with type arguments of type Sequence

StringablePolicy<? super Sequence<E>>	SequenceObserversSequenceDecorator.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)
StringablePolicy<? super Sequence<E>>	AnnotatedObserversSequenceDecorator.getStringablePolicy(StringablePolicy<? super Sequence<E>> policy)
CharSequence	SequenceObserversSequenceDecorator.toString(StringablePolicy<? super Sequence<E>> policy)
CharSequence	AnnotatedObserversSequenceDecorator.toString(StringablePolicy<? super Sequence<E>> policy)

Constructors in dk.rode.thesis.observer with parameters of type Sequence

AnnotatedObserversSequenceDecorator(Sequence<E> sequence)
Constructor.

CorrelatedSequenceObserver(Sequence<?> sequence)
Constructor.

SequenceObserversSequenceDecorator(Sequence<E> sequence)
Constructor.

Constructor parameters in dk.rode.thesis.observer with type arguments of type Sequence

PrintSequenceObserver(StringablePolicy<Sequence<?>> policy)
Constructor.

Uses of Sequence in dk.rode.thesis.prototype

Classes in dk.rode.thesis.prototype that implement Sequence

class	CountdownSequence A non-copyable count-down sequence is a singleton sequence used for count-downs: Five, Four, Three, Two, One, FIRE!
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 Sequence in dk.rode.thesis.proxy

Classes in dk.rode.thesis.proxy that implement Sequence

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 type parameters of type Sequence

<E,T extends Sequence<E>> T

SequenceProxyFactory.getVirtualSequence(InstantiableTypeLiteral<T> type, Object... arguments) Creates a virtual sequence based on the sequence type T.

Methods in dk.rode.thesis.proxy that return Sequence

<E> Sequence<E>	SequenceProxyFactory.getImmutableSequence(Sequence<E> sequence) Returns a sequence proxy implementing all interfaces sequence implements that will disallow reset(), next(), and 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 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.

Methods in dk.rode.thesis.proxy with parameters of type Sequence

<E> Sequence<E>	SequenceProxyFactory.getImmutableSequence(Sequence<E> sequence) Returns a sequence proxy implementing all interfaces sequence implements that will disallow reset(), next(), and 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 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.
boolean	SequenceProxyFactory.isProxied(Sequence<?> sequence) Returns true if sequence has at least one created proxy sequence associated with it, false if not.
boolean	SequenceProxyFactory.isProxy(Sequence<?> sequence) Returns true if sequence is a proxy sequence created by a sequence proxy factory, false if not.

Constructors in dk.rode.thesis.proxy with parameters of type Sequence

ImmutableSequence(Sequence<E> sequence)
Constructor.

NonResettableSequence(Sequence<E> sequence)
Constructor.

SynchronisedSequence(Sequence<E> sequence)
Constructor.

SynchronisedSequence(Sequence<E> sequence, Object lock)
Constructor.

Uses of Sequence in dk.rode.thesis.singleton

Classes in dk.rode.thesis.singleton that implement Sequence

class	DanishAlphabetSequence A singleton alphabet sequence for letters in the Danish alphabet: a though z as well as æ, ø, and å, all lower-cased.
class	MutatedSimpsonsFamilySequence A mutated Simpsons family sequence is a sequence representing a random mutated sub-set of the primary family members in the one and only The Simpsons family.
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.

Fields in dk.rode.thesis.singleton declared as Sequence

private Sequence<String>

DanishAlphabetSequence.sequence Delegate sequence storing the actual letters in the Danish alphabet.

Methods in dk.rode.thesis.singleton that return types with arguments of type Sequence

StringablePolicy<? super Sequence<String>>

DanishAlphabetSequence.getStringablePolicy(StringablePolicy<? super Sequence<String>> policy)

Method parameters in dk.rode.thesis.singleton with type arguments of type Sequence

StringablePolicy<? super Sequence<String>>	DanishAlphabetSequence.getStringablePolicy(StringablePolicy<? super Sequence<String>> policy)
CharSequence	DanishAlphabetSequence.toString(StringablePolicy<? super Sequence<String>> policy)

Uses of Sequence in dk.rode.thesis.state

Subinterfaces of Sequence in dk.rode.thesis.state

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 next().

Classes in dk.rode.thesis.state that implement Sequence

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.
(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.
(package private) class	StepSequenceImpl An abstract class representing the basic traits of the StepSequence interface.

Method parameters in dk.rode.thesis.state with type arguments of type Sequence

CharSequence

AbstractStateableSequence.toString(StringablePolicy<? super Sequence<E>> policy)

Uses of Sequence in dk.rode.thesis.strategy

Methods in dk.rode.thesis.strategy with parameters of type Sequence

CharSequence

SequencePolicy.toString(Sequence<?> sequence)

Uses of Sequence in dk.rode.thesis.templatemethod

Classes in dk.rode.thesis.templatemethod that implement Sequence

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 Sequence in dk.rode.thesis.visitor

Subinterfaces of Sequence in dk.rode.thesis.visitor

interface	TypeVisitableSequence<E> A type visitable sequence allows visitation by type visitors.
interface	ValueVisitableSequence<E> A value visitable sequence allows visitation by value visitors.

Classes in dk.rode.thesis.visitor that implement Sequence

class	AbstractVisitableSequence<E> Any sequence decorated by an abstract visitable sequence implementation is value and type visitable.
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	ReflectiveVisitableSequence<E> A reflective visitable sequence decorates a sequence to become value and type visitable.
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.
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	VisitableRandomSequence A visitable random sequence is a RandomSequence that is value visitable only using the SequenceValueVisitor.visitIntegerValued(Sequence, Object) visitation method.
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.

Fields in dk.rode.thesis.visitor with type parameters of type Sequence

private Set<Sequence<?>>

TypeVisitor.approved The set containing the approved sequences, in order.

Methods in dk.rode.thesis.visitor that return types with arguments of type Sequence

List<Sequence<?>>

TypeVisitor.getApproved() Returns a list containing the sequences approved by this type visitor, in visitation order.

Methods in dk.rode.thesis.visitor with parameters of type Sequence

protected void	TypeVisitor.approve(Sequence<?> sequence) Approves the visited sequence supplied as sequence.
void	LoggingVisitor.visitDateValued(Sequence<Date> sequence, Log out)
void	SequenceValueVisitor.visitDateValued(Sequence<Date> sequence, P argument) Visits a sequence that delivers Date sequence values.
void	CountingVisitor.visitDateValued(Sequence<Date> sequence, Void unused)
void	LoggingVisitor.visitIntegerValued(Sequence<Integer> sequence, Log out)
void	SequenceValueVisitor.visitIntegerValued(Sequence<Integer> sequence, P argument) Visits a sequence that delivers Integer sequence values.
void	CountingVisitor.visitIntegerValued(Sequence<Integer> sequence, Void unused)
void	LoggingVisitor.visitLongValued(Sequence<Long> sequence, Log out)
void	SequenceValueVisitor.visitLongValued(Sequence<Long> sequence, P argument) Visits a sequence that delivers Long sequence values.
void	CountingVisitor.visitLongValued(Sequence<Long> sequence, Void unused)
void	LoggingVisitor.visitStringValued(Sequence<? extends CharSequence> sequence, Log out)
void	SequenceValueVisitor.visitStringValued(Sequence<? extends CharSequence> sequence, P argument) Visits a sequence that delivers any type of value that implements the CharSequence interface, including CharSequence it self.
void	CountingVisitor.visitStringValued(Sequence<? extends CharSequence> sequence, Void unused)
void	LoggingVisitor.visitUnknown(Sequence<?> sequence, Log out)
void	SequenceVisitor.visitUnknown(Sequence<?> sequence, P argument) Visits a sequence that cannot be visited by any other visitation methods declared by this visitor.
void	TypeVisitor.visitUnknown(Sequence<?> sequence, Void unused)
void	CountingVisitor.visitUnknown(Sequence<?> sequence, Void unused)

Constructors in dk.rode.thesis.visitor with parameters of type Sequence

AbstractVisitableSequence(Sequence<E> sequence)
Constructor.

DateValuedVisitableSequence(Sequence<Date> sequence)
Constructor.

IntegerValuedVisitableSequence(Sequence<Integer> sequence)
Constructor.

ReflectiveVisitableSequence(Sequence<E> sequence)
Constructor.

StringValuedVisitableSequence(Sequence<E> sequence)
Constructor.