|  | 
          <boost/python/def_visitor.hpp> provides a generic visitation interface
          through which the class_
          def member functionality can be extended non-intrusively to avoid cluttering
          the class_
          interface. It declares the def_visitor<T> class template, which is parameterized
          on the derived type DerivedVisitor,
          which provides the actual def
          functionality through its visit
          member functions.
        
          The class def_visitor is
          a base class paramaterized by its derived class. The def_visitor
          class is a protocol class. Its derived class, DerivedVisitor, is expected
          to have a member function visit.
          The def_visitor class is
          never instantiated directly. Instead, an instance of its subclass, DerivedVisitor,
          is passed on as an argument to the class_
          def member function.
        
namespace boost { namespace python { template <class DerivedVisitor> class def_visitor {}; }
The client supplied class DerivedVisitor template parameter is expected to: * be privately derived from def_visitor * grant friend access to class def_visitor_access * define either or both visit member functions listed in the table below:
| Expression | Return Type | Requirements | Effects | 
|---|---|---|---|
| 
                           | 
                           | 
                           | 
                          A call to  | 
| 
                           | 
                           | 
                           | 
                          A call to  | 
class X {/*...*/}; class my_def_visitor : boost::python::def_visitor<my_def_visitor> { friend class def_visitor_access; template <class classT> void visit(classT& c) const { c.def("foo", &my_def_visitor::foo); c.def("bar", &my_def_visitor::bar); } static void foo(X& self); static void bar(X& self); }; BOOST_PYTHON_MODULE(my_ext) { class_<X>("X") .def(my_def_visitor()); }