Question

I have a c++ class which exposes collections by providing functions returning ranges, using boost::range.

In order to export this class to python with boost::python, I use the function boost::python::range, which can accept two parameters: the member functions of the class returning the begin and end iterators of the collection.

I want to avoid writing begin/end pairs manually for each collection, as I already provide the range. But I cannot manage to write a wrapper over boost::python::range accepting as argument a member function returning a range. Any ideas? (I have in fact more than one class, which are templatized, so a template function taking as template parameter the address of a member function of a template class won’t work, my compiler said)

I will accept a c++0x solution if compilable with g++-4.6.

edit: a sample code as asked:
say I have this class:

struct A
{
   std::vector<int> c;
   typedef  boost::sub_range<std::vector<int> > c_range;
   c_range getc() { return c; }
};

To produce a Python iterator from the getc method, I now add these two member functions to class A:

c_range::iterator c_begin() { return getc().begin(); }
c_range::iterator c_end() { return getc().end(); }

and then expose them like this:

boost::python::class_<A>("A")
  .def("getc", boost::python::range(&A::c_begin, &A::c_end));

Is there a way to write directly something like:

.def("getc", pyrange(&A::getc));

and to avoid having to write c_begin and c_end?

Answer 1

The solution was to use the more general form a range with four template parameters: create begin/end accessors as boost::bind‘ed objects, and then specify the Target template parameter of range. For const iterators, this code fulfills my needs:

namespace py = boost::python
template <class T, class Return>
struct range_accessor {
   typedef Return (T::*RA ) () const;
   static typename Return::const_iterator
   begin(RA ra, const T& t) {
       return (t.*ra)().begin();
   }
   static typename Return::const_iterator
   end(RA ra, const T& t) {
       return (t.*ra)().end();
   }

   static py::object
   pyrange(RA ra) {
       auto b = boost::bind(&range_accessor::begin, ra, _1);
       auto e = boost::bind(&range_accessor::end, ra, _1);
       return py::range<
          boost::python::objects::default_iterator_call_policies,
          T> // the "Target" parameter, which can
             //  not be deduced from a bind object
         (b,e);
   }
};

template <class T, class Return>
py::object pyrange(Return (T::*ra ) () const) {
    return range_accessor<T, Return>::pyrange(ra);
}

Edit: a slightly more compact solution, by using a local struct inside function definition:

template <class T, class Return>
py::object
pyrange(Return (T::*ra) () const) {
    typedef Return (T::*RA ) () const;
    struct accessor {
       static typename Return::const_iterator 
       begin(RA ra, const T& t) {
           return (t.*ra)().begin();
       }
       static typename Return::const_iterator
       end(RA ra, const T& t) {
           return (t.*ra)().end();
       }
    };
    return py::range<boost::python::objects::default_iterator_call_policies, T>
        (boost::bind(&accessor::begin, ra, _1),
         boost::bind(&accessor::end, ra, _1));
}