boost/python/def_visitor.hpp

Introduction

<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.

Class `def_visitor`

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 {};
}

Requires

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
`visitor.visit(cls)`	`void`	`cls` is an instance of a class_ being wrapped to Python. `visitor` is a `def_visitor` derived class.	A call to `cls.def(visitor)` forwards to this member function.
`visitor.visit(cls, name, options)`	`void`	`cls` is a class_ instance, name is a C string. `visitor` is a `def_visitor` derived class. options is a context specific optional argument.	A call to `cls.def(name, visitor)` or `cls.def(name, visitor, options)` forwards to this member function.

Example

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());
}