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

Uses of Interface
dk.rode.thesis.prototype.Copyable

Packages that use Copyable
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.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.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.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 Copyable in dk.rode.thesis.adapter
 

Classes in dk.rode.thesis.adapter that implement Copyable
 class SequenceAdapter<E,T>
          The sequence adapter acts as a generic type adapter for sequence parameterised types, i.e. from Sequence<E> to Sequence<T>, by using an adapter delegate to perform the representation shift.
 

Uses of Copyable in dk.rode.thesis.bridge
 

Subinterfaces of Copyable in dk.rode.thesis.bridge
 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.
 

Classes in dk.rode.thesis.bridge that implement Copyable
 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.
 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.
 

Uses of Copyable in dk.rode.thesis.builder
 

Subinterfaces of Copyable in dk.rode.thesis.builder
 interface ComparableExpressionBuilder<E extends Comparable<? super E>>
          A comparable expression builder construct various Expression types having a Comparable bound on the value produced by the constructed expressions and/or on the expression operands used.
 interface ExpressionBuilder<E>
          An expression builder construct various Expression types having no bounds on the values produced by the constructed expressions.
 

Classes in dk.rode.thesis.builder that implement Copyable
 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.
 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.
 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.
 class TypedFlowExpression<E>
          A typed flow expression represents one or more expressions to be evaluated in order, one at a time, where the type of value the evaluation of the expressions produces associated with it at runtime.
 

Uses of Copyable in dk.rode.thesis.command
 

Subinterfaces of Copyable in dk.rode.thesis.command
 interface Command<E>
          A command represents a possibly undoable operation on a given receiver.
 

Classes in dk.rode.thesis.command that implement Copyable
 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 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.
 

Uses of Copyable in dk.rode.thesis.composite
 

Subinterfaces of Copyable 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 Copyable
 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.
 

Uses of Copyable in dk.rode.thesis.decorator
 

Classes in dk.rode.thesis.decorator that implement Copyable
 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.
 

Uses of Copyable in dk.rode.thesis.facade
 

Classes in dk.rode.thesis.facade that implement Copyable
(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.
 

Uses of Copyable in dk.rode.thesis.flyweight
 

Classes in dk.rode.thesis.flyweight that implement Copyable
 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 Copyable in dk.rode.thesis.interpreter
 

Subinterfaces of Copyable in dk.rode.thesis.interpreter
 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.
 interface InitialisableExpression<E>
          An initialisable expression represents an expression that require several steps to be constructed, and hence must be initialised before actual use.
 interface NonTerminalExpression<E>
          A non terminal expression represents a grammar rule, but this interface is a marker interface only as it offers no specific functionality.
 interface TerminalExpression<E>
          A terminal expression represents an operation to be performed on a given sequence, but this interface is a marker interface only as it offers no specific functionality.
 interface TypedExpression<E>
          A typed expression exposes the type of the value its evaluation produces via its TypedExpression.type() method.
 

Classes in dk.rode.thesis.interpreter that implement Copyable
 class AbstractExpression<E>
          An abstract expression represents the basic traits of any expression.
 class AndExpression
          A logical and expression for two expressions evaluating to a Boolean value.
 class AssignmentExpression<E>
          An assignment expression assigns the result of the evaluation of an expression to a variable.
 class BinaryExpression<T,E>
          A binary expression represents any expression that involves (at least) two sub-expressions as operands.
 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 CompareExpression<E extends Comparable<? super E>>
          A compare expression can compare two expressions evaluating to the same Comparable type as smaller than, smaller than or equal, equal, not equal, greater than, or equal or greater than.
 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 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.
 class FlowExpression<E>
          A flow expression represents one or more expressions to be evaluated in order, one at a time.
 class NextExpression<E>
          A next expression will invoke next() a number of times on a given sequence when evaluated.
 class NotExpression
          A not expression (!)
 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 SequenceExpression<T,E>
          A sequence expression represents a terminal expression used to manipulate a given sequence.
 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 TypedExpressionDecorator<E>
          A type expression decorator allows any expression to be explicitly associated with the type of the values the evaluation of it will produce.
 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 Copyable in dk.rode.thesis.iterator
 

Classes in dk.rode.thesis.iterator that implement Copyable
 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.
 

Uses of Copyable in dk.rode.thesis.memento
 

Subinterfaces of Copyable 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 Copyable
 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.
 

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

Subinterfaces of Copyable 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.
 interface Sequence<E>
          Represents a sequence that will deliver the next, or current, value in the sequence on demand.
 

Classes in dk.rode.thesis.meta.model that implement Copyable
 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.
 

Uses of Copyable in dk.rode.thesis.observer
 

Subinterfaces of Copyable 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 Copyable
 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.
 

Uses of Copyable in dk.rode.thesis.prototype
 

Subinterfaces of Copyable in dk.rode.thesis.prototype
 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.
 

Classes in dk.rode.thesis.prototype that implement Copyable
 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().
 

Methods in dk.rode.thesis.prototype that return Copyable
<T> Copyable<T>
PrototypeFactory.getPrototypicalObject(TypeLiteral<T> type, T object)
          Returns a prototypical object representing object that can be copied by invoking copy() on it if and only if the class of object supplies a copy constructor and/or directly implements Copyable.
 

Uses of Copyable in dk.rode.thesis.proxy
 

Classes in dk.rode.thesis.proxy that implement Copyable
 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.
 

Uses of Copyable in dk.rode.thesis.singleton
 

Classes in dk.rode.thesis.singleton that implement Copyable
 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.
 

Uses of Copyable in dk.rode.thesis.state
 

Subinterfaces of Copyable 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 Sequence.next().
 

Classes in dk.rode.thesis.state that implement Copyable
 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.
 

Uses of Copyable in dk.rode.thesis.templatemethod
 

Classes in dk.rode.thesis.templatemethod that implement Copyable
 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 Copyable in dk.rode.thesis.visitor
 

Subinterfaces of Copyable 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 Copyable
 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.
 


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.