Visitor stability vs instanceof flexibility

Question

I am writing on a GUI program which allows for the visual creation of some configuration file. I have a class hierarchy for the configuration model and I use an object tree of that hierarchy in several different contexts, like for example visual representation of the configuration. I currently use the Visitor pattern to avoid polluting my model classes.

interface IConfigurationElement {
    void acceptVisitor(IConfigurationElementVisitor visitor);
}

In an earlier version I used chains of instanceof operators wherever I have a IConfigurationElementVisitor now. Comparing the two solutions I see the following tradeof.

Visitor

• It is easier and safer to add new IConfigurationElement. Just add a new declaration to IConfigurationElementVisitor and i have compiler errors for all visitor implementations. With instanceof you have to remember where you put it. Basically instanceof violates the DRY principle as it duplicates logic in several places.
• The visitor pattern is more efficient than a chain of instanceofs

instanceof

• For me, the great advantage of instanceof comes with its flexibility. I have more than 5 implementations of IConfigurationElement but often need special solutions only for a subset of those. instanceof allows me to handly exactly the special cases special and the rest equal. In contrast, Visitor forces me to implement a method for each implementation class every time.

Is there a common solution for this kind of problem? Can I adapt the Visitor somehow, so I can provide a common solution for some cases?

Answer 1

I would highly recommend you this blog tutorial which compares the different visitor style (instanceOf etc) and provides very interesting answers, it helped me I hope it woks for you too:

http://apocalisp.wordpress.com/2009/08/21/structural-pattern-matching-in-java/

Answer 2

You could use visitor with instanceOf

interfaces:

interface Visitable {
  void accept(Object visitor);
}
interface AVisitor {
  void visitA(A a);
}
interface BVisitor {
  void visitB(B b);
}
interface CVisitor {
  void visitB(C c);
}

Visitables:

class C implements Visitable {
  public void accept(Object visitor) {
    if (visitor instanceof CVisitor) {
      ((BVisitor)vistor).visitC(this);
    }
  }
}

class B implements Visitable {
  public void accept(Object visitor) {
    if (visitor instanceof BVisitor) {
      ((BVisitor)vistor).visitB(this);
    }
  }
}

class A extends B implements Visitable {
  public void accept(Object visitor) {
    super.accept(visitor);
    if (visitor instanceof AVisitor) {
      ((AVisitor)vistor).visitA(this);
    }
  }
}

Visitors:

class PrintBs implements BVisitor {
  public void visitB(B b) {
    system.out.println(b);
  }
}

class PrintAs implements AVisitor {
  public void visitA(A a) {
    system.out.println(a);
  }
}

class PrintCs implements CVisitor {
  public void visitC(C c) {
    system.out.println(c);
  }
}
class PrintAsAndCs implements CVisitor, AVisitor{
  public void visitA(A a) {
    system.out.println(a);
  }
  public void visitC(C c) {
    system.out.println(c);
  }
}

each class knows only about its related interfaces, so adding new vistors nor visitables requires changing everything in that category (visitor/visitable) (for visitor, it does not require changing anything, for visitable it requires creating new visitor interface, but again, no changing of existing objects).

This way, there is no chain of instanceof tests and visitor for subset does not need to even know about types outside this subset.

Question is what to do with situation where A extends B (and B is Visitable too), in that case, you could just add super.accept(visitor) into accept (thus it would be short chain of instanceof-s, but onlu as long as hierarchy is deep, and it should not be too deep to matter, abd you don't need to write it whole manually).

Answer 3

Well, yes, you could. Capture the commonalities of the many configuration elements by assigning roles to them. You may end up with instanceof, but not in a way that violates the DRY principle, but rather as a way around C#'s static typing.

class ConfigurationElementA implements IConfigurationElement, ICommittable {
}

class ConfigurationElementB implements IConfigurationElement, IVerifiable {
}

class Visitor {
    void accept(IConfigurationElement element) {
        if (element instanceof ICommittable) {
            // ...
        }

        // Note: not a chain of instanceofs.

        if (element instanceof IVerifiable) {
            // ...
        }
    }
}

In other words, you let the visitor accept configuration elements generically, and act on groups of implementations via roles. Note that you can go as specific as you need by modeling your configuration elements accordingly.

You may recognize here Martin Fowler's RoleInterface pattern.