boost python won't auto-convert char* data members

Question

I'm trying to wrap a C++ api and I'm hitting a roadblock on some char* class members. It seems that boost-python will auto convert char const * and std::string types into python objects (based on this answer), but it balks at char* types. This is the error I get (in python):

TypeError: No to_python (by-value) converter found for C++ type: char*

It turns out that these particular char * members probably should have been declared as char const * since the strings are never altered.

I'm new to boost-python so maybe there is an obvious answer, but I'm not having much luck googling this one.

Is there an easy way to tell boost-python to auto convert these char* members? (Unfortunately I can't change the declarations of char * to char const * since the API I am wrapping is not under my control.)

UPDATE:

Ok so I think that I need to add a custom converter to handle the char* members. I started writing one:

/** to-python convert for char* */
struct c_char_p_to_python_str
{
    static PyObject* convert(char* s) {
        return incref(object(const_cast<const char*>(s)).ptr());
    }
};

// register the QString-to-python converter
to_python_converter<char*, c_char_p_to_python_str>();

Unfortunately this does not work. This is the error:

error: expected unqualified-id
to_python_converter<char*, c_char_p_to_python_str>();
                                                   ^

Looking at the docs I can see that the template args have this signature:

template <class T, class Conversion, bool convertion_has_get_pytype_member=false>

Since char* isn't a class I'm guessing that's why this didn't work. Anyone have some insight?

UPDATE2:

Nope. Turns out to_python_converter needs to get called inside of the BOOST_PYTHON_MODULE call.

I got the to_python_converter working (with some modifications). I also wrote a function to convert form python and registered it with converter::registry::push_back. I can see my to_python code running, but the from_python code never seems to run.

Answer 1

This expands on Dan's answer. I wrote some macro definitions which generate lambda expressions. The benefits of this approach are that it is not tied to a particular type or member name.

In the API I am wrapping, I have a few hundred classes to wrap. This allows me to make a single macro call for every char* class member.

Here is a modified version of Dan's example code:

#include <boost/python.hpp>
namespace bp = boost::python;

#define ADD_PROPERTY(TYPE, ATTR) add_property(#ATTR, SET_CHAR_P(TYPE, ATTR), \
                                              GET_CHAR_P(TYPE, ATTR))

#define SET_CHAR_P(TYPE, ATTR) +[](const TYPE& e){                  \
                                   if (!e.ATTR) return "";          \
                                   return (const char*)e.ATTR;      \
                               }
#define GET_CHAR_P(TYPE, ATTR) +[](TYPE& e, char const* new_text){  \
                                   delete[] e.ATTR;                 \
                                   size_t n(strlen(new_text));      \
                                   e.ATTR = new char[n+1];          \
                                   strncpy(e.ATTR, new_text, n);    \
                                   e.ATTR[n] = '\0';                \
                               }

class example
{
public:
    example()
    {
        text = new char[1];
        text[0] = '\0';
    }

    ~example()
    {
        delete[] text;
    }

public:
    char* text;

};


BOOST_PYTHON_MODULE(topics)
{
    bp::class_<example>("example")
        .ADD_PROPERTY(example, text);
}

Answer 2

Let's assume we're wrapping some third-party API, and set aside the awfulness of having those pointers exposed and mucking with them from the outside.

Here's a short proof of concept:

#include <boost/python.hpp>
namespace bp = boost::python;

class example
{
public:
    example()
    {
        text = new char[1];
        text[0] = '\0';
    }

    ~example()
    {
        delete[] text;
    }

public:
    char* text;

};

char const* get_example_text(example* e)
{
    return e->text;
}

void set_example_text(example* e, char const* new_text)
{
    delete[] e->text;

    size_t n(strlen(new_text));
    e->text = new char[n+1];
    strncpy(e->text, new_text, n);
    e->text[n] = '\0';
}

BOOST_PYTHON_MODULE(so02)
{
    bp::class_<example>("example")
        .add_property("text", &get_example_text, &set_example_text)
        ;
}

Class example owns text, and is responsible for managing the memory.

We provide an external getter and setter function. The getter is simple, it just provides read access to the string. The setter frees the old string, allocates new memory of appropriate size, and copies the data.

Here's a simple test in python interpreter:

>>> import so02
>>> e = so02.example()
>>> e.text
''
>>> e.text = "foobar"
>>> e.text
'foobar'

---

Notes:

• set_example_text() could perhaps take std::string or bp::object so that we have the lenght easily available, and potentially allow assignment from more than just strings.
• If there are many member variables to wrap and the getter/setter pattern is similar, generate the code using templates, or even just few macros.
• There may be a way to do this with the converters, I'll have a look into that tomorrow. However, as we're dealing with memory management here, i'd personally prefer to handle it this way, as it's much more obvious what's happening.