boost::appy_visitor

{ Reformatted; please limit your lines to 70 characters -mod }

I'm experimenting with the use of a class template that'll accept a
user defined visitor. At some point I'll call boost::apply_vistor on
the user defined visitor. The code below produces the error:
"boost::apply_visitor(Visitor &)' : expects 1 arguments - 2 provided"
on MSVC 2010 and I'm not sure how to resolve the error. Ideas?

In addition, how could I use a member function template instead of a
class template such that the member function template will accept the
user defined visitor (in this case example_visitor), the store it for
later use?

Thanks in advance

# include <iostream>
# include <map>
# include <boost/variant.hpp>
# include <boost/mpl/vector.hpp>
# include <boost/mpl/contains.hpp>
# include <boost/utility/enable_if.hpp>

// Generic visitor that does magical dispatching of
// types and delegates passes down to your visitor only
// those types specified in a type list.
template <typename Visitor, typename TypeList>
struct lets_see :
   public boost::static_visitor<void>,
   public Visitor
{
     template <typename T>
     inline void operator ()
         ( T v, typename boost::enable_if<
           typename boost::mpl::contains< TypeList, T >::type >::type
*dummy = NULL ) const
     {
         Visitor::operator () (v);
     }

     template <typename T>
     inline void operator ()
         ( T v,
           typename boost::disable_if <
              typename boost::mpl::contains< TypeList, T >::type >::type
*dummy = NULL ) const
     {}
};

struct nil { int x ; };
struct example_visitor
{
   typedef lets_see
       < example_visitor,
         boost::mpl::vector<nil, char, int > > value_type;

   inline void operator () (char v) const {
     std::cout << "character detected" << std::endl;
   }

   inline void operator () (int v) const {
     std::cout << "integer detected=" << v << std::endl;
   }

   inline void operator () (nil v) const {
     std::cout << "nil detected=" << v.x << std::endl;
   }
};

template < typename T >
class Foo {
protected :

   typedef boost::variant <
        nil, char, int, double
    > sql_field;
   T visitor ;
   typedef std::map< unsigned int , Foo <T>* > FooMap;
   static FooMap mFooMap;

public :
    static Foo <T>* createInstance( unsigned int const );
    void Register( unsigned int const, Foo< T >* );
    virtual void doWork () ;
};
template < typename T>
typename Foo<T>::FooMap Foo<T>::mFooMap;

template < typename T>
Foo<T>* Foo<T>::createInstance( unsigned int const in ) {
   FooMap::iterator it = mFooMap.find( in );
   if ( it != mFooMap.end() ) {
     return ( it->second );
   } else {
     return 0 ;
   }
}

template < typename T>
void Foo<T>::Register( unsigned int const in, Foo<T>* factory ) {
   mFooMap.insert( FooMap::value_type( in, factory ) );
}
template < typename T>
void Foo<T>::doWork() {}

template <typename T>
class Bar : public Foo <T> {
// Bar( const bar& );
public :
   Bar( unsigned int a ) {
     Register ( a, this ) ;
   }

   static Bar mBar;

   void doWork () {
     sql_field intField ( 1 );
     boost::apply_visitor ( visitor, intField );
     std::cout << "Work done" << std::endl;
   }
};

template < typename T>
Bar<T> Bar<T>::mBar;

int main() {

   try {
     typedef Foo <example_visitor::value_type> FooValueType;
     //Bar <example_visitor::value_type> b ( 5 );
     Bar <FooValueType> b ( 5 );
     Foo <FooValueType>* ptr = Foo<FooValueType>::createInstance ( 5 ) ;
     if ( ptr ) {
       ptr->doWork();
     }
   } catch ( const std::exception& e ) {
     std::cout << e.what() << std::endl;
   }
   std::cout << "[done]" << std::endl;
   std::cin.get() ;

}

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