|
Evaluating Software Design Patterns — the "Gang of Four" patterns implemented in Java 6 |
||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use ExpressionException | |
---|---|
dk.rode.thesis.builder | Implementations and examples of the Builder design pattern [Gamma95, p.97]. |
dk.rode.thesis.interpreter | Implementations and examples of the Interpreter design pattern [Gamma95, p.243]. |
Uses of ExpressionException in dk.rode.thesis.builder |
---|
Methods in dk.rode.thesis.builder that throw ExpressionException | ||
---|---|---|
TypedFlowExpression<E> |
TypedFlowExpression.add(Expression<? extends E> expression)
|
|
String |
TypedFlowExpression.asSymbol(Context context)
|
|
|
ExpressionBuilder.buildConstantExpression(Class<V> type,
V value)
Builds a new CONSTANT expression. |
|
|
CountingExpressionBuilder.buildConstantExpression(Class<V> type,
V value)
|
|
|
AbstractExpressionBuilder.buildConstantExpression(Class<V> type,
V value)
|
|
void |
ExpressionBuilder.buildExpression(Expression<? extends E> expression)
Adds the constructed expression supplied
as expression to the root
expression constructed by this builder. |
|
void |
AbstractExpressionBuilder.buildExpression(Expression<? extends E> expression)
|
|
TypedExpression<E> |
TypedExpressionBuilder.buildInitialisedFlowExpression(Expression<? extends E>... expressions)
|
|
Expression<E> |
StandardExpressionBuilder.buildInitialisedFlowExpression(Expression<? extends E>... expressions)
|
|
Expression<E> |
ExpressionBuilder.buildInitialisedFlowExpression(Expression<? extends E>... expressions)
Builds a new initialised
FLOW expression. |
|
Expression<E> |
CountingExpressionBuilder.buildInitialisedFlowExpression(Expression<? extends E>... expressions)
|
|
|
ExpressionBuilder.buildVariableExpression(Class<V> type,
String name)
Builds a new VARIABLE expression. |
|
|
CountingExpressionBuilder.buildVariableExpression(Class<V> type,
String name)
|
|
|
AbstractExpressionBuilder.buildVariableExpression(Class<V> type,
String name)
|
|
private
|
Main.create(ComparableExpressionBuilder<E> builder,
Class<E> type,
E value)
Builds: next[20], y = current, (reverse[true] ? |
|
E |
TypedFlowExpression.evaluate(Context context)
|
|
Map<String,Integer> |
CountingExpressionBuilder.getExpressionCount()
Returns a map containing as values the number of times a given expression type has been created, excluding the count for the root
expression. |
|
Expression<E> |
ExpressionBuilder.getRootExpression()
Returns the root expression constructed by this builder. |
|
Expression<E> |
AbstractExpressionBuilder.getRootExpression()
|
|
TypedFlowExpression<E> |
TypedFlowExpression.initialise()
|
|
protected static
|
AbstractExpressionBuilder.initialiseExpressions(Expression<V> expression)
Initialises all initialisable expressions
reachable from the expression supplied as expression that has
not already been initialised. |
Uses of ExpressionException in dk.rode.thesis.interpreter |
---|
Subclasses of ExpressionException in dk.rode.thesis.interpreter | |
---|---|
static class |
BreakExpression.BreakException
A break exception is thrown when an break expression is evaluated. |
Methods in dk.rode.thesis.interpreter that throw ExpressionException | ||
---|---|---|
FlowExpression<E> |
FlowExpression.add(Expression<? extends E> expression)
Adds the expression supplied as expression to
this flow expression. |
|
|
Context.assign(VariableExpression<E> expression,
E value)
Assigns the value supplied as value to the
variable expression supplied
as expression . |
|
String |
TypedExpressionDecorator.asSymbol(Context context)
Returns x , where x is the symbolic
representation of the decorated expression, or if type information
is included, Type{x} , where Type is the simple
name of the type. |
|
String |
SetExpression.asSymbol(Context context)
Returns set[x] , where x is the symbolic
representation of the expression that will determine the
value, or set#123[x] , where 123 is the
identity hash code of the manipulated sequence. |
|
String |
SequenceExpression.asSymbol(Context context)
Returns name , where name is the
actual name of this expression, or
name#123 , where 123 is the identity
hash code of the manipulated sequence. |
|
String |
ReverseExpression.asSymbol(Context context)
Returns reverse[x] , where x is the symbolic
representation of the expression used to determine if the
sequence should be reversed, or reverse#123[x] ,
where 123 is the identity hash code of the
manipulated sequence. |
|
String |
OrExpression.asSymbol(Context context)
Returns (x || y) if short-circuit, or (x | y) ,
where x is the symbolic representation of the
first expression operand and y of the second. |
|
String |
NotExpression.asSymbol(Context context)
Returns {@code (! |
|
String |
NextExpression.asSymbol(Context context)
Returns next[x] , where x is the symbolic
representation of the expression that will determine the
number of times to invoke next() , or next#123[x] ,
where 123 is the identity hash code of the manipulated
sequence. |
|
String |
FlowExpression.asSymbol(Context context)
Returns x, y, z, .. , where x , y ,
z , .., are the symbol representations of the
contained expressions. |
|
String |
Expression.asSymbol(Context context)
Returns a short symbolic representation of this expression that describes it in a concise form. |
|
String |
EqualExpression.asSymbol(Context context)
Returns x == y , where x is the symbolic
representation of the first expression operand and y
of the the second. |
|
String |
ConditionalExpression.asSymbol(Context context)
Returns {@code (c ? |
|
String |
CompareExpression.asSymbol(Context context)
Returns x operator y , where x is the symbolic
representation of the first expression operand, y
of the the second, and operator is the operator used
for the comparison. |
|
String |
BreakExpression.asSymbol(Context context)
Returns either exit or break[x] , where
x is the symbol representation of the target expression
used, if any. |
|
String |
AssignmentExpression.asSymbol(Context context)
Returns x = y , where x is the symbolic
representation of the first expression operand and y
of the the second. |
|
String |
AndExpression.asSymbol(Context context)
Returns (x && y) if short-circuit, or (x & y) ,
where x is the symbolic representation of the
first expression operand and y of the second. |
|
static StringBuilder |
Expression.SymbolIdiom.asSymbol(Context context,
Expression<?> parent,
Expression<?> child)
See Expression.asSymbol(Context) . |
|
static StringBuilder |
Expression.SymbolIdiom.asSymbol(Context context,
Expression<?> parent,
Expression<?> child,
StringBuilder sb)
See Expression.asSymbol(Context) . |
|
protected String |
BinaryExpression.asSymbol(Context context,
String separator)
Returns x separator y , where x is the symbolic
representation of the first expression operand and y
of the the second. |
|
protected StringBuilder |
BinaryExpression.asSymbol(Context context,
String separator,
StringBuilder sb)
Returns x separator y , where x is the symbolic
representation of the first expression operand and y
of the the second. |
|
private
|
Main.create1(Sequence<E> sequence,
Class<E> type,
E value,
Context context)
Creates: next[20], y = current, (reverse[true] ? |
|
private
|
Main.create2(Sequence<E> sequence,
Class<E> type,
E value,
Context context)
Creates: next[value], foo = Integer{next[(boo ? |
|
private
|
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
|
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: ((! |
|
E |
VariableExpression.evaluate(Context context)
|
|
E |
TypedExpressionDecorator.evaluate(Context context)
|
|
E |
SetExpression.evaluate(Context context)
|
|
Boolean |
ReverseExpression.evaluate(Context context)
|
|
E |
ResetExpression.evaluate(Context context)
|
|
Boolean |
OrExpression.evaluate(Context context)
|
|
Boolean |
NotExpression.evaluate(Context context)
|
|
E |
NextExpression.evaluate(Context context)
|
|
E |
FlowExpression.evaluate(Context context)
|
|
E |
Expression.evaluate(Context context)
Evaluates this expression and returns the result. |
|
Boolean |
EqualExpression.evaluate(Context context)
|
|
E |
CurrentExpression.evaluate(Context context)
|
|
E |
ConditionalExpression.evaluate(Context context)
|
|
Boolean |
CompareExpression.evaluate(Context context)
|
|
E |
BreakExpression.evaluate(Context context)
|
|
E |
AssignmentExpression.evaluate(Context context)
|
|
Boolean |
AndExpression.evaluate(Context context)
|
|
|
Context.getVariable(Class<E> type,
String name)
Returns the variable or
constant stored in
this context associated with the type and name
supplied as type and name , respectively. |
|
TypedExpressionDecorator<E> |
TypedExpressionDecorator.initialise()
|
|
InitialisableExpression<E> |
InitialisableExpression.initialise()
Initialises this expression before evaluation. |
|
FlowExpression<E> |
FlowExpression.initialise()
|
|
|
Interpreter.interpret(Context context,
Expression<E> expression)
Interpret the expression syntax tree having
the root supplied as expression , and returns the
result. |
|
|
Interpreter.interpret(Context context,
Expression<E> expression,
Class<? super E> type)
Interpret the expression syntax tree having
the root supplied as expression , and returns the
result. |
|
Object |
Context.lookup(String name)
Returns the value currently associated with the variable expression
identified by the variable name supplied as name . |
|
|
Context.lookup(VariableExpression<E> expression)
Returns the value currently associated with the variable expression
supplied as expression . |
|
Class<?> |
Context.lookupType(String name)
Returns the type of the value associated with the variable expression
identified by the variable name supplied as name ,
or throws an ExpressionException in case no
such value exist. |
|
void |
Context.register(VariableExpression<?> expression)
Registers the variable expression
supplied as expression in this context with no
associated value. |
|
Gunni Rode / rode.dk | ||||||||
PREV NEXT | FRAMES NO FRAMES |