Boost Python 2: Constructors using `std::string &`

Question

I have a legacy code in C++ (which would be a huge pain to edit) and I need to use it in Python 2 for speed reasons.

I have two classes. One is responsible for loading huge amount of data from memory, in a form of std::string and converting it to internal representation MiddleClass. Second one is converting it from internal representation MiddleClass back to std::string.

 class Load {
     Load(const std::string & data) { ... };
     MiddleClass load() { ... };
 };

 class Save {
     Save(std::string & data) { .... };
     void save(const MiddleClass & middleclass) { ... };
 };

My goal is, to use this setup in Python 2 like this:

import datahandler # my lib
import requests

request = request.get("url-to-data")
loader = datahandler.Load(request.content) # my C++ class Load
internal_representation = loader.load()

.
.
.

result_variable = str() # or None or something not important
saver = datahandler.Save(result_variable) # my C++ class Save
saver.save(internal_representation)

How can I achieve this?

I've run into trouble, right from the start.

Simple variant:

BOOST_PYTHON_MODULE(datahandler)
{
     class_<MiddleClass>("MiddleClass");\
     // some .defs - not important

     class <Load>("Load", init<const std::string &>())
         .def("load". &Load::load);

     class <Save>("Save", init<std::string &>())
         .def("save". &Save::save);        
}

Will compile, no worries, but data which are loaded are somehow mangled, which leads me to thinking, that I am doing it terribly wrongly.

Also I found this bit offtopic SO question, which told me, that I can't have std::string &, because Python strings are immutable.

So conclusion: I have no idea what to do now :( Can anyone here help me? Thanks.

mohabouje · Accepted Answer · 2019-04-05 15:32:17Z

0

Take as reference this working example.

Define your C++ classes. For instance:


class MiddleClass {
public:
    explicit MiddleClass(const std::string& data) : parent_data_(data) {}

    void print() {
        std::cout << parent_data_ << std::endl;
    }

private:
    std::string parent_data_;
};

class Loader {
public:
    explicit Loader(const std::string& data) :
        data_(data){

        };

    MiddleClass load() {
        return MiddleClass(data_);
    };

private:
    std::string data_;
};

Create the boost bindings

boost::python::class_<MiddleClass>("MiddleClass",
     boost::python::init<const std::string&>(boost::python::arg("data"), ""))
     .def("print_data", &MiddleClass::print);

boost::python::class_<Loader>("Loader", 
     boost::python::init<const std::string&>(boost::python::arg("data"), ""))
     .def("load", &Loader::load);

Install your library in the right python site-package.
Enjoy it in python:

from my_cool_package import MiddleClass, Loader
example_string = "whatever"
loader = Loader(data=example_string)

# Get the middle class
middle_class = loader.load()

# Print the data in the middle class
middle_class.print_data()

The expected output:

whatever

answered Apr 5, 2019 at 15:32

mohabouje

4,0802 gold badges19 silver badges32 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

tomascapek Over a year ago

This only solves half of my trouble. I still have issues with the Save class. It ends with terrible errors.

tomascapek · Accepted Answer · 2019-04-09 13:59:07Z

So, I have found a solution. Prove me wrong, but I think, that what am I trying to achieve is impossible.

Python has immutable strings, so passing a "reference" of string to function and expecting ability to change it from inside a function is simply not valid.

Take this code as an example:

variable = "Hello"

def changer(var):
    var = "Bye"

changer(variable)

print(variable)

Prints "Hello". In Python, you can't make it work differently. (although to be exact, it is still being passed as a reference, but when you modify Python string, you just create a new one and a new reference).

So, how to get arround this?

Simple! Create a C++ wrapper, that will handle passing reference on std::string and return copy of resulting string. Not very effective, but you probably can't make it better.

Sample code of SaveWrapper class:

class SaveWrapper {
    public:
       // some constructor
       std::string save(MiddleClass & value) {
           std::string result;

           Save saver(result);
           saver.save(value);

           return result;
       }
};

Which can be easily "ported" to Python!

Collectives™ on Stack Overflow

Boost Python 2: Constructors using `std::string &`

2 Answers 2

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related