Mailman 3 June 2006 - Cplusplus-sig

C++ singleton
by Emmanuel Taurel Oct. 31, 2007

Oct. 31, 2007

Hello everybody, I am actually writing an interface to python for an existing C++ library using Boost. This library has a C++ singleton class. This class has only one constructor (with arguments) which is "protected" because it's a singleton. I am not able to build a Boost interface to this class because the compiler complains that the constructor I have given to Boost in the class_xxx constructor argument is not public (which is true) ! Therefore, my question is simple : How is it possible to interface such a class with only one constructor which is protected and a static method to create/access the object ? Thank's very much for your answer. Sincerely Emmanuel Taurel (etaurel(a)cells.es) PS : By the way, is there a searchable archive of this mailing list ?

4 3

Exposing c++ classes with static arrays using Boost.Python and py++
by Abhi Oct. 3, 2006

Oct. 3, 2006

While running py++ on a class with a static array inside it, py++ generates Boost.Python bindings using a derived class for the original C++ class. Let me illustrate with the help of the following example: class AttributesTest { public: int staticIntArray[10]; }; Notice this class has an array inside it Running py++ generates the following code, with a wrapper class that derives from the AttributesTest class. struct AttributesTest_wrapper : AttributesTest, bp::wrapper< AttributesTest > { AttributesTest_wrapper(AttributesTest const & arg ) : AttributesTest( arg ) , bp::wrapper< AttributesTest >() {} AttributesTest_wrapper( ) : AttributesTest( ) , bp::wrapper< AttributesTest >() {} pyplusplus::containers::static_sized::array_1_t< int, 10 > pyplusplus_staticIntArray_wrapper(){ return pyplusplus::containers::static_sized::array_1_t< int, 10 >( staticIntArray ); } }; and BOOST_PYTHON_MODULE(PYPP_YodaPacketCommon){ if( true ){ typedef bp::class_< AttributesTest_wrapper > AttributesTest_exposer_t; AttributesTest_exposer_t AttributesTest_exposer = AttributesTest_exposer_t( "AttributesTest" ); bp::scope AttributesTest_scope( AttributesTest_exposer ); AttributesTest_exposer.def( bp::init< >()[bp::default_call_policies()] ); pyplusplus::containers::static_sized::register_array_1< int, 10, bp::default_call_policies >( "__array_1_int_10" ); AttributesTest_exposer.add_property( "staticIntArray" , bp::make_function( (pyplusplus::containers::static_sized::array_1_t< int, 10 > ( AttributesTest_wrapper::* )( ) )(&AttributesTest_wrapper::pyplusplus_staticIntArray_wrapper) , bp::with_custodian_and_ward_postcall< 0, 1, bp::default_call_policies >() ) );; Note that it maps the python name "AttributesTest" to the derived class AttributesTest_wrapper. Why not just keep it simple and rather than creating a derived class just map the variable "staticIntArray" via a global method, such as: .add_property( "staticIntArray" , bp::make_function( (&::someglobal_staticIntArray_wrapper) , bp::with_custodian_and_ward_postcall< 0, 1, bp::default_call_policies >() ) );; and define the someglobal_staticIntArray_wrapper method as: pyplusplus::containers::static_sized::array_1_t< int, 10 > someglobal_staticIntArray_wrapper(){ return pyplusplus::containers::static_sized::array_1_t< int, 10 >( staticIntArray ); } Is there any drawback with just mapping the array variable to a global method rather than mapping the whole class. thanks - Abhi

3 5

Working with python unicode strings without wstring
by Rod Cloutier Aug. 6, 2006

Aug. 6, 2006

Hi, I am trying to wrap an external library that uses "const wchar_t *" a arguments for several methods. I know that if they would have used std::wstring the conversion would have been straight forward. Is there anyway to convert python unicode string to wchar_t pointers ? Can I make the following code work without writting a wrapper function that uses a wstring as an argument ? in C++: void printText( const wchar_t* str ) { std::wcout << str; } in python: MyModule.printText( u"The message" ) Thanks Rodrigue Cloutier

3 6

Protected destructor compile error
by Allen Bierbaum July 28, 2006

July 28, 2006

I have run into a compiler error with boost.python and I would like to understand what is causing it so I can try to fix the problem. This is coming up in several places in the binding I am working on, so I am hopeful if I can understand what is happening with one case I can fix it everywhere. Background: I am wrapping a class, Camera, the method that is causing problems is: bool Camera::calcViewRay (Line &line, Int32 x, Int32 y, const Viewport &port); I am wrapping it (using pyplusplus) with this def: Camera_exposer.def("calcViewRay" , &::osg::Camera::calcViewRay , ( bp::arg("line"), bp::arg("x"), bp::arg("y"), bp::arg("port") ) , bp::default_call_policies() ); I get this error when building with boost 1.33.1 on fedora core 4 (gcc 4.0.2): /home/allenb/Source/boost/installed/include/boost-1_33_1/boost/python/detail/destroy.hpp: In static member function 'static void boost::python::detail::value_destroyer<false>::execute(const volatile T*) [with T = osg::Viewport]': /home/allenb/Source/boost/installed/include/boost-1_33_1/boost/python/detail/destroy.hpp:90: instantiated from 'void boost::python::detail::destroy_referent_impl(void*, T& (*)()) [with T = const osg::Viewport]' /home/allenb/Source/boost/installed/include/boost-1_33_1/boost/python/detail/destroy.hpp:101: instantiated from 'void boost::python::detail::destroy_referent(void*, T (*)()) [with T = const osg::Viewport&]' /home/allenb/Source/boost/installed/include/boost-1_33_1/boost/python/converter/rvalue_from_python_data.hpp:135: instantiated from 'boost::python::converter::rvalue_from_python_data<T>::~rvalue_from_python_data() [with T = const osg::Viewport&]' /home/allenb/Source/boost/installed/include/boost-1_33_1/boost/python/converter/arg_from_python.hpp:108: instantiated from 'PyObject* boost::python::detail::caller_arity<5u>::impl<F, Policies, Sig>::operator()(PyObject*, PyObject*) [with F = bool (osg::Camera::*)(osg::Line&, osg::Int32, osg::Int32, const osg::Viewport&), Policies = boost::python::default_call_policies, Sig = boost::mpl::vector6<bool, osg::Camera&, osg::Line&, int, int, const osg::Viewport&>]' /home/allenb/Source/boost/installed/include/boost-1_33_1/boost/python/object/py_function.hpp:38: instantiated from 'PyObject* boost::python::objects::caller_py_function_impl<Caller>::operator()(PyObject*, PyObject*) [with Caller = boost::python::detail::caller<bool (osg::Camera::*)(osg::Line&, osg::Int32, osg::Int32, const osg::Viewport&), boost::python::default_call_policies, boost::mpl::vector6<bool, osg::Camera&, osg::Line&, int, int, const osg::Viewport&> >]' src/osg_module2/Camera.pypp.cpp:459: instantiated from here /home/allenb/Source/OpenSG/Builds/i686-pc-linux-gnu-g++/include/OpenSG/OSGViewport.h:126: error: 'virtual osg::Viewport::~Viewport()' is protected /home/allenb/Source/boost/installed/include/boost-1_33_1/boost/python/detail/destroy.hpp:33: error: within this context It looks like there is a problem with the "const Viewport& port" argument being passed. For some reason the generated code seems to want to be able to destroy instances of the Viewport class. This class has protected constructor and destructor as it is reference counted and the user can only create them using a helper function (Camera::create()). Can anyone describe what is happening here and what prerequisites exist for this call to work? Is there some call policy that I should be using to make this work? Thanks, Allen

5 12

extending a c++ object by overriding it's virtual functions..
by Kleistereimer July 6, 2006

July 6, 2006

hi! i've a question about virtual functions and boost::python. i use it with a boost c++ extended python which is embeeded in c++. i have a virtual function that's going to be overridden in Python and called polymorphically from C++. (so i'm not wrapping c++ for use from python) for instance i want to allow users of my software to override the virtual void Login::OnLog(std::string) function using python. that's what 'wrapper' and 'get_override' is used for, right? if i would use it in python only, overriding works without these stuff too. so i duplicated the example at http://www.boost.org/libs/python/doc/tutorial/doc/html/python/exposing.html… and it works fine inside python as advertised: >>> base.f() 0 >>> derived.f() 42 but for this i wont need 'wrapper' and 'get_override'. This works for any boost c++ extension. now for the interesting stuff: (ak the problem) after running the script i do: Base *b = new BaseWrap; int result = b->f(); delete b; now i would expect the result to be 42, but i got 0. ==================================================== so how to put 'wrapper' and 'get_override' to any use? my sollution is to obtain the PyObject* of 'derived' and to force it manualy into m_ptr of 'wrapper' using 'detail::initialize_wrapper' then 'get_override' worked as expected and i got 42. so i need to hardcode the name of the instantiated class ('derived') into the BaseWrap class to be able to initialize the wrapper with it if someone instantiated a c++ object and used f()... that's ugly but my understanding of 'virtual function that's going to be overridden in Python' is: write a c++ class and a corresponding derived class in python, and then use one or more instantiations of the c++ class without creating and maintaining python instances etc. or did i understood something completely wrong? regards kl

3 3

boost::python std::vector< std::string > crash
by John Reid July 4, 2006

July 4, 2006

Hi, I'm using boost/python/suite/indexing/vector_indexing_suite.hpp from the cvs_head version of boost python on MSVC 8. I'm getting a runtime assertion failure when appending to a vector of strings. I define a module with a vector of strings with the following code: #include <boost/python.hpp> #include <boost/python/suite/indexing/vector_indexing_suite.hpp> #include <vector> using namespace boost; using namespace boost::python; using namespace std; typedef vector< string > string_vec; BOOST_PYTHON_MODULE( _bptest ) { /** A vector of strings. */ class_< string_vec >( "StringVec" ) .def( vector_indexing_suite< string_vec >() ) ; } I use this python code: import sys print 'Importing bptest' _path_to_module = '../bin/Bio/Biopsy/_bptest.pyd/vc-8_0/debug/threading-multi' sys.path.append( _path_to_module ) import _bptest print 'Creating string vec' strings = _bptest.StringVec() print 'Appending string' strings.append( 'a' ) and it crashes in "strings.append( 'a' )" There seems to be very little in the documenation about how std::strings are handled. They seem to work fine when used outside containers. Also containers of user-defined classes (as in the vector indexing example, struct X) and containers of doubles, ints, etc.. seem to work fine. What am I missing here? Eventually I want to use a C++ method that accepts a const std::vector< std::string > & as an argument. The FAQ it suggests there are two methods to do this: vector_indexing and also using custom rvalue converters. Unfortunately this documentation seems rather out of date. The instructions to log in to cvs to see the example code don't appear to work. I did manage to find the code but it is not clear how it could help me. Any help would be much appreciated. Thanks, John. P.S. here is the stack trace: > _biopsy.pyd!boost::python::detail::value_destroyer<0>::execute<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >(const std::basic_string<char,std::char_traits<char>,std::allocator<char> > * p="") Line 34 C++ _biopsy.pyd!boost::python::detail::destroy_referent_impl<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const >(void * p=0x0021fbc8, const std::basic_string<char,std::char_traits<char>,std::allocator<char> > & (void)* __formal=0x00000000) Line 95 + 0x9 bytes C++ _biopsy.pyd!boost::python::detail::destroy_referent<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &>(void * p=0x0021fbc8, const std::basic_string<char,std::char_traits<char>,std::allocator<char> > & (void)* __formal=0x00000000) Line 101 + 0xb bytes C++ _biopsy.pyd!boost::python::converter::rvalue_from_python_data<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &>::~rvalue_from_python_data<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &>() Line 135 + 0xe bytes C++ _biopsy.pyd!boost::python::converter::arg_rvalue_from_python<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &>::~arg_rvalue_from_python<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &>() + 0xf bytes C++ _biopsy.pyd!boost::python::arg_from_python<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &>::~arg_from_python<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &>() + 0xf bytes C++ _biopsy.pyd!boost::python::detail::caller_arity<2>::impl<void (__cdecl*)(std::vector<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > &,std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &),boost::python::default_call_policies,boost::mpl::vector3<void,std::vector<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > &,std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &> >::operator()(_object * args_=0x009d58a0, _object * __formal=0x00000000) Line 201 + 0x2a bytes C++ _biopsy.pyd!boost::python::objects::caller_py_function_impl<boost::python::detail::caller<void (__cdecl*)(std::vector<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > &,std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &),boost::python::default_call_policies,boost::mpl::vector3<void,std::vector<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > &,std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &> > >::operator()(_object * args=0x009d58a0, _object * kw=0x00000000) Line 39 C++

3 5

Another project using boost.python
by Austin Bingham June 29, 2006

June 29, 2006

The boost.python website asks for submissions of projects using boost.python, so here's another one. pyxiph (http://sourceforge.net/projects/pyxiph) is a set of bindings to several of the xiph.org libraries (currently ao, ogg, and vorbis). Compared to python extensions I've written in the past using the standard C API, this was a breeze! I find the boost.python approach easier to reason with, easier to modify, much easier to get correct, and easier to explain. Count me as one happy customer. -- Austin Bingham "If I were creating the world I wouldn't mess about with butterflies and daffodils. I would have started with lasers, eight o'clock, Day One!" Evil

1 0

Re: [C++-sig] extending a c++ object by overriding it's virtual functions..
by Kleistereimer June 28, 2006

June 28, 2006

hi dave, thankyou for your explanations and sourcecode. i have some more questions about it thought. first here is the sourcecode again: //Python >>> class Derived(Base): ... def f(self): ... return 42 >>> base = Base() >>> derived = Derived() >>> base.f() 0 >>> derived.f() 42 //C++ code from your answer >1: // substitute the module name where "derived" is defined for "__main__" >2: python::object module = python::import("__main__"); >3: python::object derived = module.attr("derived"); >4: python::object b = derived( /* arguments to __init__ here */ ); >5: int result = b.f(); 1) the mentioned include file <boost/python/import.hpp> is not in boost 1.33.1. where can i get it? is it in cvs? does it suffice if i get this .hpp file only, or do i need the complete cvs version? for now i used the c api.. instead of this line. 2) what does the above code exactly? i think it instantiates a python 'Derived' class to object 'derived', so line 3 has to be: 3 python::object derived = module.attr("Derived"); //capital 'D' and at line 5 'f' is called on this instance. this gives me a compiler error: "f is no element of ..::api::object". how to solve this? i guess it involves something like: python::call_method<int>(b.ptr(),"f") but this fails in arg_to_python.hpp:181 "cannot_convert_raw_PyObject<T*>::to_python_use_handle_instead();" how to do it corectly? 3) so this scheme is not 'overwriting c++ virtual functions with python code' directly, instead it's 'deriving a python class from a c++ class, overwriting virtual functions, and then making an instance of this python class and access it from c++' right? this means if i have some heavily used c++ class which needs only some minor functions tweakable from python, i should better do it like so: class py_MyClass: def Log(self): ... class MyClass { MyClass() {m_PyObject = Instantiate("py_MyClass");} //using line 3 and 4 ~MyClass() {delete m_PyObject;} ... ... void Log(std::string) {python::call_method<void>(m_PyObject, "Log"); } }; because this calls into python only if one of the 'pythonized' functions is needed (which is seldom) but not if other c++ functions are used (which is extremely often) did i understood it right? regards kl

2 1

[pyplusplus] Which version of gccxml should I use?
by Markus Schöpflin June 27, 2006

June 27, 2006

Hello, I am wondering which version of gccxml is recommended for use with pyplusplus? Use of gccxml-0.6.0 is discouraged by the gccxml homepage, so are there any known-to-be-good CVS snapshot tar balls available? Thanks, Markus

5 9

boost.python automatic policies
by Damien Gleizes June 26, 2006

June 26, 2006

Hello, I am currently using boost.Python for binding C++ code. In fact, I'am parsing a sort of container wich stores all classes I need to bind, including their methods and members (methods signatures, arguments types). While parsing these classes, I generates CPP files containing the binding code (wich uses boost.Python). The problem I'am confronted to concerns the use of policies. Is there a way to know wich policies to use without knowing what the function exactly do? Without policies the code does not compile, so I wonder if it is possible to know wich policies to use just with the decoration of arguments and return value (types, reference, pointer, const etc). Thanks for your suggestions!

2 2