The document discusses the visitor design pattern, which separates an operation from an object structure it operates on so that new operations can be added without changing existing classes. It provides examples of using visitors for command processing, message processing, and AST traversal. The key benefits are separating operations from data structures for easier maintenance and allowing new operations to be added without changing classes. Some drawbacks are that recursion can make debugging difficult and updating visitors is costly if the data structure interface changes frequently.

1. Visitor PatternVisitor Pattern
Michael Fong
v0.11 . 1

2. ChangelogChangelog
v 0.1
Basic concept plus examples including
AST DFS traversal, BFS
Message processing
Command processing
Applicability
PRO vs CON
1 . 2

3. Object Oriented StructureObject Oriented Structure
Mixed data attribute with operations.
Composite Pattern
Part - Whole Hierarchy
Be able to treat treat all objects in the composite
structure uniformly
2 . 1

4. How Can We Do DifferentlyHow Can We Do Differently
All operations and data structure are defined in one
place. Hard to maintain and understand when
complexity grows.
Operations to be performed on a data structure
separately - Visitor pattern allow developers to define
a new operation without changing the classes of the
data structure on which it operates.
Operations can be added / removed without changing
the data structure interface.
2 . 2

5. Conceptual ClassConceptual Class
DiagramDiagram
2 . 3

6. Example: Command ProcessingExample: Command Processing
Data Structure
Commander, Sergeant, Soldier extends Unit
Visitor
SergeantVisitor, CommanderVisitor, SoldierVisitor
implements UnitVisitor
[ ]Ref 3 . 1

7. Example : Message ProcessingExample : Message Processing
Data Structure
MessageType1, MessageType2 implements
Message
Visitor
MessageVisitorImpl implements MessageVisitor
3 . 2

8. Example : AST TraversalExample : AST Traversal
Data Structure
ASTNode extends Node
Visitor
DepthFirstVisitor / BreadthFirstVisitor /
PrettyPrintVisitor implements Visitor
[ ]Link
3 . 3

9. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

10. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

11. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

12. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

13. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

14. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

15. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

16. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

17. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

18. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

19. AST - Depth First TraversalAST - Depth First Traversal
+
+ 3
3 . 4
1 2

20. Breadth First TraversalBreadth First Traversal
3 . 5

21. Breadth First TraversalBreadth First Traversal
3 . 5

22. Breadth First TraversalBreadth First Traversal
3 . 5

23. Breadth First TraversalBreadth First Traversal
3 . 5

24. Breadth First TraversalBreadth First Traversal
3 . 5

25. Breadth First TraversalBreadth First Traversal
3 . 5

26. Other ExamplesOther Examples
AnnotationValueVisitor
FileVisitor
Java Doc
Java Doc
Tutorial
3 . 6

27. When to use Visitor PatternWhen to use Visitor Pattern
Many distinct and unrelated operations need to be performed
on objects in an object structure. Visitor lets you keep related
operations together by defining them in one class.
An data structure contains many classes of objects with differing
interfaces, and you want to perform operations on these objects
that depend on their concrete classes. - ** Message Processing
Example **
The classes defining the object structure rarely change, but you
often want to define new operations over the structure.
Changing the object structure classes requires redefining the
interface to all visitors, which is potentially costly. If the object
structure classes change often, then it's probably better to
define the operations in those classes
4 . 1

28. PRO CON
Recursion Recursive by nature Hard to debug
Data / Operation
Separation
Adding / Maintaining
new operations easy.
Costly to update
Visitor
implementation if
data structure
interface is
constantly changing
Flexibility of Data
Object Handling
Allow to add any types
of data object to a
Visitor interface
Accumulating State Visitors can accumulate
states as they visit data
class Visitor {
void visitIData1(DataImpl1);
void visitIData2(DataImpl2);
}
4 . 2