0% found this document useful (0 votes)

474 views295 pages

GoF Patterns in Expression Tree Case Study

This document provides an overview of a case study on using Gang of Four (GoF) design patterns to develop an object-oriented expression tree processing application. It describes the goals of the case study, which include developing the application using design patterns and frameworks, comparing object-oriented and non-object-oriented approaches, and demonstrating scope, commonality and variability analysis. It also provides context on expression trees and outlines both proper and improper object-oriented designs for such an application.

Uploaded by

Bijal Patel

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

474 views295 pages

GoF Patterns in Expression Tree Case Study

Uploaded by

Bijal Patel

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

A Case Study of Gang of Four (GoF) Patterns: Part 1

d.schmidt@vanderbilt.edu www.dre.vanderbilt.edu/~schmidt Professor of Computer Science Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Case Study: Expression Tree Processing App

Goals Develop an OO expression tree processing app using patterns & frameworks Compare/contrast nonobject-oriented & objectoriented approaches
Expression_Tree

Component_Node

Composite_ Unary_Node

Leaf_Node

1 Tree Node 0|1|2

Composite_Binary _Node

Composite_Negate _Node

Composite_ Add_Node Composite_ Multiply_Node

Composite_ Subtract_Node Composite_ Divide_Node

4 Despite decades of OO emphasis, algorithmic decomposition is still common

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Case Study: Expression Tree Processing App

Goals Develop an OO expression tree processing app using patterns & frameworks Compare/contrast nonobject-oriented & objectoriented approaches Demonstrate Scope,
Binary Nodes

Commonality, & Variability (SCV) analysis in the context

of a concrete example

Unary Node Leaf Nodes

SCV is a systematic software reuse method

www.cs.iastate.edu/~cs309/references/CoplienHoffmanWeiss_CommonalityVariability.pdf 5

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Case Study: Expression Tree Processing App

Goals Develop an OO expression tree processing app using patterns & frameworks Compare/contrast nonobject-oriented & objectoriented approaches Demonstrate Scope,
Expression_Tree expr_tree = ; Print_Visitor print_visitor; C++11 range-based for loop for (auto &iter : expr_tree) iter.accept(print_visitor);

Commonality, & Variability

(SCV) analysis in the context of a concrete example

Illustrate how patternoriented OO frameworks can be implemented in C++ & Java

ExpressionTree exprTree = ; ETVisitor printVisitor = new PrintVisitor(); Java for-each loop for (ComponentNode node : exprTree) node.accept(printVisitor);

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Expression Tree Processing App

Expression trees consist of nodes containing operators & operands
Binary Nodes

7 See en.wikipedia.org/wiki/Binary_expression_tree for expression tree info

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Expression Tree Processing App

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Expression Tree Processing App

Expression trees consist of nodes containing operators & operands Operators have different precedence levels, different associativities, & different arities Operands can be integers, doubles, variables, etc. We'll just handle integers in this example, though it can easily be extended
Unary Operator Integer Operands Binary Operators

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Expression Tree Processing App

Trees may be evaluated via different traversal orders, e.g., in-order iterator = -5*(3+4) pre-order iterator = *-5+34 post-order iterator = 5-34+* level-order iterator = *-+534

14 See en.wikipedia.org/wiki/Binary_expression_tree#Traversal for more info

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Expression Tree Processing App

Trees may be evaluated via different traversal orders, e.g., in-order iterator = -5*(3+4) pre-order iterator = *-5+34 post-order iterator = 5-34+* level-order iterator = *-+534 The evaluation step may perform various actions, e.g.: Print contents of expression tree Return the value" of the expression tree Perform semantic analysis & optimization Generate code etc.
15

1. S = [5] 2. S = [-5] 3. S = [-5, 3] 4. S = [-5, 3, 4] 5. S = [-5, 7] 6. S = [-35]

push(node.item()) push(-pop()) push(node.item()) push(node.item()) push(pop()+pop()) push(pop()*pop())

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

How Not to Design an Expression Tree Application

Apply algorithmic decomposition Top-down design based on the
actions performed by the system
Start

A
Yes Verbose? No Verbose Prompt Succinct Prompt

Initialize Prompt User

Generally follows a divide &

conquer strategy based on the actions

A
Read Expr Build Tree Process Tree

i.e., general actions are

iteratively/recursively decomposed into more specific ones

B
Yes Print? No Print Tree Yes Eval Tree

B
No EOF? Yes End

Eval? No

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

How Not to Design an Expression Tree Application

Apply algorithmic decomposition Top-down design based on the
actions performed by the system
typedef struct Tree_Node { ... } Tree_Node; Well explore this shortly void prompt_user(int verbose); char *read_expr(FILE *fp); Tree_Node *build_tree (const char *expr); void process_tree (Tree_Node *root, FILE *fp); void eval_tree (Tree_Node *root, FILE *fp); void print_tree (Tree_Node *root, FILE *fp); ... Well explore this shortly 21

Generally follows a divide &

conquer strategy based on the actions

i.e., general actions are

iteratively/recursively decomposed into more specific ones

Primary design components e.g., C functions

correspond to processing steps in execution sequence

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Algorithmic Decomposition of Expression Tree

A typical algorithmic decomposition for implementing expression trees
Type tag typedef struct Tree_Node { enum { NUM, UNARY, BINARY } tag_; short use_; Reference count union { char op_[2]; Node value int num_; } o; #define num_ o.num_ #define op_ o.op_ union { struct Tree_Node *unary_; struct { struct Tree_Node *l_, *r_;} binary_; } c; #define unary_ c.unary_ Node child(ren) #define binary_ c.binary_ } Tree_Node; 22

would use a C struct/union to represent the main data structure

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Algorithmic Decomposition of Expression Tree

A typical algorithmic decomposition for implementing expression trees
would use a C struct/union to represent the main data structure
Memory Layout
tag_ use_ op_ num_

typedef struct Tree_Node { enum { NUM, UNARY, BINARY } tag_; short use_; union { char op_[2]; int num_; } o; #define num_ o.num_ #define op_ o.op_ union { struct Tree_Node *unary_; struct { struct Tree_Node *l_, *r_;} binary_; } c; #define unary_ c.unary_ #define binary_ c.binary_ } Tree_Node; 23

Class Relationships 1 Tree Node 0|1|2

unary_

unary_

binary_

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary
Limitations with algorithmic decomposition

Tree_Node data structure is passive & functions do all the real work

Complexity in (variable) algorithms rather than (stable) structure

void print_tree(Tree_Node *root, FILE *fp) { switch(root->tag_) { case NUM: fprintf(fp, "%d", root->num_); break; case UNARY: fprintf(fp, "(%s", root->op_[0]); Easy to make mistakes print_tree(root->unary_, fp); when switching on type tags fprintf(fp, ")"); break; case BINARY: fprintf(fp, "("); Tailoring the app for print_tree(root->binary_.l_, fp); specific requirements & fprintf(fp, "%s", root->op_[0]); specifications impedes print_tree(root->binary_.r_, fp); reuse & complicates fprintf(fp, ")"); break; software sustainment ... } 30 modeling, design, & implementation Overcoming limitations requires rethinking

A Case Study of Gang of Four (GoF) Patterns: Part 3

d.schmidt@vanderbilt.edu www.dre.vanderbilt.edu/~schmidt Professor of Computer Science Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA

Douglas C. Schmidt

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Topics Covered in this Part of the Module

Composite_ Unary_Node

Leaf_Node

Composite_Binary _Node

Composite_Negate _Node

Composite_ Add_Node Composite_ Multiply_Node

Composite_ Subtract_Node Composite_ Divide_Node

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

How to Design an Expression Tree Processing App

Apply an Object-Oriented (OO) design based on modeling classes & objects in the application domain

Binary Nodes

Unary Node

Leaf Nodes

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

How to Design an Expression Tree Processing App

Apply an Object-Oriented (OO) design based on modeling classes & objects in the application domain Employ hierarchical data abstraction where design components are based on stable class & object roles & relationships Rather than functions corresponding to actions
Post_Order_ET _Iterator_Impl In_Order_ET _Iterator_Impl ET_Iterator

ET_Iterator_Impl

Level_Order_ET _Iterator_Impl

Pre_Order_ET _|Iterator_Impl

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

How to Design an Expression Tree Processing App

Apply an Object-Oriented (OO) design based on modeling classes & objects in the application domain Employ hierarchical data abstraction where design components are based on stable class & object roles & relationships Associate actions with specific objects and/or classes of objects Emphasize high cohesion & low coupling
Event_Handler

ET_Event_Handler handle_input() prompt_user() get_input() make_command() execute_command()

Verbose_ET_ Event_Handler prompt_user() make_command()

Succinct_ET_ Event_Handler prompt_user() make_command()

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

How to Design an Expression Tree Processing App

Apply an Object-Oriented (OO) design based on modeling classes & objects in the application domain Employ hierarchical data abstraction where design components are based on stable class & object roles & relationships Associate actions with specific objects and/or classes of objects Group classes & objects in accordance to patterns & combine them to form
Reactor

Reactor
Event_Handler

Singleton
Options

ET_Command_Factory

ET_Event_Handler

ET_Context

<< create >>

Verbose_ET_ Event_Handler

Succinct_ET_ Event_Handler

ET_Command

Leaf_Node

Composite_Binary _Node

Composite_Negate _Node

Composite_ Add_Node Composite_ Multiply_Node

Composite_ Subtract_Node Composite_ Divide_Node

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

An OO Expression Tree Design Method

Start with object-oriented (OO) modeling of the expression tree application domain
Applicationdependent steps
Composite
Expression_Tree Component_Node

Model a tree as a collection of nodes

Bridge

Composite_ Unary_Node

Leaf_Node

Represent nodes as a hierarchy, capturing properties of each node e.g., arities

Composite_Binary _Node

Composite_Negate _Node

Composite_ Add_Node

Composite_ Multiply_Node

Composite_ Subtract_Node

Composite_ Divide_Node

Applicationindependent steps

Conduct Scope, Commonality, & Variability analysis to determine stable interfaces & extension points Apply Gang of Four (GoF) patterns to guide efficient & extensible development of framework components Integrate pattern-oriented language/library features w/frameworks

en.wikipedia.org/wiki/Design_Patterns40 has info on Gang of Four (GoF) book

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

C++11 range-based for loop

std::for_each (expr_tree.begin(), expr_tree.end(), [&print_visitor] (const Expression_Tree &t) { t.accept(print_visitor);}); for (auto &iter : expr_tree) iter.accept(print_visitor);

44 See en.wikipedia.org/wiki/C++11 for info on C++11

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Java Pattern-Oriented Language/Library Features

Over time, common patterns become institutionalized as programming language features
ExpressionTree exprTree = ; ETVisitor printVisitor = new PrintVisitor(); for (ComponentNode node : exprTree) node.accept(printVisitor); Java for-each loop (assumes tree implements Iterable)

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Java Pattern-Oriented Language/Library Features

Over time, common patterns become institutionalized as programming language features
ExpressionTree exprTree = ; ETVisitor printVisitor = new PrintVisitor(); for (ComponentNode node : exprTree) node.accept(printVisitor); for (Iterator<ExpressionTree> itr = exprTree.iterator(); itr.hasNext(); ) iter.next().accept (printVisitor);

Java iterator style

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

OO designs are characterized by structuring software architectures around objects/classes in domains Rather than on actions performed by the software

Summary
<< accept >>

ET_Visitor

Evaluation_Visitor

Print_Visitor

Expression_Tree << create >>

Component_Node

ET_Iterator

ET_Iterator_Impl

LQueue

Level_Order_ET _Iterator_Impl In_Order_ET _Iterator_Impl Post_Order_ET _Iterator_Impl Pre_Order_ET _Iterator_Impl

std::stack

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

OO designs are characterized by structuring software architectures around objects/classes in domains Rather than on actions performed by the software

Summary

Systems evolve & functionality changes, but well-defined objects & class roles & relationships are often relatively stable over time

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

OO designs are characterized by structuring software architectures around objects/classes in domains Rather than on actions performed by the software

Summary
Expression_Tree

Component_Node

Systems evolve & functionality changes, but well-defined objects & class roles & relationships are often relatively stable over time To obtain flexible & reusable software, therefore, its better to base the structure on objects/classes rather than on actions

Composite_ Unary_Node

Leaf_Node

Composite_Binary _Node

Composite_Negate _Node

Composite_ Add_Node Composite_ Multiply_Node

Composite_ Subtract_Node Composite_ Divide_Node

A Case Study of Gang of Four (GoF) Patterns: Part 4

d.schmidt@vanderbilt.edu www.dre.vanderbilt.edu/~schmidt Professor of Computer Science Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA

Behavioral Interpreter Template Method Chain of Responsibility Command Iterator Mediator Memento Observer State Strategy Visitor

en.wikipedia.org/wiki/Design_Patterns52 has info on Gang of Four (GoF) book

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Design Problems & Pattern-Oriented Solutions

Design Problems & Pattern-Oriented Solutions

Binary Nodes

Design Problem

Pattern(s)

Ensuring correct protocol State for processing commands Structuring the application event flow Reactor Template Method & Strategy Singleton Adapter

Unary Node Leaf Nodes

Supporting multiple operation modes Centralizing access to global resources Eliminating loops via the STL std::for_each() algorithm

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Design Problems & Pattern-Oriented Solutions

Binary Nodes

Design Problem

Pattern(s)

Ensuring correct protocol State for processing commands Structuring the application event flow Reactor Template Method & Strategy Singleton Adapter

Unary Node Leaf Nodes

Supporting multiple operation modes Centralizing access to global resources Eliminating loops via the STL std::for_each() algorithm

Supporting multiple operation modes Centralizing access to global resources Eliminating loops via the STL std::for_each() algorithm

64 Naturally, these patterns apply to more than expression tree processing apps!

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF patterns provide elements of reusable object-oriented software that address limitations with algorithmic decomposition

Summary

A Case Study of Gang of Four (GoF) Patterns : Part 5

d.schmidt@vanderbilt.edu www.dre.vanderbilt.edu/~schmidt Professor of Computer Science Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA

Douglas C. Schmidt

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Topics Covered in this Part of the Module

Composite_ Unary_Node

Leaf_Node

Composite_Binary _Node

Composite_Negate _Node

Composite_ Add_Node Composite_ Multiply_Node

Composite_ Subtract_Node Composite_ Divide_Node

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Tree Structure & Access Patterns

P urpose: Define the key internal data structure for the expression tree & simplify access to this data structure

Expression_Tree

Component_Node

Composite_ Unary_Node

Leaf_Node

Composite_Binary _Node

Composite_Negate _Node

Composite_ Add_Node

Composite_ Multiply_Node

Composite_ Subtract_Node

Composite_ Divide_Node

Bridge

Goals Support physical structure of expression tree e.g., binary/unary operators & operands Provide hook methods that enable arbitrary operations on tree nodes Constraints/forces Treat operators & operands uniformly No distinction between one vs. many to avoid special cases

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Component_Node Class Interface

Abstract base class for composable expression tree node objects Interface virtual virtual int virtual Component_Node * virtual Component_Node * virtual void
Virtual destructor ensures nodes are all deleted properly

~Component_Node()=0 item() const left() const right() const accept(ET_Visitor &visitor) const
This hook method plays an essential role in I terator & Visitor patterns (covered later)

Subclasses Leaf_Node, Composite_Unary_Node, Composite_Binary_Node, etc.

Commonality: Base class interface used by all nodes in an expression tree Variability: Each subclass defines state & method implementations that
are specific for the various types of nodes 76

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Component_Node Class Hierarchy

Note the inherent recursion in this hierarchy
Component_Node e.g., Leaf_Node is a Component_Node

Composite_ Unary_Node

Leaf_Node

e.g., Composite_Unary_Node is a Component_Node & also has a Component_Node

Composite_Binary _Node

Composite_Negate _Node

Composite_ Add_Node e.g., Composite_Binary_Node is a Composite_Unary_Node & also has a Component_Node Composite_ Multiply_Node

Composite_ Subtract_Node Composite_ Divide_Node

Eliminates need for type tags & switch 77 statements by treating nodes uniformly!

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Composite
Intent Applicability Objects must be composed recursively

GoF Object structural

Treat individual objects & multiple, recursively-composed objects uniformly

and no distinction between individual & composed elements and objects in structure can be treated uniformly Structure
e.g., Component_Node

e.g., Leaf_Node

Build an expression tree based on recursively-composed objects ComponentNode l1 = new LeafNode(5); ComponentNode l2 = new LeafNode(3); u1 ComponentNode l3 = new LeafNode(4); ComponentNode u1 = new CompositeNegateNode(l1); ComponentNode b1 = new CompositeAddNode(l2, l3); ComponentNode b2 = new CompositeMultiplyNode(u1, b1); b2

Goals Help encapsulate sources of variability in expression tree construction & use
Expression_Tree expr_tree (new Composite_Add_Node (new Leaf_Node (3), new Leaf_Node (4)));

Create an interface class (Expression_Tree) used by clients
Expression _Tree

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution: Decouple Interface & Implementation(s)

Create an interface class (Expression_Tree) used by clients & an implementor hierarchy (Component_Node et al) that encapsulates variability
Interface class can use a C++ std::shared_ptr reference count object to help automate memory management
Expression _Tree

Component _Node

Composite_ Unary_Node

Leaf_Node

Composite_ Binary_Node

Composite_ Negate_Node

Composite_ Add_Node

Composite_ Subtract_Node Composite_ Divide_Node

Composite_ Multiply_Node

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution: Decouple Interface & Implementation(s)

Create an interface class (Expression_Tree) used by clients & an implementor hierarchy (Component_Node et al) that encapsulates variability
Expression _Tree

Component _Node

Composite_ Unary_Node

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Bridge
Bridge example in C++

GoF Object Structural

Separate expression tree interface from the composite node implementations class Expression_Tree { root_ manages lifecycle of pointer parameter public: Expression_Tree(Component_Node *root): root_(root) {}
Interface forwards to implementor via shared_ptr

... void accept(ET_Visitor &v) { root_->accept(v); } private: std::shared_ptr <Component_Node> root_;

C++11/Boost smart pointer that handles reference counting

97 See en.wikipedia.org/wiki/Smart_pointer#shared_ptr_and_weak_ptr for more

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Bridge
Bridge example in C++

GoF Object Structural

Separate expression tree interface from the composite node implementations class Expression_Tree { public: Expression_Tree(Component_Node *root): root_(root) {} ... void accept(ET_Visitor &v) { root_->accept(v); } private: std::shared_ptr <Component_Node> root_; ...
expr_tree manages lifecycle of composite via Bridge pattern

Expression_Tree expr_tree (new Composite_Multiply_Node(u1, b1));

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Bridge
Consequences + Abstraction interface & implementor hierarchy are decoupled + Implementors can vary dynamically + Enables efficient use of value-based STL algorithms & containers

GoF Object Structural

One-size-fits-all abstraction & implementor interfaces

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Bridge
Consequences + Abstraction interface & implementor hierarchy are decoupled + Implementors can vary dynamically + Enables efficient use of value-based STL algorithms & containers

GoF Object Structural

One-size-fits-all abstraction & implementor interfaces Implementation

Sharing implementors & reference counting

e.g., C++11/Boost shared_ptr

Creating the right implementor Often addressed by using factories Not as widely used in Java as in C++
100

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Bridge
Consequences + Abstraction interface & implementor hierarchy are decoupled + Implementors can vary dynamically + Enables efficient use of value-based STL algorithms & containers

GoF Object Structural

Known Uses

ET++ Window/WindowPort libg++ Set/{LinkedList,

HashTable}

AWT Component/
ComponentPeer

One-size-fits-all abstraction & implementor interfaces Implementation

Java Socket/SocketImpl ACE Reactor framework

Sharing implementors & reference counting

e.g., C++11/Boost shared_ptr

Creating the right implementor Often addressed by using factories Not as widely used in Java as in C++
101

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary of Tree Structure & Access Patterns

Composite is used to define internal data structure for the expression tree processing app & Bridge simplifies access to this data structure for C++ code

Expression_Tree

Component_Node

Composite_ Unary_Node

Leaf_Node

Composite_Binary _Node

Composite_Negate _Node

Composite_ Add_Node

Composite_ Multiply_Node

Composite_ Subtract_Node

Composite_ Divide_Node

Bridge

Composite

102 of a pattern compound Bridge Composite is an example

A Case Study of Gang of Four (GoF) Patterns : Part 6

d.schmidt@vanderbilt.edu www.dre.vanderbilt.edu/~schmidt Professor of Computer Science Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA

Douglas C. Schmidt

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Topics Covered in this Part of the Module

In_Order_ Uninitialized_ State make_tree() ET_Interpreter _Context

ET_Interpreter
Symbol

Add

Subtract

Negate

Multiply

Divide

104

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Tree Creation Patterns

P urpose: Parse user input expresion & create the internal data structure for the expression tree
Expression_Tree ET_Context ET_Interpreter_Context

Interpreter
<< use >>

ET_Interpreter << build >> Component_Node Symbol

Leaf_Node

Composite_ Binary_Node

Composite_ Unary_Node <<build>>

Number

Operator

Unary_Operator

Composite_ Add_Node

Composite_ Subtract_Node

Composite_ Negate_Node

Add

Subtract

Negate

Composite_ Multiply_Node

Composite_ Divide_Node

<<build>>

Multiply

Divide

Composite

Builder

105 of patterns involved in this design There are many classes, but only a handful

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Problem: Parsing Expressions & Creating an Expression Tree

Goals Simplify & centralize the creation of all nodes in the composite expression tree

in-order expression

Use an interpreter to create a parse tree corresponding to user input expression
ET_Interpreter In_Order_ Uninitialized_ State make_tree()

Symbol

ET_Interpreter _Context

Operator

Unary_Operator

Multiply

Negate

Number

Add

109

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution: Build Expression Tree Using Interpreter

Use an interpreter to create a parse tree corresponding to user input expression This parse tree is then traversed to build the appropriate type of nodes in the corresponding
ET_Interpreter In_Order_ Uninitialized_ State make_tree()

Symbol

ET_Interpreter _Context

expression tree

Operator

Unary_Operator

We create the entire parse tree to enable optimizations (as a future extension)

Multiply

Negate

Number

Add

<<build>>

110

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Interpreter Class Interface

Transforms expressions into a parse tree & then generates the
corresponding expression tree
Interface virtual ~ET_Interpreter() Expression_Tree interpret(ET_Interpreter_Context &context, const std::string &input) <<uses>> ET_Interpreter_Context() ~ET_Interpreter_Context() int get(std::string variable) void set(std::string variable, int value) void print() The context can be used to implement void reset() setters/getters for variable leaf nodes

111

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Interpreter Class Interface

Abstract base class of all parse tree nodes

Symbol(Symbol *left, Symbol *right) virtual ~Symbol() virtual int precedence()=0 virtual Component_Node * build()=0

This method is used to build a component node corresponding to the expression parse tree node 112

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Interpreter Class Interface

Transforms expressions into a parse tree & then generates the
corresponding expression tree
Interface virtual ~ET_Interpreter() Expression_Tree interpret(ET_Interpreter_Context &context, const std::string &input) <<uses>> ET_Interpreter_Context() <<creates>> ~ET_Interpreter_Context() Symbol(Symbol *left, int get(std::string variable) Symbol *right) void set(std::string variable, virtual ~Symbol() int value) virtual int precedence()=0 void print() virtual void reset() Component_Node * build()=0

Commonality: Provides a common interface building parse trees &

expression trees from user input expressions

Variability: The structure of the parse trees & expression trees can vary
depending on the format & contents of the expression input 113

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

+ Simple grammars are easy to change & extend e.g., All rules represented by distinct classes in a consistent & orderly manner + Adding another rule adds another class Complex grammars hard to create & maintain e.g., More inter-dependent rules yield more inter-dependent classes

116 approach (e.g., parser generators) Complex grammars may require different

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Interpreter
Consequences

Builder example in C++ The interpret() method builds composite expression tree from parse tree
Expression_Tree ET_Interpreter::interpret (ET_Interpreter_Context &context, const std::string &input) { ... return Expression_Tree(parse_tree.back()->build()); Invoke a recursive expression tree build, starting with the root symbol in parse tree created by the interpreter

120

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Builder

GoF Object Creational

Component_Node * Multiply::build() { return new Composite_Multiply_Node (left_->build(), right_->build()); } Build equivalent component nodes Component_Node *Number::build() { return new Leaf_Node(item_); } 121

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Builder
Consequences + Isolates code for construction & representation

GoF Object Creational

+ Can vary a product's internal representation

+ Finer control over the construction process May involve a lot of classes

122

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Builder
Consequences + Isolates code for construction & representation

GoF Object Creational

+ Can vary a product's internal representation

+ Finer control over the construction process May involve a lot of classes Implementation The Builder pattern is a factory pattern with a mission A Builder pattern implementation exposes itself as a factory It goes beyond conventional factory patterns by connecting various implementations together
123

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Builder
Consequences + Isolates code for construction & representation

GoF Object Creational

Known Uses ET++ RTF converter application Smalltalk-80 ACE Service Configurator framework

+ Can vary a product's internal representation

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary of Tree Creation Patterns

Interpreter & Builder patterns create internal data
structure for expression tree from user input
Expression_Tree ET_Context

Interpreter
<< use >> ET_Interpreter_Context

ET_Interpreter << build >> Component_Node Symbol

Leaf_Node

Composite_ Binary_Node

Composite_ Unary_Node <<build>>

Number

Operator

Unary_Operator

Composite_ Add_Node

Composite_ Subtract_Node

Composite_ Negate_Node

Add

Subtract

Negate

Composite_ Multiply_Node

Composite_ Divide_Node

<<build>>

Multiply

Divide

Composite

Builder

Interpreter, Builder, & Composite125 are powerful pattern sequence

A Case Study of Gang of Four (GoF) Patterns : Part 7

d.schmidt@vanderbilt.edu www.dre.vanderbilt.edu/~schmidt Professor of Computer Science Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA

Douglas C. Schmidt

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Topics Covered in this Part of the Module

Describe the object-oriented (OO) expression tree case study Evaluate the limitations with algorithmic design techniques Present an OO design for the expression tree processing app Summarize the patterns in the expression tree design Explore patterns for Tree structure & access Tree creation Tree traversal for (auto iter = expr_tree.begin(); iter != expr_tree.end(); ++iter) (*iter).accept(print_visitor);
127

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Tree Traversal Patterns

P urpose: Traverse the expression tree & perform designated operations
<< accept >>

Visitor
ET_Visitor

Expression_Tree

Component_Node

Iterator

<< create >> Evaluation_Visitor Print_Visitor

ET_Iterator

ET_Iterator_Impl

std::queue

Level_Order_ET _Iterator_Impl In_Order_ET_ Iterator_Impl Post_Order_ ET_Iterator_Impl Pre_Order_ET _Iterator_Impl std::stack

Prototype

128 Patterns decouple expression tree structure from operations performed on it

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Goals

Problem: Extensible Expression Tree Operations

Operation 2: Evaluate the yield of the nodes in the tree Operation 1: Print all the values of the nodes in the tree

Create a framework for performing operations that affect nodes in a tree

Binary Nodes

Unary Node Leaf Nodes 129

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Goals

Problem: Extensible Expression Tree Operations

Operation 2: Evaluate the yield of the nodes in the tree Operation 1: Print all the values of the nodes in the tree

Create a framework for performing operations that affect nodes in a tree Constraints/forces Support multiple operations on the expression tree without tightly coupling operations with the tree structure i.e., dont have print() & evaluate() methods in the node classes
Unary Node

Binary Nodes

Leaf Nodes 130

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution (Part A): Encapsulate Traversal

Iterator Encapsulates a traversal algorithm without exposing representation details to callers e.g., in-order iterator = -5*(3+4) pre-order iterator = *-5+34 post-order iterator = 5-34+* level-order iterator = *-+534
Unary Node

Leaf for (auto iter = expr_tree.begin(); Nodes iter != expr_tree.end(); ++iter) (*iter).accept(print_visitor);

131

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution (Part A): Encapsulate Traversal

Unary Node Leaf Nodes

Post_Order_ET_Iterator_Impl Pre_Order_ET_Iterator_Impl

In_Order_ET_Iterator_Impl Level_Order_ET_Iterator_Impl

132& simplifies memory management Bridge pattern encapsulates variability

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Iterator Class Interface

Interface for iterator that traverses all nodes in an expression tree instance
Interface
This interface plays the role of the abstraction in the Bridge pattern

Expression_Tree const Expression_Tree ET_Iterator & ET_Iterator bool bool

ET_Iterator(ET_Iterator_Impl *) ET_Iterator(const ET_Iterator &) operator *() operator *() const operator++() operator++(int) operator==(const ET_Iterator &rhs) operator!=(const ET_Iterator &rhs) ...

Overloaded C++ operators conform to whats expected from an STL iterator

Commonality: Provides a common interface for expression tree iterators

that conforms to the standard STL iterator interface

Variability: Can be configured with specific expression tree iterator algorithms via the Abstract Factory 133 pattern

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Iterator_Impl Class Interface

iterations algorithms that can be performed to traverse the expression tree ET_Iterator_Impl Interface (const Expression_Tree &) virtual ~ET_Iterator_Impl() virtual Expression_Tree operator *()=0 virtual void operator++()=0 This class virtual bool operator== doesnt need (const ET_Iterator_Impl &)=0 to mimic the virtual bool operator!= Bridge interface (const ET_Iterator_Impl &)=0 virtual ET_Iterator_Impl * clone()=0
clone() is used by P rototype pattern

Base class of the iterator implementor hierarchy that defines the various

Commonality: Provides a common interface for implementing expression

tree iterators that conforms to the standard STL iterator interface nodes in the expression trees in a particular traversal order 134

Variability: Can be subclassed to define various algorithms for accessing

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Iterator

GoF Object Behavioral

Intent Access elements of an aggregate without exposing its representation Applicability Require multiple traversal algorithms over an aggregate Require a uniform traversal interface over different aggregates When aggregate classes & traversal algorithm must vary independently Structure
e.g., Expression_Tree e.g., ET_Iterator_Impl

e.g., Pre_Order_ET_Iterator_Impl, In_Order_ET_Iterator_Impl, etc. 135

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Iterator

GoF Object Behavioral

Comparing STL iterators with GoF iterators

STL iterators have value-semantics, e.g.:

for (auto iter = expr_tree.begin(); iter != expr_tree.end(); ++iter) (*iter).accept(print_visitor);

Easy to use, harder to implement

In contrast, GoF iterators have pointer semantics, e.g.:

Iterator *iter; Easy to implement, harder to use (correctly)

for (iter = exprTree.createIterator(); iter->done() == false; iter->advance()) iter->currentElement()->accept(printVisitor); delete iter; 136 The Bridge pattern enables STL iterator use in expression tree processing app

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Iterator

GoF Object Behavioral

Comparing Java iterators with GoF iterators

Java iterators are closer to GoF iterators than STL iterators are, e.g.:
for (IteratorL<ExpressionTree> itr = exprTree.iterator(); itr.hasNext(); ) iter.next().accept (printVisitor); }

Heres the equivalent Java code for GoF-style iterators, e.g.:

for (ETIterator iter = tree.createIterator(); !iter.done(); iter.advance()) (iter.currentElement()).accept(printVisitor);

137 in C++/Java is to use a for loop Often, the simplest way to use an iterator

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Iterator
for loop, e.g.:

GoF Object Behavioral

Comparing Java iterators with STL iterators

Often, the simplest way to use an iterator in C++/Java is to use a

C++11 range-based for loop for (auto &iter : expr_tree) iter.accept(print_visitor);

Java for-each loop for (ComponentNode node : exprTree) node.accept(printVisitor);

138

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Iterator
Consequences + Flexibility: Aggregate & traversal are independent

GoF Object Behavioral

Known Uses C++ STL iterators JDK Enumeration, Iterator Unidraw Iterator C++11 range-based for loops & Java foreach loops

142 Batching in distributed & concurrent programs

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution (Part B): Decouple Operations from Expression Tree Structure

Visitor Defines action(s) at each step of traversal & avoids hard-coding action(s) into nodes
Unary Node Leaf Nodes

143

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution (Part B): Decouple Operations from Expression Tree Structure

Visitor Defines action(s) at each step of traversal & avoids hard-coding action(s) into nodes Iterator calls accept(ET_Visitor&) method on each node in expression tree

Unary for (auto iter = expr_tree.begin(); Node

iter != expr_tree.end(); ++iter) (*iter).accept(print_visitor);

Leaf Nodes

144

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution (Part B): Decouple Operations from Expression Tree Structure

Visitor Defines action(s) at each step of traversal & avoids hard-coding action(s) into nodes Iterator calls accept(ET_Visitor&) method on each node in expression tree

Unary for (auto iter = expr_tree.begin(); Node

iter != expr_tree.end(); ++iter) (*iter).accept(print_visitor); accept() calls back on visitor, e.g.: void Leaf_Node::accept(ET_Visitor &v) { v.visit(*this); }

Leaf Nodes

145 Note static polymorphism based on method overloading by type

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Visitor Class Interface

Interface for a visitor that defines operations performed for each type of
node in the expression tree Interface virtual virtual virtual virtual virtual virtual void void void void void void
An overloaded visit() method is defined for each Component_Node subclass

visit(const visit(const visit(const visit(const visit(const visit(const

Leaf_Node &node)=0 Composite_Negate_Node &node)=0 Composite_Add_Node &node)=0 Composite_Subtract_Node &node)=0 Composite_Divide_Node &node)=0 Composite_Multiply_Node &node)=0

Commonality: Provides a common accept()method for all expression

tree nodes & common visit()method for all visitor subclasses
ET_Visitor

Variability: Can be subclassed

to define specific behaviors for the visitors & nodes
146

The Print_Visitor class prints character code or value for each node
class Print_Visitor : public public: virtual void visit(const virtual void visit(const virtual void visit(const // etc. }; ET_Visitor { Leaf_Node &); Add_Node &); Divide_Node &);

Can be combined with any traversal algorithm, e.g.:

stack_.push(node.item());

accept(eval_visitor)

stack_.push(-stack_.pop());

153

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Visitor
Consequences

Douglas C. Schmidt

Implementing STL Iterator Semantics

158

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Implementing STL Iterator Semantics

Goals Ensure the proper semantics of post-increment operations for STL-based ET_Iterator objects Expression_Tree value = iter++ vs. Expression_Tree value = ++iter Constraints/forces STL pre-increment operations are easy to implement since they simply increment the value & return *this, e.g., iterator &operator++() { ++...; return *this; } STL post-increment operations are more complicated since they return a copy of the existing iterator before incrementing its value, e.g., iterator operator++(int) { iterator temp = copy_*this; ++...; return temp; }

159

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Specify the kinds of objects to create using a prototypical instance & create new objects by copying this prototype Applicability

When the classes to instantiate are specified at run-time Theres a need to avoid the creation of a factory hierarchy It is more convenient to copy an existing instance than to create a new one
Structure
e.g., ET_Iterator_Impl

e.g., ET_Iterator e.g., Pre_Order_ET_Iterator_Impl, In_Order_ET_Iterator_Impl, etc.

163

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Prototype
Prototype example in C++

GoF Object Creational

GoF Object Creational

Known Uses

The first widely known

application of the Prototype pattern in an object-oriented language was in ThingLab related to the Prototype pattern for C++ & gives many examples & variations

Every class that used as a prototype must itself be instantiated Classes that have circular references to other classes cannot really be cloned Implementation

Jim Coplien describes idioms

Use prototype manager Shallow vs. deep copies Initializing clone internal state within a
uniform interface
168

Etgdb debugger for ET++ The music editor example is

based on the Unidraw drawing framework

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary of Tree Traversal Patterns

The Iterator, Prototype, & Visitor patterns traverse the expression tree & perform designated operations
<< accept >>

Visitor
ET_Visitor

Expression_Tree

Component_Node

Iterator

<< create >> Evaluation_Visitor Print_Visitor

ET_Iterator

ET_Iterator_Impl

std::queue

Level_Order_Expression _Tree_Iterator_Impl In_Order_Expression _Tree_Iterator_Impl Post_Order_Expression _Tree_Iterator_Impl Pre_Order_Expression _Tree_Iterator_Impl std::stack

Prototype

169 These patterns allow adding new operations without affecting tree structure

A Case Study of Gang of Four (GoF) Patterns : Part 8

d.schmidt@vanderbilt.edu www.dre.vanderbilt.edu/~schmidt Professor of Computer Science Institute for Software Integrated Systems Vanderbilt University Nashville, Tennessee, USA

Douglas C. Schmidt

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Topics Covered in this Part of the Module

Describe the object-oriented (OO) expression tree case study ET_Command Evaluate the limitations with _Factory algorithmic design techniques Present an OO design for expression tree processing app Summarize the patterns in the expression tree design Explore patterns for Tree structure & access Tree creation Tree traversal Commands & factories
Print_ Command ET_Command the _Factory_Impl ET_Command

ET_Command_Impl

Format_ Command Macro_ Command

Expr_ Command

Eval_ Command

Quit_ Command

171

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Command & Factory Patterns

P urpose: Define operations that can users can perform on an expression tree processing app & centralize extensible creation of these operations
ET_Event_Handler ET_Command_Factory ET_Command _Factory_Impl

Abstract Factory & Factory Method

<< create >>

Concrete_ET_ Command_Factory_Impl

ET_Context

ET_Command

ET_Command_Impl

Command

1 Macro_Command Print_Command Set_Command Quit_Command Null_Command

Format_Command

Expr_Command

Eval_Command

172 These patterns decouple creation from use & provide a uniform command API

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Format_ Command Macro_ Command

Expr_ Command

Eval_ Command

Print_ Command

Quit_ Command

176

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution: Encapsulate an Operation w/Command

A Command encapsulates An operation method (execute()) An inverse operation method (unexecute()) A test for reversibility (boolean reversible()) State for (un)doing the operation A Command may Implement the operation itself or Forward the operation implementation to other object(s)
Macro_ Command ET_Command_Impl ET_Command

Format_ Command

Expr_ Command

Eval_ Command

Print_ Command

Quit_ Command

177& simplifies memory management Bridge pattern encapsulates variability

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Command Class Interface

Interface for defining a command thatwhen executedperforms an
operation on an expression tree
This class plays the role of the abstraction in the Bridge pattern

Interface

ET_Command(ET_Command_Impl *=0) ET_Command(const ET_Command &) ET_Command & operator=(const ET_Command &) ~ET_Command() These methods forward to bool execute() the implementor subclass bool unexecute()

We dont use this method but its a common command feature

Commonality: Provides common interface for expression tree commands Variability: Implementations of expression tree commands can vary
depending on the operations requested by user input
178

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Command_Impl Class Interface

Base class of an implementor hierarchy used to define commands that
perform operations on an expression tree when they are executed
This class is the base class of the implementor hierarchy in the Bridge pattern

Interface

ET_Command_Impl(ET_Context &) ~ET_Command_Impl()= 0 ... The bulk of the work is virtual bool execute()=0 typically done here by virtual bool unexecute()=0
subclasses

Commonality: Provides a common base class for implementations of

expression tree commands

Variability: Subclasses of this base class implement different expression

tree commands depending on the operations requested by user input
179

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Command
Intent Applicability

GoF Object Behavioral

Encapsulate the request for a service as an object Want to parameterize objects with an action to perform Want to specify, queue, & execute requests at different times For multilevel undo/redo Structure
e.g., ET_Command_Impl

e.g., Eval_Command, Format_Command, Print_Command, Quit_Command, Macro_Command, etc.

180

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Object Behavioral

Copying a command before putting it on a history list Avoiding error accumulation during undo/redo Supporting transactions
186

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Object Behavioral

Known Uses InterViews Actions MacApp, Unidraw Commands JDKs UndoableEdit, AccessibleAction Emacs Microsoft Office tools See Also Command Processor pattern in POSA1

Copying a command before putting it on a history list Avoiding error accumulation during undo/redo Supporting transactions
187

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Problem: Consolidating Creation of Variabilities

Goals Simplify & centralize the creation of all variabilities in the expression tree application to ensure semantic compatibility Be extensible for future variabilities
ET_Command ET_Command_Impl

Format_Command

Print_Command

Eval_Command

Quit_Command

Expr_Command

Macro_Command

ET_Iterator

ET_Iterator_Impl

In_Order_ET_Iterator_Impl Level_Order_ET_Iterator_Impl

Post_Order_ET_Iterator_Impl

188

Pre_Order_ET_Iterator_Impl

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Problem: Consolidating Creation of Variabilities

Goals Simplify & centralize the creation of all variabilities in the expression tree application to ensure semantic compatibility Be extensible for future variabilities
ET_Command ET_Command_Impl

Constraints/forces Dont recode existing clients Add new variabilities without recompiling

Format_Command

Print_Command

Eval_Command

Quit_Command

Expr_Command

Macro_Command

ET_Iterator

ET_Iterator_Impl

In_Order_ET_Iterator_Impl Level_Order_ET_Iterator_Impl

Interface used to create appropriate command based on string supplied
by caller Interface
This class plays the role of the abstraction in the Bridge pattern

ET_Command_Factory(ET_Context &tree_context) ET_Command_Factory(ET_Command_Factory_Impl *) ET_Command make_command(const std::string &s) ...

These are helper factory methods This is the main factory method

ET_Command ET_Command ET_Command ET_Command ET_Command ET_Command

make_format_command(const std::string &) make_expr_command(const std::string &) make_print_command(const std::string &) make_eval_command(const std::string &) make_quit_command(const std::string &) make_macro_command(const std::string &)

Commonality: Provides a common interface to create commands Variability: Implementations of expression tree command factory
methods can vary depending on the requested commands 192

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Command_Factory_Impl Class Interface

Base class of an implementor hierarchy used to create appropriate commands
based on string supplied by caller Interface
This class is base class of implementor hierarchy in the Bridge pattern

ET_Command_Factory_Impl(ET_Context &context) ~ET_Command_Factory_Impl() virtual ET_Command make_command(const std::string &s)=0 ... Pure virtual methods virtual virtual virtual virtual virtual virtual ET_Command ET_Command ET_Command ET_Command ET_Command ET_Command make_format_command(const std::string &)=0 make_expr_command(const std::string &)=0 make_print_command(const std::string &)=0 make_eval_command(const std::string &)=0 make_quit_command(const std::string &)=0 make_macro_command(const std::string &)=0

Commonality: Provides a common interface to create commands Variability: Subclasses of this base class define expression tree

command factory methods vary depending on the requested commands 193

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Factory Structure
ET_Command_Factory ET_Command

ET_Command_Factory_Impl

ET_Command_Impl

Concrete_ET_Command _Factory_Impl +make_command() #make_expr_command() #make_format_command() #make_eval_command() #make_macro_command() #make_quit_command() #make_print_command() Format_ Command Macro_ Command Print_ Command Expr_ Command Eval_ Command Quit_ Command

Each factory method creates a different type of concrete command

194& simplifies memory management Bridge pattern encapsulates variability

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Factory Method
Intent concrete type to a subclass

Douglas C. Schmidt

Factory Method
Consequences

GoF Class Creational

Known Uses InterViews Kits ET++ WindowSystem AWT Toolkit The ACE ORB (TAO) BREW feature phone frameworks

The creator class is abstract & does not implement creation methods (then it must be subclassed) The creator class is concrete & provides a default implementation (then it can be subclassed) If a factory method can create different variants the method must be provided with a parameter 200

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Abstract Factory
Intent Applicability

GoF Object Creational

Create families of related objects without specifying subclass names When clients cannot anticipate groups of classes to instantiate
Structure
e.g., ET_Command _Impl e.g., ET_Command _Factory_Impl e.g., Eval_Command, Print_ Command, Macro_Command, etc.

e.g., Concrete_ET_ Command_Factory_Impl

201

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Abstract Factory
Abstract Factory example in C++

GoF Object Creational

Create families of related objects without specifying subclass names

class Concrete_ET_Command_Factory_Impl : public ET_Command_Factory_Impl { public: Concrete_ET_Command_Factory_Impl() { command_map_["format"] = &make_format_command; command_map_["expr"] = &make_expr_command; command_map_["eval"] = &make_eval_command; ... std::map associating command names to pointerto-member-function command factories

202

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Abstract Factory
Abstract Factory example in C++

GoF Object Creational

Create families of related objects without specifying subclass names

designated command based on user input virtual ET_Command make_command(const std::string &input) { auto iter = command_map_.find(command_name(input)); if (iter != command_map_.end()) { auto ptmf = iter->second; return (this->*ptmf)(command_parameter(input)); } Dispatch command 203factory method via returned via map ...

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary of Command & Factory Patterns

which then dictate how users interact with an expression tree processing app
ET_Event_Handler ET_Command_Factory ET_Command_Factory_Impl

Abstract Factory contains Factory Methods that create Command objects,

Abstract Factory & Factory Method

<< create >>

Concrete_ET_Command_Factory_Impl

ET_Context

ET_Command

ET_Command_Impl

Command

1 Macro_Command Print_Command Set_Command Quit_Command Null_Command

Format_Command

Expr_Command

Eval_Command

Uninitialized _State

Pre_Order_ Uninitialized_State

Post_Order_ Uninitialized_State

In_Order_ Uninitialized_State

Level_Order_ Uninitialized_State

Pre_Order_ Initialized_State

Post_Order_ Initialized_State

In_Order_ Initialized_State

Level_Order_ Initialized_State

State

<< use >> ET_Interpreter

This pattern uses design of classes to 210 explicitly order user commands correctly

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Problem: Ensuring Correct Command Protocol

Goals Ensure that users follow the correct protocol when entering commands % tree-traversal -v format [in-order] expr [expression] print [in-order|pre-order|postorder|level-order] eval [post-order] quit Protocol > format in-order violation > print in-order Error: ET_State::print called in invalid state

Douglas C. Schmidt

Solution: Encapsulate Command History as States

Handling user commands depends on history of prior commands
*_Order_ Uninitialized State make_tree() format() *_Order_ Initialized State eval() make_tree() print()

This Uninitialized history can be State represented as a format() state machine The state machine can be encoded using various subclasses that enforce the correct protocol for user commands

quit()

219 & simplifies memory management ET_Context also encapsulates variability

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Context Class Interface

Interface used to ensure commands are invoked according to correct protocol
These methods correspond to user commands

Interface

void void void void

ET_State * void Expression_Tree & void

format(const std::string &new_format) make_tree(const std::string &expression) print(const std::string &format) evaluate(const std::string &format) ... Setter/getter for state() const ET_State subclasses state(ET_State *new_state) tree() tree(const Expression_Tree &new_tree)

Commonality: Provides a common interface for ensuring that

expression tree commands are invoked according to the correct protocol

Variability: The implementations& correct functioningof the

expression tree commands can vary depending on the requested operations & the current state 220

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_State Class Interface

Implementation used to define the various states that affect how users
commands are processed Interface virtual void format(ET_Context &context, const std::string &new_format) virtual void make_tree(ET_Context &context, const std::string &expression) virtual void print(ET_Context &context, const std::string &format) virtual void evaluate(ET_Context &context, const std::string &format)
These methods are delegated from ET_Context methods

Commonality: Provides a common interface for ensuring that

expression tree commands are invoked according to the correct protocol

Variability: The implementations& correct functioningof the

expression tree commands can vary depending on the requested operations & the current state 221

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

State
Intent

GoF Object Behavioral

Allow an object to alter its behavior when its internal state changesthe object will appear to change its class Applicability

When an object must change its behavior at run-time depending on

which state it is in

When several operations have the same large multipart conditional

structure that depends on the object's state
e.g., ET_State

Structure
e.g., Uninitialized_State, Pre_Order_Uninitialized_State, Pre_Order_Initialized_State, etc.

e.g., ET_Context

222

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

State
State example in C++

GoF Object Behavioral

This method delegates to the ET_State object

Allows ET_Context object to alter its behavior when its state changes
void ET_Context::make_tree(const std::string &expression) { state_->make_tree(*this, expression); }

class Uninitialized_State { public: virtual void make_tree(ET_Context &tc, const std::string &expr) { throw Invalid_State("make_tree called in invalid state"); } ...

Its invalid to call make_tree() in this state

223

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

State
State example in C++

GoF Object Behavioral

This method delegates to the ET_State object

Allows ET_Context object to alter its behavior when its state changes
void ET_Context::make_tree(const std::string &expression) { state_->make_tree(*this, expression); }

class In_Order_Uninitialized_State : public Uninitialized_State { public: Calling make_tree() in this state initializes expression tree virtual void make_tree(ET_Context &et_context, const std::string &expr) { ET_Interpreter interp; ET_Interpreter_Context interp_context; et_context.tree(interp.interpret (interp_context, expr)); et_context.state(new In_Order_Initialized_State); } ... Transition to the new state 224

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Object Behavioral

225

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

State
Consequences + It localizes state-specific behavior & partitions behavior for different states + It makes state transitions explicit + State objects can be shared Can result in lots of subclasses that are hard to understand Implementation Who defines state transitions? Consider using table-based alternatives Creating & destroying state objects

GoF Object Behavioral

226

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Object Behavioral

Known Uses

The State pattern & its

application to TCP connection protocols are characterized by Ralph Johnson & Johnny Zweig in their article Delegation in C++. Journal of Object-Oriented Programming, 4(11):22-35, November 1991

Unidraw & Hotdraw drawing

tools

227

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary of State Pattern

State ensures user commands are performed in the correct order

ET_Context

ET_State

Uninitialized _State

Pre_Order_ Uninitialized_State

Post_Order_ Uninitialized_State

In_Order_ Uninitialized_State

Level_Order_ Uninitialized_State

Pre_Order_ Initialized_State

Post_Order_ Initialized_State

In_Order_ Initialized_State

P urpose: Structure the overall control flow of the event-driven expression tree processing app
Reactor
Reactor Event_Handler

Singleton
Options

ET_Command_Factory

ET_Event_Handler

ET_Context

<< create >>

Verbose_ET_ Event_Handler

Succinct_ET_ Event_Handler

ET_Command

231 of events & user options These patterns simplify processing

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Problem: Structuring Application Event Flow

Goals

Decouple expression tree

processing app from the context in which it runs

e.g., command-line vs.

various GUI environments

% tree-traversal -v format [in-order] expr [expression] print [in-order|pre-order|postorder|level-order] eval [post-order] quit > format in-order > expr 1+4*3/2 > eval post-order 7 > quit

232

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Problem: Structuring Application Event Flow

Goals

Decouple expression tree

processing app from the context in which it runs

e.g., command-line vs.

Constraints/forces

various GUI environments

Dont hard-code control flow into app logic Dont hard-code event processing logic into app structure

233

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution: Separate Event Handling Concerns

Solution: Separate Event Handling Concerns

Create a reactor to detect input on various
sources of events & then demux & dispatch the events to the appropriate event handlers handlers & register the concrete event handlers with the reactor loop to drive the application event flow
Note the inversion of control

Create concrete event

Run the reactors event

237

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Reactor & Event Handler Class Interfaces

An object-oriented event demultiplexor & dispatcher of event handler
callback methods in response to various types of events
Enact inversion of control

Interface

void void void void static Reactor * instance()

~Reactor() run_event_loop() end_event_loop() register_handler(Event_Handler event_handler) remove_handler(Event_Handler event_handler)

Singleton access point Attach/detact event handlers

238

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Reactor & Event Handler Class Interfaces

An object-oriented event demultiplexor & dispatcher of event handler
hook methods in response to various types of events
<<uses>>

Interface

void void void void static Reactor * instance()

~Reactor() run_event_loop() Process an event end_event_loop() register_handler(Event_Handler event_handler) remove_handler(Event_Handler event_handler)

virtual void ~Event_Handler()=0 virtual void delete_this() virtual void handle_input()=0

Commonality: Provides a common interface for managing & processing

events via callbacks to abstract event handlers

Variability: Concrete implementations of Reactor & event handlers can

be tailored to a wide range of OS muxing mechanisms & applicationspecific concrete event handling behaviors 239

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Reactor
Intent

POSA2 Architectural Pattern

Allows event-driven applications to demultiplex & dispatch service requests

that are delivered to an application from one or more clients Applicability

Need to decouple event handling from event management infrastructure When multiple sources of events must be handled in a single thread
Structure
e.g., Event_Handler

e.g., Verbose_ET _Event_Handler, Succinct_ET_ Event_Handler

240 See www.dre.vanderbilt.edu/~schmidt/PDF/Reactor.pdf for the Reactor pattern

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Reactor
Reactor example in C++

POSA2 Architectural Pattern

POSA2 Architectural Pattern

Known Uses X Windows Xt InterViews Dispatcher ET++ WindowSystem AWT Toolkit ACE & The ACE ORB (TAO) Java NIO package

Rather than using global variables, create a central access point to global
instances, e.g.:
int main(int argc, char *argv[]) { Parse the command-line options if(!Options::instance()->parse_args(argc, argv)) return 0; Dynamically allocate the appropriate event handler based on the ET_Event_Handler *event_handler = command-line options ET_Event_Handler::make_handler (Options::instance()->verbose()); Reactor::instance()->register_input_handler (event_handler); Register event handler with the event loop driver // ... 247

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Singleton
Intent Applicability

GoF Object Creational

Ensure a class only has one instance & provide a global point of access When there must be exactly one instance of a class & it must be accessible from a well-known access point When the sole instance should be extensible by subclassing & clients should be able to use an extended instance without modifying their code Structure
If (uniqueInstance == 0) uniqueInstance = new Singleton; return uniqueInstance;

e.g., Options & Reactor

248

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Singleton
Singleton example in C++

GoF Object Creational

Define a singleton class to handle command-line option processing

class Options { public: static Options *instance(); if (instance_ == 0) instance_ = new Options; return instance_;

// Parse command-line arguments and sets values as follows: // 't' - Traversal strategy, i.e., 'P' for pre-order, 'O' for // post-order, 'I' for in-order, & 'L' for level-order. bool parse_args(int argc, char *argv[]); bool verbose() const; // True if program runs in verbose mode. char traversal_strategy() // Returns desired traversal strategy. ... Accessor methods to check for enabled options private: Make constructor private to prevent multiple instances Options(); static Options *instance_; ... 249 Points to the one & only instance

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Singleton
Consequences + Reduces namespace pollution + Makes it easy to change your mind & allow more than one instance + Allow extension by subclassing Same drawbacks of a global if misused Implementation may be less efficient than a global Concurrency/cache pitfalls & communication overhead

GoF Object Creational

250for discussion of Singleton issues See c2.com/cgi/wiki?SingletonsAreEvil

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Object Creational

Registering singleton instance with manager Deleting singletons

251 www.research.ibm.com/designpatterns/pubs/ph-jun96.txt: Singleton deletion

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Object Creational

Registering singleton instance with manager Deleting singletons

252 www.dre.vanderbilt.edu/~schmidt/PDF/ObjMan.pdf: Singleton management

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Object Creational

Known Uses Unidraw's Unidraw object Smalltalk-80 ChangeSet, the set of changes to code InterViews Session object ACE Singleton See Also Double-Checked Locking Optimization pattern from POSA2 book

Registering singleton instance with manager Deleting singletons

253 en.wikipedia.org/wiki/Double-checked_locking has more synchronization info

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary of Application Structure Patterns

Reactor structures the overall control flow of the event-driven expression tree processing app & Singleton simplifies access to global resources
Reactor
Reactor Event_Handler

Singleton
Options

ET_Command_Factory

ET_Event_Handler

ET_Context

<< create >>

Verbose_ET_ Event_Handler

Succinct_ET_ Event_Handler

ET_Command

254 The Reactor pattern embodies key characteristics of frameworks

<< create >>

Verbose_ET_ Event_Handler

Succinct_ET_ Event_Handler

ET_Command

Strategy & Template Method

These patterns support controlled257 variability of steps in an algorithm

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Problem: Supporting Multiple Operation Modes

Goals

Minimize effort required to

support multiple modes of operation modes

e.g., verbose & succinct

% tree-traversal -v format [in-order] Verbose mode expr [expression] print [in-order|pre-order|postorder|level-order] eval [post-order] quit > format in-order > expr 1+4*3/2 > eval post-order 7 > quit % tree-traversal > 1+4*3/2 7
258

Succinct mode

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Problem: Supporting Multiple Operation Modes

Goals

Minimize effort required to

support multiple modes of operation mode

e.g., verbose & succinct

Constraints/forces

Dont tightly couple the

operation modes with the program structure enhancements algorithmic decomposition
259

Simplify future

Avoid limitations of

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

ET_Event_Handler handle_input() prompt_user() get_input() make_command() execute_command()

Verbose_ET_ Event_Handler prompt_user() make_command()

Succinct_ET_ Event_Handler prompt_user() make_command()

ET_Command make_command (const std::string &input) { return command_factory_. make_macro_command(input); }

ET_Command make_command (const std::string &input) { return command_factory_.make_command(input); }

Template Method
Template Method example in C++

GoF Class Behavioral

Allow subclasses to customize certain steps in event handling algorithm

void ET_Event_Handler::handle_input() { Template method prompt_user(); std::string input; if (!get_input(input)) Reactor::instance()->end_event_loop(); ET_Command command = make_command(input); if (!execute_command(command)) Reactor::instance()->end_event_loop(); ... Hook methods

266

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Template Method
Template Method example in C++

GoF Class Behavioral

Allow subclasses to customize certain steps in event handling algorithm

void ET_Event_Handler::handle_input() { prompt_user(); std::string input; if (!get_input(input)) Reactor::instance()->end_event_loop(); ET_Command command = make_command(input); if (!execute_command(command)) Reactor::instance()->end_event_loop(); ... ET_Command Verbose_ET_Event_Handler::make_command (const std::string &input) { return command_factory_.make_command(input); Specialized hook } methods ET_Command Succinct_ET_Event_Handler::make_command (const std::string &input) { return command_factory_.make_macro_command(input); 267 }

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Template Method
Template Method example in C++

GoF Class Behavioral

Allow subclasses to customize certain steps in event handling algorithm

void ET_Event_Handler::handle_input() { prompt_user(); std::string input; if (!get_input(input)) Reactor::instance()->end_event_loop(); ET_Command command = make_command(input); if (!execute_command(command)) Reactor::instance()->end_event_loop(); ... ET_Event_Handler *ET_Event_Handler::make_handler(bool verbose) { return verbose ? new Verbose_ET_Event_Handler : new Succint_ET_Event_Handler } Factory creates appropriate strategy objects 268 This is not the only (or best) way of defining a factory

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Class Behavioral

269

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Template Method
Consequences + Enables inversion of control (Hollywood principle: don't call us we'll call you!) + Promotes code reuse + Lets you enforce overriding rules Must subclass to specialize behavior (cf. Strategy pattern) Implementation Virtual vs. non-virtual template method Few vs. many primitive operations (hook methods)

GoF Class Behavioral

Naming conventions (do_() vs. make_() prefix)

270

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

GoF Class Behavioral

Known Uses

InterViews Kits ET++ WindowSystem AWT Toolkit ACE & The ACE ORB (TAO) Android Activities

Naming conventions (do_() vs. make_() prefix)

271

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution B: Encapsulate Algorithm Variability

Implement algorithm once in base class & let strategies define variant parts
Event_Handler void handle_input() { prompt_user(); ET_Event_Handler handle_input() std::string input; if(!get_input(input)) Reactor::instance() ->end_event_loop(); ET_Command cmd = make_command(input);

Same template method & hook methods as before

if(!execute_command(cmd)) Reactor::instance() ->end_event_loop(); }

272

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution B: Encapsulate Algorithm Variability

Implement algorithm once in base class & let strategies define variant parts
Event_Handler
PROMPT_USER _STRATEGY GET_INPUT _STRATEGY

void handle_input() { prompt_user(); ET_Event_Handler handle_input()

PROMPT_USER_STRATEGY, GET_INPUT_STRATEGY, MAKE_COMMAND_STRATEGY, EXECUTE_COMMAND_STRATEGY

std::string input; if(!get_input(input)) Reactor::instance() ->end_event_loop(); ET_Command cmd = make_command(input); if(!execute_command(cmd)) Reactor::instance() ->end_event_loop(); }

MAKE_ COMMAND _STRATEGY

Strategy_ET_ Event_Handler

EXECUTE_ COMMAND _STRATEGY

handle_input() prompt_user() get_input() make_command() execute_command()

Strategy objects can be passed as arguments to Strategy_ET_Event_Handler constructor

Strategy objects can be defined 273 using C++ parameterized types

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Solution B: Encapsulate Algorithm Variability

Implement algorithm once in base class & let strategies define variant parts
Event_Handler
PROMPT_USER _STRATEGY GET_INPUT _STRATEGY

void handle_input() { prompt_user(); ET_Event_Handler handle_input()

PROMPT_USER_STRATEGY, GET_INPUT_STRATEGY, MAKE_COMMAND_STRATEGY, EXECUTE_COMMAND_STRATEGY

std::string input; if(!get_input(input)) Reactor::instance() ->end_event_loop(); ET_Command cmd = make_command(input); if(!execute_command(cmd)) Reactor::instance() ->end_event_loop(); }

MAKE_ COMMAND _STRATEGY

Strategy_ET_ Event_Handler

EXECUTE_ COMMAND _STRATEGY

handle_input() prompt_user() get_input() make_command() execute_command()

Hook methods forward to strategy object methods

ET_Command make_command(const std::string &input) { return mc_strategy_.make_command(input); } bool execute_command(const std::string &input) { return ec_strategy_.execute_command(input); }

274

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Strategy Template Parameters

Provides template parameters that perform steps in the algorithm associated
with the expression tree processing app Template Parameters MAKE_COMMAND _STRATEGY ET_Command make_command(const std::string &input) EXECUTE_COMMAND Expected method signatures _STRATEGY bool execute_command(const std::string &input) ...

Commonality: Provides common expected method signatures for

performing steps in the expression tree processing algorithm Variability: Template arguments provided to Strategy_ET_Event _Handler implement various operation modes, e.g., verbose vs. succinct
275

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Strategy

GoF Object Behavioral

Intent Define a family of algorithms, encapsulate each one, & make them interchangeable to let clients & algorithms vary independently Applicability When an object should be configurable with one of many algorithms, and all algorithms can be encapsulated, and one interface covers all encapsulations Structure

e.g., MAKE_COMMAND_ STRATEGY, EXECUTE_ COMMAND_STRATEGY, etc.

276

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Strategy
Strategy example in C++

GoF Object Behavioral

Customize algorithm behavior by composition/forwarding vs. inheritance

Parameterized template <..., typename MAKE_COMMAND_STRATEGY, type strategies typename EXECUTE_COMMAND_STRATEGY> class Strategy_ET_Event_Handler : public ET_Event_Handler { public: Reuse handle_input() Strategy_ET_Event_Handler template method (..., const MAKE_COMMAND_STRATEGY &mc_strategy, const EXECUTE_COMMAND_STRATEGY &ec_strategy) ... Pass strategy objects via constructor & assign to corresponding data members

Douglas C. Schmidt

Comparing Strategy with Template Method

284

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Comparing Strategy with Template Method

Strategy + Provides for clean separation between components via black-box interfaces + Allows for strategy composition at runtime + Supports flexible mixing & matching of features Incurs the overhead of forwarding May yield many strategy classes Template Method + No explicit forwarding necessary + May be easier for small use cases Close coupling between subclass(es) & base class Inheritance hierarchies are static & cannot be reconfigured at runtime Adding features via inheritance may yield combinatorial subclass explosion Beware overusing inheritance since its not always the best choice Deep inheritance hierarchies in an app are a red flag

Strategy is commonly used for Black-box frameworks Template Method is commonly used for White-box frameworks
285

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Overview of Algorithm Variability Encapsulation Patterns

The Strategy & Template Method patterns simplify processing of multiple operation modes

Reactor

Event_Handler

Options

ET_Command_Factory

ET_Event_Handler

ET_Context

<< create >>

Verbose_Expression_ Tree_Event_Handler

Macro_Expression_ Tree_Event_Handler

ET_Command

Strategy & Template Method

286 These patterns avoid limitations of algorithmic decomposition

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary
Pattern-oriented expression tree processing app design has many benefits: Major improvements over the original algorithmic decomposition
Expression_Tree

Component_Node

Composite_ Unary_Node

Leaf_Node

Composite_Binary _Node

Composite_Negate _Node

1 Tree Node 0|1|2 287

Composite_Negate _Node

Composite_ Add_Node Composite_ Multiply_Node

Composite_ Subtract_Node Composite_ Divide_Node

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt Visitor

Summary
Pattern-oriented expression tree processing app design has many benefits: Major improvement over the original algorithmic decomposition Exhibits high pattern density
Iterator

Prototype

291

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt Visitor

292

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt Visitor

Summary
Pattern-oriented expression tree processing app design has many benefits: Major improvement over the original algorithmic decomposition Exhibits high pattern density Nearly all classes & objects in design play a role in one or more patterns Patterns help clarify the relationships of myriad classes in the design
Prototype Iterator

293

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary
Pattern-oriented expression tree processing app design has many benefits: Major improvement over the original algorithmic decomposition Exhibits high pattern density Same design can easily be realized in common OO programming languages
Expression_Tree expr_tree = ...; Print_Visitor print_visitor; C++11 range-based for loop for (auto &iter : expr_tree) iter.accept(print_visitor);

ExpressionTree exprTree = ...; ETVisitor printVisitor = new PrintVisitor(); Java for-each loop for (ComponentNode node : exprTree) node.accept(printVisitor);

294

GoF Patterns Expression Tree Case Study

Douglas C. Schmidt

Summary
Pattern-oriented expression tree processing app design has many benefits: Major improvement over the original algorithmic decomposition Exhibits high pattern density Same design can easily be realized in common OO programming languages C++ & Java solutions are nearly identical, modulo minor syntactical & semantic differences
Expression_Tree expr_tree = ...; Print_Visitor print_visitor; C++11 range-based for loop for (auto &iter : expr_tree) iter.accept(print_visitor);

ExpressionTree exprTree = ...; ETVisitor printVisitor = new PrintVisitor(); Java for-each loop for (ComponentNode node : exprTree) node.accept(printVisitor);

295 See www.vincehuston.org/dp for many examples of patterns in C++ & Java

Expression Tree
No ratings yet
Expression Tree
4 pages
Understanding Binary Expression Trees
No ratings yet
Understanding Binary Expression Trees
14 pages
Binary Expression Trees Explained
No ratings yet
Binary Expression Trees Explained
14 pages
GoF Patterns in Expression Tree Design
No ratings yet
GoF Patterns in Expression Tree Design
31 pages
Binary Expression Trees in C++
No ratings yet
Binary Expression Trees in C++
44 pages
Binary Expression Trees
No ratings yet
Binary Expression Trees
14 pages
Binary Expression Trees
No ratings yet
Binary Expression Trees
14 pages
Binary Search Trees and Expressions
No ratings yet
Binary Search Trees and Expressions
5 pages
Binary Expression Trees
No ratings yet
Binary Expression Trees
14 pages
Constructing Expression Trees Explained
No ratings yet
Constructing Expression Trees Explained
17 pages
Practical Assigment 6 Expression Tree
No ratings yet
Practical Assigment 6 Expression Tree
3 pages
Parse Tree
No ratings yet
Parse Tree
10 pages
DSAL Assignments 4 5 6
No ratings yet
DSAL Assignments 4 5 6
19 pages
Understanding Binary Trees Basics
No ratings yet
Understanding Binary Trees Basics
28 pages
09 - Trees I
No ratings yet
09 - Trees I
53 pages
2 Binary Tree
No ratings yet
2 Binary Tree
23 pages
Understanding Tree Data Structures
No ratings yet
Understanding Tree Data Structures
85 pages
Expression Tree Construction Guide
No ratings yet
Expression Tree Construction Guide
26 pages
Binary Trees
No ratings yet
Binary Trees
10 pages
Tree Data Structures and Algorithms
0% (1)
Tree Data Structures and Algorithms
27 pages
C++ Expression Tree Evaluation
No ratings yet
C++ Expression Tree Evaluation
4 pages
Extended Binary Trees and Expressions
No ratings yet
Extended Binary Trees and Expressions
16 pages
Binary Trees and Search Algorithms
No ratings yet
Binary Trees and Search Algorithms
107 pages
Expression Trees: Traversals & Construction
No ratings yet
Expression Trees: Traversals & Construction
16 pages
Understanding Tree Data Structures
No ratings yet
Understanding Tree Data Structures
22 pages
Unit II
No ratings yet
Unit II
65 pages
Unit 4 Trees
No ratings yet
Unit 4 Trees
56 pages
Importance of Expression Trees in Evaluation
No ratings yet
Importance of Expression Trees in Evaluation
1 page
Understanding Tree Data Structures
No ratings yet
Understanding Tree Data Structures
4 pages
Trees: Data Structures Overview
No ratings yet
Trees: Data Structures Overview
6 pages
Binary Trees, Graphs, and Heaps Explained
No ratings yet
Binary Trees, Graphs, and Heaps Explained
25 pages
Binary Tree - Expression Tree
No ratings yet
Binary Tree - Expression Tree
60 pages
Binary Trees in Data Structure
No ratings yet
Binary Trees in Data Structure
50 pages
Topic 6 Notes+Exercises
No ratings yet
Topic 6 Notes+Exercises
2 pages
Binary Tree Traversals and Exercises
No ratings yet
Binary Tree Traversals and Exercises
6 pages
Parse Trees
No ratings yet
Parse Trees
9 pages
Infix and Postfix Expressions
No ratings yet
Infix and Postfix Expressions
32 pages
Tree Data Structures Overview
No ratings yet
Tree Data Structures Overview
35 pages
Binary Trees: ECE 250 Algorithms and Data Structures
No ratings yet
Binary Trees: ECE 250 Algorithms and Data Structures
32 pages
Tree Structures and Binary Trees Guide
No ratings yet
Tree Structures and Binary Trees Guide
52 pages
Understanding Trees and Binary Trees
No ratings yet
Understanding Trees and Binary Trees
38 pages
Understanding Tree Data Structures
No ratings yet
Understanding Tree Data Structures
4 pages
Understanding Tree Data Structures
No ratings yet
Understanding Tree Data Structures
27 pages
PPT5 - Introduction To Tree, Binary Tree and Expression Tree
No ratings yet
PPT5 - Introduction To Tree, Binary Tree and Expression Tree
26 pages
Unit 03
No ratings yet
Unit 03
15 pages
The Tree ADT
No ratings yet
The Tree ADT
42 pages
Lab Manual & Code - Dsal - 6 - 1738216357257
No ratings yet
Lab Manual & Code - Dsal - 6 - 1738216357257
3 pages
4 Lecture 13-03-2025-Postfix - Prefix - Infix - Stack Calculator
No ratings yet
4 Lecture 13-03-2025-Postfix - Prefix - Infix - Stack Calculator
34 pages
Understanding Trees in Data Structures
No ratings yet
Understanding Trees in Data Structures
32 pages
Lecture 08 - Trees
No ratings yet
Lecture 08 - Trees
44 pages
Tree Structures & Binary Trees
No ratings yet
Tree Structures & Binary Trees
18 pages
Understanding Expression Trees
No ratings yet
Understanding Expression Trees
14 pages
C++ Object-Oriented Design Patterns
No ratings yet
C++ Object-Oriented Design Patterns
37 pages
C++ Object-Oriented Design Patterns
No ratings yet
C++ Object-Oriented Design Patterns
37 pages
Non-linear Data Structures: Binary Trees
No ratings yet
Non-linear Data Structures: Binary Trees
35 pages
Understanding DFAs, NFAs, and Grammars
No ratings yet
Understanding DFAs, NFAs, and Grammars
11 pages
Critical Review of Mobile Privacy Research
No ratings yet
Critical Review of Mobile Privacy Research
37 pages
A Survey On Security For Mobile Devices
No ratings yet
A Survey On Security For Mobile Devices
26 pages
Mean, Median, Mode Explained
No ratings yet
Mean, Median, Mode Explained
36 pages
GoF Patterns in Expression Tree Case Study
No ratings yet
GoF Patterns in Expression Tree Case Study
295 pages
GoF Patterns in Expression Tree Case Study
No ratings yet
GoF Patterns in Expression Tree Case Study
295 pages
XtremeMiner: Custom Mining Rig Catalog
No ratings yet
XtremeMiner: Custom Mining Rig Catalog
19 pages
Stallings 8e Accessible Fullppt 03
No ratings yet
Stallings 8e Accessible Fullppt 03
34 pages
Powerful Proofreading Techniques
100% (1)
Powerful Proofreading Techniques
2 pages
How To Make An F-4 Paper Model
No ratings yet
How To Make An F-4 Paper Model
6 pages
Planning Implementing and Evaluating Understanding The Connections
100% (1)
Planning Implementing and Evaluating Understanding The Connections
24 pages
Sanjana N.C.'s Career Overview
No ratings yet
Sanjana N.C.'s Career Overview
6 pages
Dont Aim Too High For Your Kids
No ratings yet
Dont Aim Too High For Your Kids
14 pages
Face Recognition Door Access System
No ratings yet
Face Recognition Door Access System
53 pages
Principles of Management Solved Exam Questions
No ratings yet
Principles of Management Solved Exam Questions
17 pages
O-Level Biology, Note Transport in Flowering Plant
100% (1)
O-Level Biology, Note Transport in Flowering Plant
7 pages
GP 380
No ratings yet
GP 380
60 pages
Stacks Questions and Answers - Sanfoundry PDF
No ratings yet
Stacks Questions and Answers - Sanfoundry PDF
4 pages
ICCPBE 2021: Biosciences & Engineering Conference
No ratings yet
ICCPBE 2021: Biosciences & Engineering Conference
2 pages
Voyage Planning: Key Stages & Responsibilities
100% (4)
Voyage Planning: Key Stages & Responsibilities
17 pages
DAGDA Rig Move Report: OAK to SKM
No ratings yet
DAGDA Rig Move Report: OAK to SKM
60 pages
RBI Grade B Test Series Phase 1 2 3
No ratings yet
RBI Grade B Test Series Phase 1 2 3
6 pages
Strategies to Avoid Communication Breakdown
No ratings yet
Strategies to Avoid Communication Breakdown
2 pages
Payment Records for January 2019
No ratings yet
Payment Records for January 2019
4 pages
Crafting an Effective Literature Review
100% (3)
Crafting an Effective Literature Review
5 pages
Cannabis Essential Oils Analysis Techniques
No ratings yet
Cannabis Essential Oils Analysis Techniques
14 pages
Enegy Transition Research
No ratings yet
Enegy Transition Research
101 pages
3-4 СБОРНИК АНГЛИЙСКИЙ ЯЗЫК
No ratings yet
3-4 СБОРНИК АНГЛИЙСКИЙ ЯЗЫК
59 pages
Low Power VLSI Circuits Design Strategies and Methodologies: A Literature Review
No ratings yet
Low Power VLSI Circuits Design Strategies and Methodologies: A Literature Review
7 pages
Urban Climate: Richa Sharma, P.K. Joshi
No ratings yet
Urban Climate: Richa Sharma, P.K. Joshi
16 pages
Polymer Molecular Weight via Viscosity
No ratings yet
Polymer Molecular Weight via Viscosity
10 pages
Mini Project Light Green
No ratings yet
Mini Project Light Green
10 pages
Bill of Supply For Electricity: BSES Yamuna Power Limited
No ratings yet
Bill of Supply For Electricity: BSES Yamuna Power Limited
2 pages
Overview of Engineering Disciplines
No ratings yet
Overview of Engineering Disciplines
2 pages
Coding and Decoding Questions For IBPS PO Prelims
No ratings yet
Coding and Decoding Questions For IBPS PO Prelims
12 pages
HRM Swot Report
No ratings yet
HRM Swot Report
10 pages