Think of drawing/diagramming editors • Drawing/diagramming editors let users build complex diagrams out of simple components ECE450 – Software Engineering II – The user can group components to form larger components... – ...which in turn can be grouped to form still larger components Today: Design Patterns VI Composite, Iterator, and Visitor Patterns ECE450 - Software Engineering II 1 ECE450 - Software Engineering II 2 The problem The Composite pattern • Although we grouped the shapes, the system should not treat the result as a “primitive” shape – Even if most of the time we treat them identically – We may decide to ungroup them • Or to modify an attribute of one of the components of the grouped shape •The Composite pattern describes how to use recursive composition so that clients don’t have to make this distinction. • Composite: Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly – The key to the pattern is the abstract class that represents both primitives and their containers. ECE450 - Software Engineering II 3 ECE450 - Software Engineering II 4 1 Structure and participants Structure and participants (cont) • Component – Declares the interface for objects in the composition •Composite – Implements default behavior for the interface common to all classes – Defines behavior for components having children – Declares an interface for accessing and managing its child components – Stores child components – (Optionally) defines an interface for accessing a component’s parent in the structure, and – Implements child-related operations in the Component interface implements it if appropriate • Client •Leaf – Manipulates objects in the composition through the Component interface – Represents leaf objects in the composition. A leaf has no children – Defines behavior for primitive objects in the composition ECE450 - Software Engineering II 5 ECE450 - Software Engineering II 6 Applicability Consequences • Use the Composite pattern when... • The pattern defines class hierarchies consisting of primitive objects and – You want to represent part-whole hierarchies of objects composite objects – You want clients to be able to ignore the difference between compositions of – Primitive objects can be composed into more complex objects, which in turn can objects and individual objects. be composed, and so on recursively. • Clients will treat all objects in the composite structure uniformly – Wherever client code expects a primitive object, it can also take a composite object • A second example: file systems • Makes the client simple – Directories contain entries, each of which could be a directory – Clients can treat composite structures and individual objects uniformly. – Clients don’t know (and shouldn’t care) whether they’re dealing with a leaf or a composite component • But can make your design overly general – The disadvantage of making it easy to add new components is that it makes it harder to restrict the components of a composite • Sometimes you want only some kinds of components, but you’ll have to use run-time checks to guarantee your constraints. ECE450 - Software Engineering II 7 ECE450 - Software Engineering II 8 2 That was it for structurals... Implementation Now we need to tackle behaviorals • Explicit parent references? • We’ve gone through the creational – You may want to maintain references from child components to their parent to patterns... simplify traversal and management of a composite structure – Factory method – Abstract factory – The usual place to define the parent reference is in the Component class –Builder –Prototype • Declaring the child management operations? –Singleton – Our diagram has the Component abstract class declare the Add and Remove • ... the structural ones... operations for managing children, but leaf nodes never use them –Decorator – Is it better to have those operations declared in the Composite class? – Adapter – Tradeoff between safety and transparency: – Facade • Defining the child management interface at the root gives you transparency (you can –Proxy treat all components uniformly) but costs you safety (clients may try to do meaningless – Flyweight things like add and remove objects from leaves!) – Bridge • Defining child management in the Composite class gives you safety (any attempt to add • ...and two behaviorals or remove objects from leaves will be caught at compile-time), but you lose transparency (leaves and composites have different interfaces). –Template method – Null object • What is the best data structure for storing components? • A (short) review is in order... – Depends on efficiency. It is possible that you don’t even need a general-purpose data structure at all! ECE450 - Software Engineering II 9 ECE450 - Software Engineering II 10 Behavioral patterns We’ll start with a simple one... • Behavioral patterns are concerned with algorithms and the assignment of • Assume you have an aggregate object such as a list responsibilities between objects – They describe not just patterns of objects or classes, but also the patterns of • This aggregate object should give you a way to access its elements communication between them without exposing its internal structure. – And you may want to traverse the list in different ways • However, adding the operations for different traversals to the List interface would bloat it – The List is there for a purpose different than supporting our traversals • And remember classes should do just one thing, if possible (maximizing cohesion) – Not only that, but you may want to traverse it more than once at the same time • How can we address this problem? ECE450 - Software Engineering II 11 ECE450 - Software Engineering II 12 3 The Iterator pattern Structure and participants • Iterator: Provide a way to access the elements of an aggregate object •Iterator sequentially without exposing its underlying representation – Defines an interface for accessing and traversing elements – You probably knew of this one already • ConcreteIterator • Java’s Iterator interface is an application of this principle – Implements the Iterator interface – Keeps track of the current position in the traversal of the aggregate • Aggregate – Defines an interface for creating an Iterator object • ConcreteAggregate – Implements the Iterator creation interface to return an instance of the proper ConcreteIterator ECE450 - Software Engineering II 13 ECE450 - Software Engineering II 14 Applicability Consequences • Use the Iterator pattern... • Iterators support variations in the traversal of an aggregate – To access an aggregate object’s contents without exposing its internal – Complex aggregates may be traversed in many ways. Iterator subclasses (or representation Iterator instances) allow clients to traverse the aggregate in the way they desire – To support multiple traversals of aggregate objects – To provide a uniform interface for traversing different aggregate structures • More than one traversal can be pending on an aggregate • That is, to support polymorphic iteration – An iterator keeps track of its own traversal state. Therefore, you can have more than one traversal in progress at once ECE450 - Software Engineering II 15 ECE450 - Software Engineering II 16 4 Implementation Operations on a compiler • Who controls the iteration? • Consider a compiler that represents programs as abstract syntax trees – When the client controls the iteration, the iterator is called an external iterator – Every node is a token (a variable, an assignment, etc.) • Clients must advance the traversal and request the next element explicitly – The compiler needs to perform operations on the trees for various kinds of – When the iterator controls it, the iterator is an internal iterator analyses • Clients hand an internal iterator an operation to perform, and the iterator applies that • Type-checking operation to every element in the aggregate • Code optimization • Who defines the traversal algorithm? • Flow analysis – It could be defined in the iterator (making it easy to use different iteration • ... algorithms in the same aggregate) or in the aggregate (probably necessary if we – Most of these operations will need to treat nodes that represent assignment need to access private variables of the aggregate) statements differently from nodes that represent variables or arithmetic expressions • Iterators for Composites • There will be one class for assignment statements, another for variable accesses, etc. – External iterators can be difficult to implement over recursive aggregate – Distributing all our operations across the various node classes leads to a system structures like Composites that is hard to understand, maintain, and change • They need to store a path through the Composite to keep track of the current object • It will be confusing to have type-checking code mixed with pretty-printing code • Null iterator – It would be better if each new operation could be added separately, and the – A null iterator always “is done” with the traversal node classes were independent on the operations that apply to them – They can make traversing tree-structured aggregates (like Composites) easier • Aggregate elements return a concrete iterator as usual • But leaf elements return an instance of NullIterator ECE450 - Software Engineering II 17 ECE450 - Software Engineering II 18 The Visitor pattern Participants and structure • Represent an operation to be • Visitor performed on the elements of – Declares a