Mailman 3 August 2005 - Cplusplus-sig

How to wrap protected virtual methods
by Eric Jardim Aug. 7, 2005

Aug. 7, 2005

Hi, again... I finally managed to wrap public virtual functions correctly. Everything is fine and I eliminated all of the "segfaults" caused by bad chosen return value policies. But I have another challenge: wrapping protected virtual methods. I know that virtual methods cannot be called outside the class. They might be visible only by its class scope and its derived classes. But imagine now (thinking hybrid) that you may want to derive this C++ class (with a protected method) in Python. Then, it should be something like this: ======= C++ ========= class QWidget: { ... protected: void mouseEvent(QEvent* event) { ... } }; ====== Python ====== class MyWidget(QWidget): def __init__(self, ...): QWidget(self, ...) def mouseEvent(self, event): # ... do something QWidget.mouseEvent(self, event) # call the default after or: def mouseEvent(self, event): QWidget.mouseEvent(self, event) # call the default before # ... do something or worse: def mouseEvent(self, event): # ... do something # do not call the default I tried the same approach we discussed today on this list. But it didnt worked, because the compiler complainted when I tried to pass a pointer of a protected method. So, is there any way to do this, as naturally as possible? I though 2 solutions for this problem: 1 - One is wrapping the "default_mouseEvent" on the wrapped class with a different name. I think it should work, but the user must know that he should call a different name for the same function. It may confuse the user. 2 - The other way is a "hack". I can create a static semaphor inside the method, so I realise if it is the first (or not) time it is being called. If it is called the first time, I try to call the Python overriden version. If it is called twice or more, I call the default implementation. This way, the user can use the same function for different behaviors. The second approach seems to be dangerous. I am afraid of loosing the semaphor control (eg: if an exception is thrown). Well, is there a more simple and secure way of doing this? Thanks, [Eric Jardim] P.S. Sorry for bothering you all with so many questions in just a single day

2 2

How do I wrap virtual methods (solved)
by Eric Jardim Aug. 5, 2005

Aug. 5, 2005

Hi all, I changed the wrapping approach to the wrapper<...>, and with some ajustments it worked. I will display the code (just the essential part) below: struct QObject_Wrapper: QObject, wrapper<QObject> { // notice that I have overloaded constructors // so I have to redefine them QObject_Wrapper(): QObject() { } QObject_Wrapper(QObject* parent): QObject(parent) { } bool event(QEvent* p0) { if (override event = this->get_override("event")) { // here is the trick. "event" is a Python object // not a real C++ funcion return event( ptr( p0 ) ); } return QObject::event(p0); } bool default_event(QEvent* p0) { return this->QObject::event(p0); } }; void export_QObject() { class_<QObject_Wrapper, boost::shared_ptr<QObject_Wrapper>, boost::noncopyable> ("QObject") // constructor with no parent .def(init<>()) // constructor with QObject parent .def(init<QObject*>( args("parent") ) [with_custodian_and_ward<1,2>()] ) .def("event", &QObject::event, &QObject_Wrapper::default_event) ; } So, it solved the problem. The only thing that I am concerned about, is how does it know to convert native "QObject" to the "QObject_Wrapper". Well its working well anyway. BTW, Pyste must be updated for that wrapper<...> use. Thanks everybody. I am enjoying Boost.Python more everyday :) [Eric Jardim]

2 3

How do I wrap virtual methods
by Eric Jardim Aug. 5, 2005

Aug. 5, 2005

Hi, I am wrapping a library, and everything is going well. But now I am trying to wrap some virtual methods. After that a strange behavior is happening (I am using boost 1.32). I am using Pyste to wrap a "scratch code" for me, and I then manually insert some wrapped functions/classes/enums to the definitive source. (This approach might be strange, but it is good for me. It helps me learning Boost.Pythonconstructs, and it's a way to control errors for each step.) The error consist basically of a wrapped virtual method of the "QObject" class being called *without* it being reimplemented in Python. Of course it was reimplemented in C++, when the "QObject_Wrapper" class was created. Pyste is generating the "QObject_Wrapper" with the overloaded constructors, a "PyObject* py_self" reference to the Python object, everything explicit! On the other hand, I saw on the tutorial that you should use a construct like: struct BaseWrap : Base, wrapper<Base> { int f() { if (override f = this->get_override("f")) return f(); // note* return Base::f(); } int default_f() { return this->Base::f(); } }; // *note: on MSVC use // return call<char const*>(f.ptr()); I think that this will solve the problem, because it tests if there is a overriden method. I am still confused if wrapper<...> will create the apropriate contructors. So what do "wrapper<..>" really do? Another thing that I noticed is that I have to reimplement virtual methods on every derived class. This is an accumulative task. Am I right? So, what is the right and safe way to wrap virtual methods? Thanks, [Eric Jardim]

2 4

Possible bug for return_internal_reference with shared_ptr
by Dr. Michael Knecht Aug. 5, 2005

Aug. 5, 2005

Hallo, i am using internal reference with shared pointers to handle borrowed references. Here the code: begin cpp-------------------- #include <boost/shared_ptr.hpp> #include <boost/python.hpp> using namespace boost; using namespace python; class B { public: B() : _a(0) {} void set(const int & a) { _a = a; } const int & get() const { return _a; } private: int _a; }; typedef shared_ptr<B> ptr_type; class A { public: A() : _a(new B()) {} void set(const ptr_type & a) { _a = a; } const ptr_type & get1() const { return _a; } const ptr_type & get2() const { return _a; } private: ptr_type _a; }; BOOST_PYTHON_MODULE(ptr_test) { class_<A, shared_ptr<A> >("A") .def("set", &A::set) .def("get1", &A::get1, return_value_policy<copy_const_reference>()) .def("get2", &A::get2, return_internal_reference<>()) ; class_<B, shared_ptr<B> >("B") .def("set", &B::set) .def("get", &B::get, return_value_policy<copy_const_reference>()) ; } end cpp --------------------- begin python --------- from ptr_test import * a = A() b1 = a.get1() print b1.get() b2 = a.get2() print b2.get() end python -------------------- If I execute the python script I get the following error message: TypeError: No Python class registered for C++ class boost::shared_ptr<B> begin out -------------------- 0 Traceback (most recent call last): File "test.py", line 8, in ? b2 = a.get2() TypeError: No Python class registered for C++ class boost::shared_ptr<B> end out ----------------------- So return_value_policy<copy_const_reference> is working and return_internal_reference<> not! Any ideas why boost/python can not handle this? I think to handle internal references is importend for containers and iterators.

2 1

return_arg
by Ira Aug. 5, 2005

Aug. 5, 2005

Hi, Say I have a C++ class exposed to python. The C++ code creates an instance of said class and I want to retrieve it from python code. What would be the correct way for python code to 'get' the reference? Regardless can someone please elaborate on the the whole "param passing & return value" subject. It might be me but I had a hard time with return_arg<> (I don't get what arg_pos is suppose to mean), and the example discusses only return_self What I *tried* to do is: MyClass* pMyClass; main() { pMyClass = new MyClass; } MyClass* GetMyClass() { return pMyClass; } BOOST_PYTHON_MODULE(mymod) { class_<MyClass>..... def ("GetMyClass", GetMyClass); } This didn't compile with "C2027 use of unspecified type boost::python::detail::specify_a_return_value_to_wrap_functions_returning<T> with T=result_t". I tried messing around with the def, adding return_arg<> but nothing did the trick for me. Cheers, Ira

3 4

Re: [C++-sig] to_python / from_python guidance?
by Alexis H. Rivera-Rios Aug. 4, 2005

Aug. 4, 2005

I'm using the one that can be downloaded from: Generic Graphic Toolkit http://ggt.sourceforge.net/ Is this the same one? Alexis Programming Tutorial: In Python: To do this, do this In Perl: To do this, do this or this or this or this... In C: To do this, do this, but be careful In C++: To do this, do this, but don't do this, be careful of this, watch out for this, and whatever you do, don't do this ____________________________________________________ Start your day with Yahoo! - make it your home page http://www.yahoo.com/r/hs

2 1

Pyste Modification for operator[]: is there any python function to know whether a C++ type is a class or basic data type?
by Aghera, Parixit Aug. 3, 2005

Aug. 3, 2005

Hi All, I have a C++ library which I want to export to python using pyste. There are several sequence class in C++ library which overloads [] operator and that is the only way to access an element in sequence. Current pyste implementation (Release version 1_32_0) doesn't handle operator [], so I modified ClassExporter.py to generate the .defs for __getitem__ and __setitem__ in the pyste generated .cpp. Following the template function for getitem and pyste modification. It seems that for C++ struct/class I have to return the element by reference and for other C++ types (basic/enums) I need to return the element by value. I learnt this by experiments and from boost/python/suite/indexing/vector_indexing_suite.hpp . Now the problem I run into here is this. I need to add return_internal_reference< 1 > in generated .def in case when getitem function return element by reference. Now in python I don't know a way to figure out whether IndexOp_PysteWrapper_getitem function will return element by reference or by value, since I don't know if the return type of operator[] is a C++ class/structure or basic data type. Any solution/hints for solution to this problem would be a great help. Template Function: template <typename T> typename boost::mpl::if_<is_class<T>,T&,T>::type IndexOp_PysteWrapper_getitem(TAO_Unbounded_Sequence<T>& seq, int index) { if (index < 0) { index = seq.length() + index; // negative index } if (index >= seq.length()) { PyErr_SetString(PyExc_IndexError, "index out of range"); throw_error_already_set(); } return seq[index]; } Pyste Modification: Added folloing function for handling index operator in ClassExporter. This function is called when operator[] is found in the class being exported. Depending on return type of the operator[] (is it const or not), I determine whether setitem and getitem should be supported. def HandleIndexOperator(operator): if operator.result.const: self.Add('inside', '.def("__getitem__", &IndexOp_PysteWrapper_getitem<%s>)' % (operator.result.name)) else: self.Add('inside', '.def("__setitem__", &IndexOp_PysteWrapper_setitem<%s>)' % (operator.result.name)) Thanks, Parixit

2 1

to_python / from_python guidance?
by Alexis H. Rivera-Rios Aug. 3, 2005

Aug. 3, 2005

Hi, I'm trying to expose a class that uses a third party library: gmtl. The gmtl library has already bindings for python. I want to be able to do this: struct Test { gmtl::Vec3d x; gmtl::Point3d y; Test() : x(0,0,0),y(0,0,0) {} Test(const Test &other) : x(other.x), y(other.y){} Test& operator=(const Test& other) { if (this==&other) return *this; x = other.x; y = other.y; } }; Im exposing the class like this: class_< Test >("Test", init< >()) .def(init< const Test& >()) .def_readwrite("x", &Test::x) .def_readwrite("y", &Test::y) ; But this fails: >>> import gmtl >>> from PyStatATA import * >>> test = Test() >>> test.x = gmtl.Vec3d(0,0,1) Traceback (most recent call last): File "<stdin>", line 1, in ? Boost.Python.ArgumentError: Python argument types in None.None(Test, Vec3d) did not match C++ signature: None(struct Test {lvalue}, class gmtl::Vec<double,3>) >>> test.y = gmtl.Point3d(0,0,1) Traceback (most recent call last): File "<stdin>", line 1, in ? Boost.Python.ArgumentError: Python argument types in None.None(Test, Point3d) did not match C++ signature: None(struct Test {lvalue}, class gmtl::Point<double,3>) >>> my = test.y Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: No Python class registered for C++ class class gmtl::Point<double,3> >>> mx = test.x Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: No Python class registered for C++ class class gmtl::Vec<double,3> >From my understanding, to solve this I need to define the to and from python converters. But the examples assume I have headers to the python type of gmtl::Vec3d and gmtl::Point3d. In my case, I don't have that. What is the best approach to solve this? Thanks, Alexis Programming Tutorial: In Python: To do this, do this In Perl: To do this, do this or this or this or this... In C: To do this, do this, but be careful In C++: To do this, do this, but don't do this, be careful of this, watch out for this, and whatever you do, don't do this __________________________________________________ Do You Yahoo!? Tired of spam? Yahoo! Mail has the best spam protection around http://mail.yahoo.com

2 1