Class hierarchy on visitor side of visitor pattern

Hi all.

Below is a code snippet that sketches two class hierarchies,
on both sides of the visitor pattern.

The visitor pattern is used to handle objects in the Base/derived_n
hierarch according to type. The visitors are also organized in
a class hierarchy, since the pattern will be used in many different
contexts. So all the visitee objects need to know, is the interface
against the BaseVistor class, and one can let DerivedVisitor
classes handle the specifics.

The DerivedClass sets an internal state depending on the type of
object it encounters.

This works in its basic form, where all the functions in the
double dispatch return void.

So to make life as user easy (see the desired syntax as pointed
out in function main()), I want to have the double dispatch methods
return references.

This doesn't work, as the compiler isues an error in the indicated
function DerivedVisitor::visit(): "Cannot convert from BaseVisitor to
DerivedVistor &."

So I am a bit lost. I always thought one could 'generalize' references
and pointer on functon. As far as I can tell, it is the methods
derived_n::dispatchType(BaseVisitor*) that 'peels off' the
information
concerning the derived classes.

Is it at all possible to obtain what I want while leaving the
Base/ derived_n visitee classes with knowledge only about the
BaseVisitor class?

Rune

/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>

class BaseVisitor;
class derived1;
class derived2;

class Base{
public:
    virtual BaseVisitor& dispatchType(BaseVisitor*) = 0;
};

class BaseVisitor{
public:
    virtual BaseVisitor& visit(Base*) = 0;
    virtual BaseVisitor& display(derived1*) = 0;
    virtual BaseVisitor& display(derived2*) = 0;
};

class DerivedVisitor : public BaseVisitor {
public:
    DerivedVisitor& visit(Base* b)
    {
        ////////////////////////////////
        return (b->dispatchType(this)); // <<<<< Compiler error
        ////////////////////////////////
    };
    DerivedVisitor& display(derived1*)
    {
        std::cout << "Derived 1" << std::endl;
        state_ =1;
        return *this;
    };
    DerivedVisitor& display(derived2*)
    {
        std::cout << "derived 2" << std::endl;
        state_ = 2;
        return *this;
    };
    size_t getState() const {return state_;};
private:
    size_t state_;
};

class derived1 : public Base{
public:
    BaseVisitor& dispatchType(BaseVisitor* b)
    {
        return b->display(this);
    }
};

class derived2 : public Base{
public:
    BaseVisitor& dispatchType(BaseVisitor* b)
    {
        return b->display(this);
    }
};

int main()
{
    DerivedVisitor v;
    derived1 d1;
    derived2 d2;

    size_t s = v.visit(&d1).getState(); // <<<< I want this syntax,
not
    // v.visit(&d1);
    // s = v.getState();
    std::cout << s << std::endl;
    return 0;
}

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]