Message-ID: <47B194E3.4030204@sympatico.ca> Marcus Jannes wrote: > It should read ExpClass not c_class here of course: > > ExpClass pycall(ExpClass c){ > PyObject *py_obj; > ExpClass c_result; > py_obj = PyBuildValue("O",c); //does not work! Provide converter function with "O&" argument ? > c_result = SomeConverterToC(py_obj); //??? > return c_result; What are you trying to do here ? What is 'c' ? There shouldn't be any need to use PyObject raw pointers at all. Assuming 'ExpClass' has already been exported, the following should Just Work: ExpClass a = ...; bp::object o(a); //<--- now holds a copy of 'a' ... ExpClass b = bp::extract(o); //<--- attempts to extract an // ExpClass from 'o' > }; Just declare 'pycall' in your module: bp::def("pycall", pycall); HTH, Stefan -- ...ich hab' noch einen Koffer in Berlin... From jannes80 at hotmail.de Tue Feb 12 14:09:47 2008 From: jannes80 at hotmail.de (Marcus Jannes) Date: Tue, 12 Feb 2008 14:09:47 +0100 Subject: [C++-sig] Convert C++ Class to exposed class and back In-Reply-To: <47B194E3.4030204@sympatico.ca> References:

<47B194E3.4030204@sympatico.ca> Message-ID: > What are you trying to do here ? What is 'c' ? There shouldn't be any > need to use PyObject raw pointers at all. Assuming 'ExpClass' has > already been exported, the following should Just Work: > > ExpClass a = ...; > bp::object o(a); //<--- now holds a copy of 'a' > ... > ExpClass b = bp::extract(o); //<--- attempts to extract an > // ExpClass from 'o' > >> }; Thank you, this seems to go into the right direction, but i need the PyObject pointer for a function like: PyEval_CallObject(); if i use it with the code above: PyEval_CallObject(_pyfunc_ptr, &o); i get this error: cannot convert ?boost::python::api::object*? to ?PyObject*? for argument ?2? _________________________________________________________________ Kostenlose Messenger Emoticons! Hier downloaden! http://messenger.live.de/mein/ From seefeld at sympatico.ca Tue Feb 12 14:27:05 2008 From: seefeld at sympatico.ca (Stefan Seefeld) Date: Tue, 12 Feb 2008 08:27:05 -0500 Subject: [C++-sig] Convert C++ Class to exposed class and back In-Reply-To: References:

<47B194E3.4030204@sympatico.ca> Message-ID: <47B19EA9.8070102@sympatico.ca> Marcus Jannes wrote: > >> What are you trying to do here ? What is 'c' ? There shouldn't be any >> need to use PyObject raw pointers at all. Assuming 'ExpClass' has >> already been exported, the following should Just Work: >> >> ExpClass a = ...; >> bp::object o(a); //<--- now holds a copy of 'a' >> ... >> ExpClass b = bp::extract(o); //<--- attempts to extract an >> // ExpClass from 'o' >> >>> }; > > Thank you, this seems to go into the right direction, but i need the PyObject pointer for a function like: > PyEval_CallObject(); Why ? Have you studied the boost.python documentation at all ? It offers everything you need to call a python object from within C++ code, without having to touch the Python C API. (But to answer your question: python::object has a 'ptr()' member function that returns a raw pointer, if you *really* need it.) HTH, Stefan -- ...ich hab' noch einen Koffer in Berlin... From jannes80 at hotmail.de Tue Feb 12 14:50:08 2008 From: jannes80 at hotmail.de (Marcus Jannes) Date: Tue, 12 Feb 2008 14:50:08 +0100 Subject: [C++-sig] Convert C++ Class to exposed class and back In-Reply-To: <47B19EA9.8070102@sympatico.ca> References:

<47B194E3.4030204@sympatico.ca> <47B19EA9.8070102@sympatico.ca> Message-ID: Thank you, i think this is exactly what i need. Regarding your question why i want to use it in this way: It is because i want to convert Python function objects to C++ function pointers which get passed to a another function and this seems to be the way to do it. The boost.python FAQ (see: http://www.boost.org/libs/python/doc/v2/faq.html ) states that it isnt possible, unless i misunderstood it. So i am trying it in C API. Now i should be able to :-). If there is any better way to do it, i would be happy to know. ---------------------------------------- > Date: Tue, 12 Feb 2008 08:27:05 -0500 > From: seefeld at sympatico.ca > To: c++-sig at python.org > Subject: Re: [C++-sig] Convert C++ Class to exposed class and back > > Marcus Jannes wrote: >> >>> What are you trying to do here ? What is 'c' ? There shouldn't be any >>> need to use PyObject raw pointers at all. Assuming 'ExpClass' has >>> already been exported, the following should Just Work: >>> >>> ExpClass a = ...; >>> bp::object o(a); //<--- now holds a copy of 'a' >>> ... >>> ExpClass b = bp::extract(o); //<--- attempts to extract an >>> // ExpClass from 'o' >>> >>>> }; >> >> Thank you, this seems to go into the right direction, but i need the PyObject pointer for a function like: >> PyEval_CallObject(); > > Why ? Have you studied the boost.python documentation at all ? It offers > everything you need to call a python object from within C++ code, > without having to touch the Python C API. > > (But to answer your question: python::object has a 'ptr()' member > function that returns a raw pointer, if you *really* need it.) > > HTH, > Stefan > > -- > > ...ich hab' noch einen Koffer in Berlin... > _______________________________________________ > C++-sig mailing list > C++-sig at python.org > http://mail.python.org/mailman/listinfo/c++-sig _________________________________________________________________ Kostenlose Messenger Emoticons! Hier downloaden! http://messenger.live.de/mein/ From roman.yakovenko at gmail.com Tue Feb 12 14:52:43 2008 From: roman.yakovenko at gmail.com (Roman Yakovenko) Date: Tue, 12 Feb 2008 15:52:43 +0200 Subject: [C++-sig] Best practices for C++ project preparation In-Reply-To: References: Message-ID: <7465b6170802120552y7ff2d04ewd372b5e8138e0784@mail.gmail.com> On Feb 12, 2008 1:30 PM, Oliver Schweitzer wrote: > Hi, > > I'm using Py++ to Boost.Python-wrap several medium-scale projects/ > libraries. So far I'm having a good time doing this, learning a lot > about advanced C++, Boost and Python in the process. A key to Py++ is > reading the available documentation carefully, there is a lot in it. > Great stuff. Thank you! > My questions: > > Call policies: There is the odd "deeper" problem popping up, but most > of my current work at wrapping classes seems to come from having to > explicitly prescribe Call Policies for several dozen classes. Is there > a way to adapt design/implementation on the C++ to "help" Py++ at > guessing a good call policy? Any coding convetion should be good enough. Ogre project, for example, has a lot of functions which return "pointer" to some object. Almost all of them return reference to existing object. Python-Ogre code for setting call policies: def Set_DefaultCall_Policies( mb ): mem_funs = mb.calldefs () mem_funs.create_with_signature = True #Generated code will not compile on for mem_fun in mem_funs: if mem_fun.call_policies: continue if not mem_fun.call_policies and (declarations.is_reference (mem_fun.return_type) or declarations.is_pointer (mem_fun.return_type) ): mem_fun.call_policies = call_policies.return_value_policy( call_policies.reference_existing_object ) Another idea is to change the source code: * You can add gccxml attributes to the code: http://gccxml.org/HTML/Running.html * You can embed call policies within the code and parse it. Every declaration has location information ( full file name and line number ). Some comment, near the function, could solve the problem. Also be aware of call policies defaults: http://language-binding.net/pyplusplus/documentation/functions/call_policies.html#defaults > Granularity of Wrapper projects: Having several dozen classes to wrap/ > expose, what is your experience with organizing wrapper projects/ > libraries? Close to the source C++ project/namespaces? There is no policy here. Do what ever you think is best. By the way new version of Py++ contains very good support for multi-module development: http://language-binding.net/pyplusplus/documentation/multi_module_development.html > How many Headers/Classes into one Module/Module-Builder? Take a look on this document: http://language-binding.net/pyplusplus/documentation/split_module.html . The new version of Py++ supports 4 different "split module" strategies: * single file * multiple files * fixed set of multiple files * multiple files, where single class code is split to few files I believe you will find "the only one". >Working exclusive or inclusive, i.e. exposing only carefully selected classes/members or > try to expose all and everything? Both :-): exclude everything, and than include declarations from specific namespaces. Thus when you add "implementation details" you will not have to change the script code. > One goal is having not ever to touch the Py++-generated code, just work in Python and the wrappee lib. It should be possible. -- Roman Yakovenko C++ Python language binding http://www.language-binding.net/ From seefeld at sympatico.ca Tue Feb 12 15:07:22 2008 From: seefeld at sympatico.ca (Stefan Seefeld) Date: Tue, 12 Feb 2008 09:07:22 -0500 Subject: [C++-sig] Convert C++ Class to exposed class and back In-Reply-To: References:

<47B194E3.4030204@sympatico.ca> <47B19EA9.8070102@sympatico.ca> Message-ID: <47B1A81A.1060301@sympatico.ca> Marcus Jannes wrote: > Thank you, i think this is exactly what i need. Regarding your question why i want to use it in this way: > It is because i want to convert Python function objects to C++ function pointers which get passed to a another function and this seems to be the way to do it. The boost.python FAQ (see: http://www.boost.org/libs/python/doc/v2/faq.html ) states that it isnt possible, unless i misunderstood it. So i am trying it in C API. Now i should be able to :-). If there is any better way to do it, i would be happy to know. I think you misunderstood. The problem is not with the API, but with the underlying object model: As Dave notes in the FAQ, a (C, C++) function pointer is not an object, and thus has no state to carry around. Unless your function takes not only a function pointer but also some closure argument (which would then carry that state), you are out of luck. In contrast, if you do get to pass a closure argument, you can pass a python (callable) there, and then implement the function whose pointer you pass such that it simply invokes that callable. In either case, the problem is the same, no matter whether you try to solve it with Python's C API or boost.python. HTH, Stefan -- ...ich hab' noch einen Koffer in Berlin... From jannes80 at hotmail.de Tue Feb 12 20:07:36 2008 From: jannes80 at hotmail.de (Marcus Jannes) Date: Tue, 12 Feb 2008 20:07:36 +0100 Subject: [C++-sig] Convert C++ Class to exposed class and back In-Reply-To: <47B1A81A.1060301@sympatico.ca> References:

<47B194E3.4030204@sympatico.ca> <47B19EA9.8070102@sympatico.ca> <47B1A81A.1060301@sympatico.ca> Message-ID: Okay, let me explain in detail then: I got an existing c++ library where there is a class DerivType which i want exposed to python. There is a function i also want exposed void fEval( ddf_FctPtr f, interval, interval&) where the first parameter is a function pointer which is typedef'ed: typedef DerivType (*ddf_FctPtr)(const DerivType&); I want to do this in python (argument and return type should be of class DerivType): def f(x): x_temp = DerivType(x) return x_temp*x_temp fEval(f,interval1,interval2) Now the wrapper should look something like this: PyObject* _pyfunc_ptr = NULL; DerivType _pycall(const DerivType& d){ DerivType c_result; //build Python data from C++ data: bp::object o(d); result = PyEval_CallObject(_pyfunc_ptr, o.ptr()); c_result = bp::extract(result);//http://www.boost.org/libs/python/doc/v2/extract.html return c_result; }; static PyObject *eval(PyObject *self, PyObject *args){ PyObject *ddf_function; if (!PyArg_ParseTuple(args,"O" ,&ddf_function)) { return NULL; } if(!PyCallable_Check(ddf_function)){ PyErr_Format(PyExc_TypeError,"ddf_function is not callable function"); return NULL; } _pyfunc_ptr = ddf_function; //cache new callback interval i1(10); interval i2; //just for testing fEval(_pycall,i1,i2); return Py_BuildValue(""); }; Well, i still couldn't get this to work at runtime yet. I am not sure if it is even possible, but i got an example from a book where there is a similar case using double data instead of a class (DerivType) and it seems like doing the trick. If this can be done with boost.python instead of C API or you got any other comments please let me know. ---------------------------------------- > Date: Tue, 12 Feb 2008 09:07:22 -0500 > From: seefeld at sympatico.ca > To: c++-sig at python.org > Subject: Re: [C++-sig] Convert C++ Class to exposed class and back > > Marcus Jannes wrote: >> Thank you, i think this is exactly what i need. Regarding your question why i want to use it in this way: >> It is because i want to convert Python function objects to C++ function pointers which get passed to a another function and this seems to be the way to do it. The boost.python FAQ (see: http://www.boost.org/libs/python/doc/v2/faq.html ) states that it isnt possible, unless i misunderstood it. So i am trying it in C API. Now i should be able to :-). If there is any better way to do it, i would be happy to know. > > I think you misunderstood. The problem is not with the API, but with the > underlying object model: As Dave notes in the FAQ, a (C, C++) function > pointer is not an object, and thus has no state to carry around. > Unless your function takes not only a function pointer but also some > closure argument (which would then carry that state), you are out of luck. > > In contrast, if you do get to pass a closure argument, you can pass a > python (callable) there, and then implement the function whose pointer > you pass such that it simply invokes that callable. > > In either case, the problem is the same, no matter whether you try to > solve it with Python's C API or boost.python. > > HTH, > Stefan > > -- > > ...ich hab' noch einen Koffer in Berlin... > _______________________________________________ > C++-sig mailing list > C++-sig at python.org > http://mail.python.org/mailman/listinfo/c++-sig _________________________________________________________________ Kostenlose Messenger Emoticons! Hier downloaden! http://messenger.live.de/mein/ From seefeld at sympatico.ca Tue Feb 12 20:44:00 2008 From: seefeld at sympatico.ca (Stefan Seefeld) Date: Tue, 12 Feb 2008 14:44:00 -0500 Subject: [C++-sig] Convert C++ Class to exposed class and back In-Reply-To: References:

Message-ID: <8bdb0d630802261249i436be153qc4266d6ba4b8b11d@mail.gmail.com> Thank you for the prompt answer - that accomplishes exactly what I was trying to do! I haven't had a lot of luck tracking down the hooks to add a manual conversion for 'float *' into the types registry, do you have any reference for that handy? - Tristam On 26/02/2008, Joseph Lisee wrote: > > I don't know how to integrate this into Boost.Python in a clean way, but > here > is a litter terminal example that can help: > > >>> array = (ctypes.c_int * 3)(1,2,3) > >>> addr = ctypes.addressof(array) > >>> arrayPtr = ctypes.cast(addr, ctypes.POINTER((ctypes.c_int))) > >>> array[0] > 1 > >>> arrayPtr[0] > 1 > > So basically if you can get a long value into python representing the > address > of your float array you are good to go. This is done in Python-Ogre by > just > wrapping a manual cast function: > > unsigned long castToAddress(float* ptr) > { > return (unsigned long)ptr; > } > > A more permanent way to do this would be to change your wrapper to execute > this code with Boost.Python's C++ python API interface (not tested): > > bp::object convertFloat(float* ptr) > { > bp::object ctypes = bp::import("ctypes"); > > bp::long addr((unsigned addr)ptr); > bp::object pointerType(ctypes["POINTER"](ctypes["c_float"])); > > return ctypes["cast"](addr, pointerType); > } > > I believe you can do this by specifying a manual to python convert for the > "float*" type. > > Hope that helps, > Joseph Lisee > > _______________________________________________ > C++-sig mailing list > C++-sig at python.org > http://mail.python.org/mailman/listinfo/c++-sig > -------------- next part -------------- An HTML attachment was scrubbed... URL: From jlisee at gmail.com Tue Feb 26 22:09:24 2008 From: jlisee at gmail.com (Joseph Lisee) Date: Tue, 26 Feb 2008 21:09:24 +0000 (UTC) Subject: [C++-sig] Boost Python and ctypes References:

<8bdb0d630802261249i436be153qc4266d6ba4b8b11d@mail.gmail.com> Message-ID: > Thank you for the prompt answer - that accomplishes exactly what I was trying to do! > I haven't had a lot of luck tracking down the hooks to add a manual conversion for 'float *' into the types registry, do you have any reference for that handy? > > - Tristam No problem, I think this is what you are looking for: http://www.boost.org/libs/python/doc/v2/to_python_converter.html -Joseph Lisee From jlisee at gmail.com Tue Feb 26 22:42:24 2008 From: jlisee at gmail.com (Joseph Lisee) Date: Tue, 26 Feb 2008 21:42:24 +0000 (UTC) Subject: [C++-sig] Check number of arguments of a function object ? References:

Message-ID: And responding to my self, So I wanted to get this done for my project and I am sharing the code. This is a functor class with checks the argument count. Its for an event system and it has been tested. The following is public domain: /// ------------------------ EventFunctor.h ----------------------------- /// /** Wraps a called python object, so it can handle events * * Then given python object is checked to make sure its calledable and has * the proper number of arguments on functor creation. */ class EventFunctor { public: EventFunctor(boost::python::object pyObject); void operator()(EventPtr event); /** The callable python object which is called to handle the event */ boost::python::object pyFunction; }; /// ----------------------- EventFunctor.cpp ---------------------------- /// #include #include "EventFunctor.h" namespace bp = boost::python; EventFunctor::EventFunctor(bp::object pyObject) : pyFunction(pyObject) { bool bad = false; // Check to make sure its a callable object if (0 == PyObject_HasAttrString(pyObject.ptr(), "__call__")) { // If not, lets throw an exception to warn the user PyErr_SetString(PyExc_TypeError, "Handler must be a callable object"); bad = true; } else { int expectedArgs = 1; // Handle function objects vs. functions // * Free python functions have a 'func_code' attributes // * For python function objects, their __call__ method has func_code bp::object func_code; if (0 == PyObject_HasAttrString(pyObject.ptr(), "func_code")) { // Function object, need to increment count for 'self' expectedArgs += 1; func_code = pyObject.attr("__call__").attr("func_code"); } else { func_code = pyObject.attr("func_code"); // Handle instancemethod type callable if (0 != PyObject_HasAttrString(pyObject.ptr(), "im_self")) expectedArgs += 1; } int argCount = bp::extract(func_code.attr("co_argcount")); // 0x4 in the flags means we have a function signature with *args int flags = bp::extract(func_code.attr("co_flags")); // To many arguments if (argCount > expectedArgs) { PyErr_SetString(PyExc_TypeError, "Handler has to many args, expected 1"); bad = true; } // To few arguments and no "*args" in signature else if ((argCount < expectedArgs) && !(flags & 4)) { PyErr_SetString(PyExc_TypeError, "Handler has too few args, expected 1"); bad = true; } } if (bad) bp::throw_error_already_set(); } void EventFunctor::operator()(EventPtr event) { pyFunction(event); } -Joseph Lisee From swiftcoder at gmail.com Tue Feb 26 23:05:05 2008 From: swiftcoder at gmail.com (Tristam MacDonald) Date: Tue, 26 Feb 2008 17:05:05 -0500 Subject: [C++-sig] Boost Python and ctypes In-Reply-To: References:

<8bdb0d630802261249i436be153qc4266d6ba4b8b11d@mail.gmail.com> Message-ID: <8bdb0d630802261405r25137512o5e0c6c0caa6f723d@mail.gmail.com> Now we are into the dizzying world of template error messages :) So I have a class Matrix, which exposes a pointer to float, and a conversion operator to POINTER(c_float): struct Matrix { int test(); float *ptr(); }; struct ctypes_float_ptr { static PyObject *convert(float *ptr) { object ctypes = import("ctypes"); long_ addr((unsigned)ptr); object pointerType(ctypes["POINTER"](ctypes["c_float"])); return ctypes["cast"](addr, pointerType).ptr(); } }; BOOST_PYTHON_MODULE(math) { to_python_converter(); class_("Matrix") .def("test", &Matrix::test) // this compiles fine .def("ptr", &Matrix::ptr) // error here ; } And the error is as follows: src/math.cpp:146: error: no matching function for call to 'boost::python::class_::def(const char [4], )' Any pointers on where to go from here? On 26/02/2008, Joseph Lisee wrote: > > > Thank you for the prompt answer - that accomplishes exactly what I was > trying > to do! > > I haven't had a lot of luck tracking down the hooks to add a manual > conversion > for 'float *' into the types registry, do you have any reference for that > handy? > > > > - Tristam > > > No problem, I think this is what you are looking for: > http://www.boost.org/libs/python/doc/v2/to_python_converter.html > > > -Joseph Lisee > > > _______________________________________________ > C++-sig mailing list > C++-sig at python.org > http://mail.python.org/mailman/listinfo/c++-sig > -------------- next part -------------- An HTML attachment was scrubbed... URL: From jlisee at gmail.com Wed Feb 27 23:22:51 2008 From: jlisee at gmail.com (Joseph Lisee) Date: Wed, 27 Feb 2008 22:22:51 +0000 (UTC) Subject: [C++-sig] bosst.python Event object wrapped with bp::object() References: Message-ID: Alexander Eisenhuth stacom-software.de> writes: > ThreadClass::threadLoop() > { > ... > if (methodeCalled) { > ... > this->myEvent.attr("set")(); > } > > } You can't do this. The Python C API (and therefore Boost.Python's) is not thread safe. If threadloop is running in another thread along side the one the Python interpreter is running in, accessing a Python object at the same time will result in a crash. You should wrap a C++ class, which has a set member that can be accessed from Python. That way in C++ you can do: "this->myEvent.set();" Then later in python you can access the value. -Joe From walter at mathematik.hu-berlin.de Thu Feb 28 13:26:24 2008 From: walter at mathematik.hu-berlin.de (Sebastian Walter) Date: Thu, 28 Feb 2008 13:26:24 +0100 Subject: [C++-sig] boost.python: when does python call c++ destructors? Message-ID: <200802281326.24585.walter@mathematik.hu-berlin.de> Hello, I have compiled a python module with boost.python that exposes the functionality of a c++ class that has a constructor and destructor and an overloaded operator*. The complete c++ code and wrapper can be found at the bottom of this email: But at first the python script that gives me headaches: /* test.py */ /*-----------*/ #!/usr/bin/env python import myclass a = myclass.asdf() b = myclass.asdf() c = a * b d = a * c /* output of test.py */ /*-----------------------*/ wronski(walter):~/workspace/code_tests/boost_python> ./test.py called constructor with loc: 0 called constructor with loc: 1 called operator* with locs: (0,1) called constructor with loc: 2 called destructor with loc: 2 ?!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! called operator* with locs: (0,2) called constructor with loc: 2 called destructor with loc: 2 called destructor with loc: 0 called destructor with loc: 2 called destructor with loc: 1 called destructor with loc: 2 The problem that I don't understand: a*b calls the constructor of a temporary object that is assigned loc=2 and then directly after that the destructor is called! ...? I expected the new temporary object to get assigned to the name c! What bugs me even more is that there are 4 constructor calls but 6!! destructor calls! How can this happen? Is there something im overlooking? Is this intended behavior of Python/Boost.Python ? How could I avoid it? thanks in advance, Sebastian Walter The corresponding boost.python wrapper and c++ code: /* mainclass.hpp */ /*----------------------*/ #ifndef MAINCLASS_HPP #define MAINCLASS_HPP #include #include using namespace std; class asdf{ public: int loc; asdf(); ~asdf(); friend const asdf operator*(const asdf &lhs, const asdf &rhs); }; #endif /* mainclass.cpp */ /*----------------------*/ #include "mainclass.hpp" int global_int=0; asdf::asdf(){ loc = global_int; cout<<"called constructor with loc:\t"<("asdf") .def(self * self) ; } From e.tadeu at gmail.com Thu Feb 28 20:45:32 2008 From: e.tadeu at gmail.com (Edson Tadeu) Date: Thu, 28 Feb 2008 16:45:32 -0300 Subject: [C++-sig] Bug and patch for boost.python with enable_shared_from_this In-Reply-To: <502180.14222.qm@web31102.mail.mud.yahoo.com> References: <502180.14222.qm@web31102.mail.mud.yahoo.com> Message-ID: Any news on this issue? Will this patch get into Boost 1.35? Thanks, Edson On Wed, Feb 13, 2008 at 5:27 PM, Ralf W. Grosse-Kunstleve wrote: > Hi Chad, > > Could you at least ask Peter Dimov if he thinks the > dont_enable_shared_from_this patch could be generally useful? > Maybe he's OK adding it, then it wouldn't be a big deal > fixing Boost.Python, which would probably prevent a lot of > confusion and lost time in the future. > > http://www.boost.org/people/peter_dimov.htm > p-d-i-m-o-v-at-m-m-l-t-d-dot-n-e-t > > Ralf > > ----- Original Message ---- > From: Chad Austin > To: Development of Python/C++ integration > Sent: Monday, February 11, 2008 10:10:31 PM > Subject: Re: [C++-sig] Bug and patch for boost.python with > enable_shared_from_this > > There probably is a way to prevent boost.python from creating > shared_ptrs with a null deleter like it does, but it would require far > more knowledge than I have. :) > > I agree that it would be a better fix, though. > > On 2/11/08, Ralf W. Grosse-Kunstleve wrote: > > > > > > > > Thanks for the patch! I'd love to check this in for you, but for the > > change in shared_ptr.hpp you'll need Peter Dimov's approval, and the > > shared_ptr documentation would have to be updated. Also, your reproducer > > should be turned into a unit test (in boost/libs/python/test). > > > > Is there any chance that the shared_ptr patch could somehow be avoided? > > > > Ralf > > > > > > > > ----- Original Message ---- > > From: Chad Austin > > To: c++-sig at python.org > > Sent: Sunday, February 10, 2008 5:14:45 PM > > Subject: [C++-sig] Bug and patch for boost.python with > enable_shared_from_this > > > > Hi all, > > > > A month ago or so we discovered a bug in Boost.Python that manifests > when using enable_shared_from_this. Here is a test case that demonstrates > the bug: > > > > ... > -------------- next part -------------- An HTML attachment was scrubbed... URL: From rwgk at yahoo.com Thu Feb 28 22:20:02 2008 From: rwgk at yahoo.com (Ralf W. Grosse-Kunstleve) Date: Thu, 28 Feb 2008 13:20:02 -0800 (PST) Subject: [C++-sig] Bug and patch for boost.python with enable_shared_from_this Message-ID: <229148.259.qm@web31108.mail.mud.yahoo.com> No news that I'm aware of. I'd be happy to check in patches, but someone else has to take the lead in communicating with Peter, and updating the unit tests. Ralf ----- Original Message ---- From: Edson Tadeu To: Development of Python/C++ integration Sent: Thursday, February 28, 2008 11:45:32 AM Subject: Re: [C++-sig] Bug and patch for boost.python with enable_shared_from_this Any news on this issue? Will this patch get into Boost 1.35? Thanks, Edson On Wed, Feb 13, 2008 at 5:27 PM, Ralf W. Grosse-Kunstleve wrote: Hi Chad, Could you at least ask Peter Dimov if he thinks the dont_enable_shared_from_this patch could be generally useful? Maybe he's OK adding it, then it wouldn't be a big deal fixing Boost.Python, which would probably prevent a lot of confusion and lost time in the future. http://www.boost.org/people/peter_dimov.htm p-d-i-m-o-v-at-m-m-l-t-d-dot-n-e-t Ralf ----- Original Message ---- From: Chad Austin To: Development of Python/C++ integration Sent: Monday, February 11, 2008 10:10:31 PM Subject: Re: [C++-sig] Bug and patch for boost.python with enable_shared_from_this There probably is a way to prevent boost.python from creating shared_ptrs with a null deleter like it does, but it would require far more knowledge than I have. :) I agree that it would be a better fix, though. On 2/11/08, Ralf W. Grosse-Kunstleve wrote: > > > > Thanks for the patch! I'd love to check this in for you, but for the > change in shared_ptr.hpp you'll need Peter Dimov's approval, and the > shared_ptr documentation would have to be updated. Also, your reproducer > should be turned into a unit test (in boost/libs/python/test). > > Is there any chance that the shared_ptr patch could somehow be avoided? > > Ralf > > > > ----- Original Message ---- > From: Chad Austin > To: c++-sig at python.org > Sent: Sunday, February 10, 2008 5:14:45 PM > Subject: [C++-sig] Bug and patch for boost.python with enable_shared_from_this > > Hi all, > > A month ago or so we discovered a bug in Boost.Python that manifests when using enable_shared_from_this. Here is a test case that demonstrates the bug: > > ... -----Inline Attachment Follows----- _______________________________________________ C++-sig mailing list C++-sig at python.org http://mail.python.org/mailman/listinfo/c++-sig -------------- next part -------------- An HTML attachment was scrubbed... URL: From j.reid at mail.cryst.bbk.ac.uk Fri Feb 29 14:43:41 2008 From: j.reid at mail.cryst.bbk.ac.uk (John Reid) Date: Fri, 29 Feb 2008 13:43:41 +0000 Subject: [C++-sig] Raoul Gough's container suite with svn boost-trunkboost.python? In-Reply-To: <470E72FE.48A19C6D@sitius.com> References: <470E72FE.48A19C6D@sitius.com> Message-ID: Nikolay Mladenov wrote: > I found it, > > the postcall_override template needs to have the following line > > typedef typename Policy::extract_return_type extract_return_type; > Do you mean I should insert that line as follows? namespace detail { template struct postcall_override { // This class overrides the Policy's postcall function and // result_conveter to handle the list returned from get_slice. // The Policy's result_converter is removed, since it gets // applied within get_slice. Our postcall override applies the // original postcall to each element of the Python list returned // from get_slice. typedef typename Policy::extract_return_type extract_return_type; typedef boost::python::default_result_converter result_converter; typedef typename Policy::argument_package argument_package; postcall_override (Policy const &p); bool precall (PyObject *args); PyObject* postcall (PyObject *args, PyObject *result); private: Policy m_base; }; } In my version of boost/python/suite/indexing/slice_handler.hpp this is inserted on line 63. If I do this I get the following error: /alma/home/john/software/boost/boost-trunk/boost/python/suite/indexing/slice_handler.hpp:63: error: 'typename boost::python::return_value_policy::extract_return_type' names 'template struct boost::python::default_call_policies::extract_return_type', which is not a type Any help appreciated, John. From walter at mathematik.hu-berlin.de Fri Feb 29 15:11:08 2008 From: walter at mathematik.hu-berlin.de (Sebastian Walter) Date: Fri, 29 Feb 2008 15:11:08 +0100 Subject: [C++-sig] boost.python: when does python call c++ destructors? In-Reply-To: <200802281326.24585.walter@mathematik.hu-berlin.de> References: <200802281326.24585.walter@mathematik.hu-berlin.de> Message-ID: <200802291511.08404.walter@mathematik.hu-berlin.de> Ok, I figured out what I have been missing. Actually it are two things 1) C++ automatically defines a standard copy constructor when it is not manually defined. 2)In Python the expression "c = a*b" first computes a*b where a temporary object tmp is created. But instead of using this tmp object and give it the name c, Python does the following: The copy constructor with tmp as argument is called and this new copy is "given the name" c. So, since the standard copy constructor does not increase global_int nor does it cout the "called constructor" string, this led to the unexpected behavior that I couldn't explain. If I add and wrap the copy constructor: asdf::asdf(const asdf& a) { loc = global_int; cout << "called copy constructor with loc:\t" << loc << endl; global_int++; } i get the correct result. wronski(walter):~/workspace/code_tests/boost_python> ./test.py called constructor with loc: 0 called constructor with loc: 1 called operator* with locs: (0,1) called constructor with loc: 2 called copy constructor with loc: 3 called destructor with loc: 2 called operator* with locs: (0,3) called constructor with loc: 3 called copy constructor with loc: 4 called destructor with loc: 3 end called destructor with loc: 0 called destructor with loc: 3 called destructor with loc: 1 called destructor with loc: 4 On Thursday, 28. February 2008 13:26:24 Sebastian Walter wrote: > Hello, > I have compiled a python module with boost.python that exposes the > functionality of a c++ class that has a constructor and destructor and an > overloaded operator*. The complete c++ code and wrapper can be found at the > bottom of this email: > > But at first the python script that gives me headaches: > > /* test.py */ > /*-----------*/ > #!/usr/bin/env python > import myclass > > a = myclass.asdf() > b = myclass.asdf() > > c = a * b > d = a * c > > /* output of test.py */ > /*-----------------------*/ > wronski(walter):~/workspace/code_tests/boost_python> ./test.py > called constructor with loc: 0 > called constructor with loc: 1 > called operator* with locs: (0,1) > called constructor with loc: 2 > called destructor with loc: 2 ?!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! > called operator* with locs: (0,2) > called constructor with loc: 2 > called destructor with loc: 2 > called destructor with loc: 0 > called destructor with loc: 2 > called destructor with loc: 1 > called destructor with loc: 2 > > The problem that I don't understand: > a*b calls the constructor of a temporary object that is assigned loc=2 > and then directly after that the destructor is called! ...? > I expected the new temporary object to get assigned to the name c! > > What bugs me even more is that there are 4 constructor calls but 6!! > destructor calls! How can this happen? > > Is there something im overlooking? Is this intended behavior of > Python/Boost.Python ? > How could I avoid it? > > > thanks in advance, > > Sebastian Walter > > > > > The corresponding boost.python wrapper and c++ code: > > /* mainclass.hpp */ > /*----------------------*/ > #ifndef MAINCLASS_HPP > #define MAINCLASS_HPP > > #include > #include > using namespace std; > > class asdf{ > public: > int loc; > asdf(); > ~asdf(); > friend const asdf operator*(const asdf &lhs, const asdf &rhs); > }; > #endif > > /* mainclass.cpp */ > /*----------------------*/ > #include "mainclass.hpp" > > int global_int=0; > > asdf::asdf(){ > loc = global_int; > cout<<"called constructor with loc:\t"< global_int++; > } > > asdf::~asdf(){ > cout<<"called destructor with loc:\t"< global_int--; > } > > const asdf operator*(const asdf &lhs, const asdf &rhs){ > cout<<"called operator* with > locs:\t"<<"("< } > > > /* wrapper.cpp */ > /*------------------*/ > #include "boost/python.hpp" > #include "mainclass.hpp" > > BOOST_PYTHON_MODULE(myclass) > { > using namespace boost::python; > class_("asdf") > .def(self * self) > ; > } > > > > > > > _______________________________________________ > C++-sig mailing list > C++-sig at python.org > http://mail.python.org/mailman/listinfo/c++-sig From seefeld at sympatico.ca Fri Feb 29 15:16:48 2008 From: seefeld at sympatico.ca (Stefan Seefeld) Date: Fri, 29 Feb 2008 09:16:48 -0500 Subject: [C++-sig] boost.python: when does python call c++ destructors? In-Reply-To: <200802291511.08404.walter@mathematik.hu-berlin.de> References: <200802281326.24585.walter@mathematik.hu-berlin.de> <200802291511.08404.walter@mathematik.hu-berlin.de> Message-ID: <47C813D0.3070103@sympatico.ca> Sebastian Walter wrote: > Ok, I figured out what I have been missing. Actually it are two things > > 1) C++ automatically defines a standard copy constructor when it is not > manually defined. Right. > 2)In Python the expression "c = a*b" first computes a*b where a temporary > object tmp is created. But instead of using this tmp object and give it the > name c, Python does the following: > The copy constructor with tmp as argument is called and this new copy > is "given the name" c. This is not quite accurate. Python doesn't know about temporaries and copy-construction, as it always uses references. It is your own definition of operator* that requires the temporary. Regards, Stefan -- ...ich hab' noch einen Koffer in Berlin...