HI all,

I’m in need of some design advice here.

I have a hierarchy of classes representing logical formulas.  I then
have some visitors that do stuff on them.

One of those visitors has the general method

public void visit(Formula form){
 // do some pre-visit work on the formula, such as bringing it in
normal form
 form.accept(this)
 // do some post-visit work on the result, such as make sure the
variables are singletons where need be
}

Then, of course, there are all the other methods for all possible
subclasses of the Formula interface:

public void visit(Negation form) {
 // do stuff specific to negation
 setResult(whateverComputed);
}

and similar for Disjunction, Inclusion, ...

Now, the problem is:  if a user declares a formula of type Negation, and
then lets the builder visit it:

Negation neg = new Negation(negatedFormula);
builder.visit(neg);

it will of course jump into the formula for Negation.  That should not
happen, since the computations done before and after visiting are
necessary (e.g. visit(Implication) just throws an exception, since they
do not occur in the normal form).

Is there a way to prevent users from calling visit(Negation), to force
them to use visit(Formula)?

A sketch of the current design is:

public interface Visitable {

 void accept(final FormulaVisitor visitor) throws VisitorException;

}

public interface Formula extends Visitable {

 // stuff common to formulas

}

public interface FormulaVisitor {

    void visit(final Formula form) throws VisitorException;

    void visit(final Negation form) throws VisitorException;

    void visit(final Conjunction form) throws VisitorException;

... for other subclasses

}

Aha, typing this out gave me the solution: I can make FormulaVisitor an
abstract class and all but the visit(Formula) methods protected.  That
solves the problem.

However, if someone sees a better way, please tell me!

Cheers, H.
- --
Hendrik Maryns
http://tcl.sfs.uni-tuebingen.de/~hendrik/
==================
http://aouw.org
Ask smart questions, get good answers:
http://www.catb.org/~esr/faqs/smart-questions.html