Visitor pattern for Java

Question

I have a question about visitor pattern! Imagine I have Data structure Class and inside it I have a has-a relation with Class2. Class2 has specific class hierarchy with about 10 classes.

I need to itetarate list of Class1 instances and dispatch request for Visitor.visit(Class1) according to type of Class2. I can't use iteration with class2 because I need variables from class1 context.

Right now I'm thinking something about dispatcher who accept Class1 object and then on the basis of this class it check type of class2 and call something

visitor.visitClass2Type1(Class1 object)

But in this case I loose same signature for visitor pattern...

Another question how can I inject variables in the context of the visitor pattern. like if I traverse tree structures I want to keep parent variable for previous level to perform something on the lower level.

Answer 1

You could add a setContext() method to your Visitor class which tells the Visitor in which context the following objects need to be interpreted.

When you have an object relation which is nested by more than one level, you could add an analogue leaveContext() method and keep a stack of contexts in your visitor class.

Answer 2

I think your Visitor.visit method should be like Visitor.visit(Class2, Class1) Where your visitor class will implement visit method for each types of Class2.

So you can implement visit(Class2-1, Class1), visit(Class2-2,Class1)...visit(Class2-10,Class1)

I think in this way you will be able to access Class1 object info inside visit method and as visit method invocation will be decided dynamically so it won't matter what your Class2 list is having...

For more info you can refer to wiki page: http://en.wikipedia.org/wiki/Visitor_pattern

Answer 3

Taking what Philipp suggested a step farther, try this.

Given class Widget is the parent, and class Feature is the base type of the child hierarchy

Simple usage:

// widget will have an instance of a Feature subclass from args or config, etc
Widget theWidget = new Widget(args);

// create and configure visitor
Visitor theVisitor = new Visitor();
theVisitor.prop1 = x; 
theVisitor.prop2 = y;
theVisitor.prop3 = z;

theWidget.visit(theVisitor);

Widget (parent class):

class Widget 
{
   Feature _childFeature;

   void visit(Visitor visitor)
   {
      visitor.beginAccept(this);
      childFeature.visit(visitor);            
      visitor.endAccept();
   }

}

Feature class hierarchy:

abstract class Feature
{
   abstract void visit(Visitor visitor);
}

class Sunroof extends Feature
{
   void visit(Visitor visitor)
   {
      visitor.accept(this);
   }
}

class BulletProof extends Feature
{
   void visit(Visitor visitor)
   {
      visitor.accept(this);
   }
}

class GoldPlated extends Feature
{
   void visit(Visitor visitor)
   {
      visitor.accept(this);
   }
}

A concrete visitor that uses both the parent and the child:

class ExampleVisitor extends Visitor
{

   private _widgetInProcess;


   void beginAccept(Widget w)
   {
      _widgetInProcess = w;
   }

   void accept(Sunroof feature)
   {
      // do work based on both _widgetInProcess and type-specific feature
   }

   void accept(BulletProof feature)
   {
      // do work based on both _widgetInProcess and type-specific feature
   }

   void accept(GoldPlated feature)
   {
      // do work based on both _widgetInProcess and type-specific feature
   }

   void endAccept()
   {
      _widgetInProcess = null;
   }

}

You can visualize the tree model use-case as well where in beginAccept you push onto a stack, the various accept methods peek the stack to get their parent context, and endAccept pops from the stack. This can allow you to recursively process a tree while always having access to the parent chain.