260 likes | 288 Views
Behavioural Patterns. GoF pg. 221 -222 Iterator GoF pg. 257 – 271 Memento GoF pg. 283-291 By: Dan Sibbernsen. Overview. Behavioural Concerned with algorithms and responsibilities among objects. Also concerned with methods of communication between them
E N D
Behavioural Patterns GoF pg. 221 -222 IteratorGoF pg. 257 – 271 Memento GoF pg. 283-291 By: Dan Sibbernsen
Overview • Behavioural • Concerned with algorithms and responsibilities among objects. • Also concerned with methods of communication between them • Allow you to put your “interconnected” hat on while taking off your “control” hat.
Iterator • Intent • Provide a means to Iterate through a series of nodes in specific way(s) • Motivation • To traverse lists of information without having to know anything too specific about the objects • To implement multiple algorithms to traverse those nodes.
Iterator:Implementation • Who Controls the Iteration? • External Iterator • Client controls iteration • Client must explicitly request next() on each node • Internal Iterator • Iterator controls iteration • Client hands an operation to the Iterator, Iterator tells every child in the aggregate to perform it.
Implementation Benefits • External Iterator • More flexible than Internal. Can compare 2 collections easily • Internal Iterator • Easier to use, as they define the iteration logic for you. Makes portability easier.
Who defines the traversal Algorithm? • Algorithm can be held by a class outside of the Iterator. It could be held by the aggregate can hold it. • Called “the cursor.” • Allows the algorithm to access private members of the aggregate (and not break encapsulation) • Algorithm is held by the iterator • Allows algorithms to be swapped out easily.
How Robust is the Iterator? • If an iterator is robust it • Will allow for removal of nodes in the middle of traversal. • It does this through registering the iterator with the aggregate. If any nodes are removed, it is notified.
Additional Iterator Operations • All come with first, next, isdone, and currentItem • Previous • Goes to the previous node that was iterated • Can be helpful in certain situations • SkipTo • Skips to a certain node. • Goes to a node matching specific criteria
Using Polymorphic Iterators in c++ • Drawbacks • Allocated dynamically by a factory method. • Client is responsible for deleting them. Can be error prone due to multiple levels of calls, and also because of exceptions • Proxy can be used to remedy this. • Only use them when Polymorphism is required.
Iterators may have privileged access • Makes coupling tighter between Iterator and Aggregate • Can be problematic if there are multiple iterators you want to apply • Solution: make private iterator-specific functions “protected” so that only Iterator subclasses can access them
Iterators for composites • Use an Internal iterator to keep track of the levels-deep it has traversed. This happens recursively so everything is stored on the stack.
Null Iterators • Makes traversal of Composite classes easier. • Always returns IsDone() as true.
Related Patterns • Composite • Factory Method • Memento
Consequences (good) • “Supports variations in the traversal of an aggregate.” • “Iterators simplify the Aggregate interface.” • “More than one traversal can be pending on an aggregate.”
Memento • Intent • “Without violating encapsulation, capture and externalize an object’s internal state so that the object can be restored to this state later.” • Motivation • When we want to store off an object’s internal state without adding any complication to the object’s interface. • Perhaps for an undo mechanism
Undo Mechanism Complications • Constraint-Solver problem • Uses multiple levels deep of objects to draw objects. • What if we want to support undo but can’t localize the changes to just one class? • Propose a Memento that gathers information from objects contained in a certain class
Applicability • Use this • when you want to save state on a hierarchy’s elements. • When the hierarchy’s interface would be broken if implementation details were exposed.
Participants • Memento • stores the state of the Originator • Originator • Creates the memento • “Uses the memento to restore its internal state” • CareTaker • Keeps track of the Memento • Never uses the Memento’s Interface to the Originator
Collaboration • Pg. 286 (can’t find image) • Caretaker requests a memento from an Originator. • Caretaker passes back memento. • Originator uses it to restore state.
Consequences (good) • “Preserves Encapsulation Boundaries” • “It simplifies Originator” • You can name your class “mementos_TheFreshMaker”!!!
Consequences (bad) • Might be expensive • Difficulty defining interfaces to keep Originator encapsulated • Hidden costs in caring for mementos • Caretaker could have to keep track of a lot of information for the memento • You can name your class “mementos_TheFreshMaker” =(
Implementation • Language Support • C++ lets you call Originator a friend of Memento, thus giving it access to all private members of Memento that it needs
Storing Incremental Changes • If storing state happens incrementally, then we can just record the changes of what’s happened in a new memento object. • This helps with memory difficulties.
Related Patterns • Command • Iterator