Re: [Boost-users] variant: bounded types derive from same base class

3 Aug 2009

      Hi!

The only solution I can come up with is the declaration of the visitor in
your ABCBase as virtual function and visitor has a function template to
dispatch different types:

class ABCVisitor
{
    public:
    template<class T>
    void visit(T& t)
    {
      // no visit implemented ...
    }
};

class ABCBase
{
   //... dtor, copy ctor, assignment operator etc.

   public:
   void accept_visitor(ABCVisitor& v)
   {
       do_accept_visitor(v);
   }

   private:
   virtual void accept_visitor(ABCVisitor& v)=0;
};

class ABCDerived1
{
   //... dtor, copy ctor, assignment operator etc.
   void accept_visitor(ABCVisitor& v)
   {
       v.visit(*this);
   }
};

template<>
void ABCVisitor::visit<ABCDerived1>(ABCDerived1& derived)
{
   // handle derived here...
}

Hope that helps,
Ovanes

On Mon, Aug 3, 2009 at 4:22 PM, Hicham Mouline  wrote:
...
...
-----Original Message-----
From: boost-users-bounces@lists.boost.org [mailto:boost-users-
bounces@lists.boost.org] On Behalf Of Igor R
Sent: 03 August 2009 14:50
To: boost-users@lists.boost.org
Subject: Re: [Boost-users] variant: bounded types derive from same base
class
...
My restriction is that f takes a ABC const-ref as an input.
Can I construct the variant from the    const ABC& abc
Maybe like
   variant v(abc);
without deep copying. The Di objects are big.
Then I would apply the visitation.
Maybe storing variant...
Yes, you can store ptrs in the variant.
...
So f would look like
void f( const ABC& abc )
{
  const VariantTypeDefProvidedByLib v(&abc);
v.apply_visitor( YourVisitor );
}
You cannot construct the variant in f(), because you already lost the
compile-time type of the object - it's ABC now.
If you'd like to work with ABC's and virtual functions, then why do
you need variant? Variant is about preserving the compile-time type.
Then that's not what I need.
I need a runtime visitor pattern.
Parts of the user code deal with ABCs, and the user also writes functions
for specific derived types,
that use non common public functions of the derived types.
The f function still needs to dispatch to the appropriate piece of code
depending on the ABC type.
void f( const ABC& abc )
{
Switch (abc.getTag())
 {
  case D1tag:  // do something
  ...
   Case Dntag:
  }
}  // I get the warning from g++ if I miss 1 case
Or
void f( const ABC& abc )
{
 if (dynamic_cast(&abc))
  // do something
...
if (dynamic_cast(&abc))
  // do something
}  // no warnings here If I miss a case
Maybe what I want is just not possible,
_______________________________________________
Boost-users mailing list
Boost-users@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

Re: [Boost-users] variant: bounded types derive from same base class

Ovanes Markarian