This document discusses the visitor design pattern. The visitor pattern represents an operation to be performed on elements of an object structure without changing the classes of the elements. It is useful when adding new operations to an object structure like an abstract syntax tree that contains many node types. With the visitor pattern, each node type accepts a visitor object that contains operations specific to that node type, rather than putting operations directly in each node class. This avoids changing node classes when adding new operations and separates operation code from class code for better structure and maintenance.

1. By Nishant S Mevawala
MSC IT(sem-2)
MSIT/11/003

2. Intent

Represent an operation to be performed on the elements of
an object structure. Visitor lets you define a new operation
without changing the classes of the elements on which it
operates.

The classic technique for recovering lost type information.

Do the right thing based on the type of two objects.

Double dispatch

3. Motivation

Consider a compiler that parses a program and represents the parsed
program as an abstract syntax tree (AST). The AST has many
different kinds of nodes, such as Assignment , Variable Reference,
and Arithmetic Expression nodes.

4. Motivation (con..)



Operations that one would like to perform on the AST include:
1. Checking that all variables are defined
2. Checking for variables being assigned before they are used
3. Type checking
4. Code generation
5. Pretty printing/formatting
These operations may need to treat each type of node differently
One way to do this is to define each operation in the specific node
class

5. Motivation (con..)

Problems with this approach:
1. Adding new operations requires changes to all of the node
classes
2.It can be confusing to have such a different set of operations in
each node class. For example, mixing type-checking code with
pretty-printing code can be hard to understand and maintain.

Another solution is to encapsulate a desired operation in a separate
object, called a visitor. The visitor object then traverses the elements
of the tree. When an tree node "accepts" the visitor, it invokes a
method on the visitor that includes the node type as an argument.
The visitor will then execute the operation for that node - the
operation that used to be in the node class.

6. Structure Summary

7. Structure

The Element hierarchy is instrumented with a “universal method
adapter”. The implementation of accept() in each Element derived
class is always the same. But – it cannot be moved to the Element
base class and inherited by all derived classes because a
reference to this in the Element class always maps to the base
type Element.

8. Structure (Con..)

When the polymorphic firstDispatch() method is called on an
abstract First object, the concrete type of that object is “recovered”.
When the polymorphic secondDispatch() method is called on an
abstract Second object, its concrete type is “recovered”. The
application functionality appropriate for this pair of types can now
be exercised.

9. Example

The Visitor pattern represents an operation to be performed on the
elements of an object structure without changing the classes on which
it operates. This pattern can be observed in the operation of a taxi
company. When a person calls a taxi company (accepting a visitor), the
company dispatches a cab to the customer. Upon entering the taxi the
customer, or Visitor, is no longer in control of his or her own
transportation, the taxi (driver) is.

10. Rules of thumb

The abstract syntax tree of Interpreter is a Composite (therefore
Iterator and Visitor are also applicable).

Iterator can traverse a Composite. Visitor can apply an operation over
a Composite.

The Visitor pattern is like a more powerful Command pattern because
the visitor may initiate whatever is appropriate for the kind of object
it encounters.

The Visitor pattern is the classic technique for recovering lost type
information without resorting to dynamic casts.

11. Thank You