TypedExpressionBuilder (Evaluating Software Design Patterns

Overview

Package

Class

Use

Tree

Index

Help

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

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

dk.rode.thesis.builder
Class TypedExpressionBuilder<E>

java.lang.Object
  dk.rode.thesis.builder.AbstractExpressionBuilder<E>
      dk.rode.thesis.builder.TypedExpressionBuilder<E>


Type Parameters:: E - The type of value the evaluation of constructed expressions produces.

All Implemented Interfaces:: ExpressionBuilder<E>, Copyable<ExpressionBuilder<E>>, StrictCopyable<ExpressionBuilder<E>>

Direct Known Subclasses:: TypedComparableExpressionBuilder

@Participant(value="ConcreteBuilder") public class TypedExpressionBuilder<E>
extends AbstractExpressionBuilder<E>
implements ExpressionBuilder<E>
extends AbstractExpressionBuilder<E>
implements ExpressionBuilder<E>

A typed expression builder builds typed expressions.

An actual builder must be supplied at construction to perform the construction of expressions, but this builder will use a local context.

Implementation notes:
This builder uses covariant types for the created expressions where possible. The expression type is narrowed to TypedExpression. Narrowing it even further, i.e. to the exact expression type, is not always possible if the implementation types are hidden: how can the builder cast to the exact type if only the interfaces are known? As TypedExpression has a concrete decorator class, TypedExpressionDecorator, the narrowing to TypedExpression can be performed because an implementation is always known.

This presents a problem with the buildFlowExpression() method because it already has a narrowed return type, namely FlowExpression, and because it is created via composition; this builder has no control over the creation process. The FlowExpression type must not be lost, or the functionality offered by it cannot be used by the client. This is not a problem for the buildInitialisedFlowExpression(Expression...) method, because it returns an Expression type like most other builder methods.

Inheritance, proxies, and/or decoration/adaptation must be used. Dynamic proxies can only be used of an interface is used. Decoration and adaptation can only be used if a non-final type is known. Inheritance only if a concrete class is known, regardless if an interface is known. As FlowExpression is concrete, but non final, we have to make a decorator wrapping the created FlowExpression, overriding all methods, and adapting it to the TypedExpression interface. This is tedious at best, but cannot be avoided. The decorator class is TypedFlowExpression.

Dynamic proxies created by a ProxyFactory cannot be used for several reasons. First, FlowExpression is a concrete type, so casting a proxy into the return type required by the buildFlowExpression() method will cause a class cast exception. Secondly, FlowExpression already implements InitialisableExpression that use covariant return types to refine its copy() method. TypedExpression also use covariant return types to to refine its copy() method. This works for FlowExpression because it is a concrete type known to implement both interfaces, but cannot work for dynamic proxies because if incompatible return types. See the JavaDoc for TypedFlowExpression.copy() to get an idea of the different narrowed return types that fits the TypedFlowExpression class.

Instead of inheritance, this builder relies on composition: the actual builder to construct the expressions is supplied at construction time. This can be viewed as an application of the Decorator pattern, and perhaps also as a degenerate version of the Bridge pattern where the abstraction and implementation share the same interface.

Author:: Gunni Rode / rode.dk

Field Summary
`protected ExpressionBuilder<E>`	`builder` The expression builder used to construct the expressions.
`protected Class<E>`	`type` A class literal representing the type of value the evaluation of constructed expressions produces.

Fields inherited from class dk.rode.thesis.builder.AbstractExpressionBuilder
`context, root, sequence`

Constructor Summary
`TypedExpressionBuilder(Class<E> type, ExpressionBuilder<E> builder)` Constructor.
`TypedExpressionBuilder(TypedExpressionBuilder<E> builder)` Copy constructor.

Method Summary

TypedExpression<Boolean> buildAndExpression(Expression<Boolean> first, Expression<Boolean> second)
Builds a new short-circuit AND expression.

TypedExpression<E> buildAssignmentExpression(VariableExpression<E> variable, Expression<? extends E> expression)
Builds a new ASSIGNMENT expression.

TypedExpression<E> buildBreakExpression(TypedExpression<E> expression)
Builds a new BREAK expression.

TypedExpression<E> buildConditionalExpression(Expression<Boolean> condition, Expression<? extends E> first, Expression<? extends E> second)
Builds a new CONDITIONAL expression.

TypedExpression<E> buildCurrentExpression()
Builds a new CURRENT expression.

TypedExpression<Boolean> buildEqualExpression(Expression<?> first, Expression<?> second)
Builds a new EQUAL expression.

TypedFlowExpression<E> buildFlowExpression()
Builds a new uninitialised FLOW expression.

TypedExpression<E> buildInitialisedFlowExpression(Expression<? extends E>... expressions)
Builds a new initialised FLOW expression.

TypedExpression<E> buildNextExpression(Expression<? extends Number> count)
Builds a new NEXT expression.

TypedExpression<Boolean> buildNonShortCircuitAndExpression(Expression<Boolean> first, Expression<Boolean> second)
Builds a new non short-circuit AND expression.

TypedExpression<Boolean> buildNonShortCircuitOrExpression(Expression<Boolean> first, Expression<Boolean> second)
Builds a new non short-circuit OR expression.

TypedExpression<Boolean> buildNotExpression(Expression<Boolean> expression)
Builds a new NOT expression.

TypedExpression<Boolean> buildOrExpression(Expression<Boolean> first, Expression<Boolean> second)
Builds a new short-circuit OR expression.

TypedExpression<E> buildResetExpression()
Builds a new RESET expression.

TypedExpression<Boolean> buildReverseExpression(Expression<Boolean> reverse)
Builds a new REVERSE expression.

TypedExpressionBuilder<E> copy()
Returns a deep copy of this object.

protected static



<T> TypedExpression<T>

getTypedExpression(Expression<T> expression,
                   Class<T> type)

Returns a typed expression of the typed supplied as type based on expression.

Class<E> type()
Returns a class literal representing the type of value the evaluation of constructed expressions produces.

Methods inherited from class dk.rode.thesis.builder.AbstractExpressionBuilder
`buildConstantExpression, buildExpression, buildVariableExpression, equals, getContext, getRootExpression, getSequence, hashCode, initialiseExpressions, toString`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface dk.rode.thesis.builder.ExpressionBuilder
`buildConstantExpression, buildExpression, buildVariableExpression, getRootExpression, getSequence`

Field Detail

builder

protected final ExpressionBuilder<E> builder

The expression builder used to construct the expressions.

Never null.

type

protected final Class<E> type

A class literal representing the type of value the evaluation of constructed expressions produces. Supplied at construction time, never null.

Constructor Detail

TypedExpressionBuilder

public TypedExpressionBuilder(Class<E> type,
                              ExpressionBuilder<E> builder)

Constructor.

The same sequence as used by builder will be used by this builder, but a new local context will be created and used.

Parameters:: type - The class literal representing the type of value the evaluation of constructed expressions produces; cannot be null.; builder - The actual builder to use; cannot be null.
Throws:: NullPointerException - If either argument is null.

TypedExpressionBuilder

public TypedExpressionBuilder(TypedExpressionBuilder<E> builder)

Copy constructor.

The same sequence as used by builder will be used by this builder, but a new local context will be created and used. The root expression from builder is not copied. Hence, this builder is ready to construct new expressions, and return a unique root expression from AbstractExpressionBuilder.getRootExpression().

Parameters:: builder - The builder to copy; cannot be null.
Throws:: NullPointerException - If builder is null.

Method Detail