PythonStdVectorUtils.h

Go to the documentation of this file.

// PythonStdVectorUtils.h:
// -----------------------
//

#ifndef __PYIPSDKBASE_PYTHONSTDVECTORUTILS_H__
#define __PYIPSDKBASE_PYTHONSTDVECTORUTILS_H__

#include <vector>
#include <boost/python/iterator.hpp>
#include <boost/python/self.hpp>
#include <boost/python/operators.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>

namespace ipsdk {
namespace python {


// from http://stackoverflow.com/questions/15842126/feeding-a-python-list-into-a-function-taking-in-a-vector-with-boost-python
template <typename Container>
struct VectorConverter
{
    // @brief Check if PyObject is iterable.
    static void* convertible(PyObject* object)
    {
        return PyObject_GetIter(object) ? object : NULL;
    }

    // @brief Convert iterable PyObject to C++ container type.
    //
    // Container Concept requirements:
    //
    //   * Container::value_type is CopyConstructable.
    //   * Container can be constructed and populated with two iterators.
    //     I.e. Container(begin, end)
    static void construct(
        PyObject* object,
        boost::python::converter::rvalue_from_python_stage1_data* data)
    {
        namespace python = boost::python;
        // Object is a borrowed reference, so create a handle indicting it is
        // borrowed for proper reference counting.
        python::handle<> handle(python::borrowed(object));

        // Obtain a handle to the memory block that the converter has allocated
        // for the C++ type.
        typedef python::converter::rvalue_from_python_storage<Container>
            storage_type;
        void* storage = reinterpret_cast<storage_type*>(data)->storage.bytes;

        typedef python::stl_input_iterator<typename Container::value_type>
            iterator;

        // Allocate the C++ type into the converter's memory block, and assign
        // its handle to the converter's convertible variable.  The C++
        // container is populated by passing the begin and end iterators of
        // the python object to the container's constructor.
        new (storage)Container(
            iterator(python::object(handle)), // begin
            iterator());                      // end
        data->convertible = storage;
    }

    // create string associated to object
    static std::string to_string(const Container& cl)
    {
        std::stringstream ss;
        ss << "[";
        bool first = true;
        for (typename Container::const_iterator
            i = cl.begin(), e = cl.end(); i != e; ++i) {
            if (first) {
                first = false;
            }
            else {
                ss << ", ";
            }
            ss << (*i);
        }
        ss << "]";
        return ss.str();
    }
};

// export vector
template<class Container> void
export_vector_no_proxy(const char* py_name)
{
    boost::python::type_info info = boost::python::type_id<Container>(); 
    const boost::python::converter::registration* reg = boost::python::converter::registry::query(info);
    if (reg == 0 || reg->m_to_python == 0) {

        boost::python::class_<Container>(py_name)
            .def(boost::python::vector_indexing_suite<Container, true>())
            .def("__str__", &VectorConverter<Container>::to_string);
        boost::python::converter::registry::push_back(
            &VectorConverter<Container>::convertible,
            &VectorConverter<Container>::construct,
            boost::python::type_id<Container>());
    }
}

// export vector
template<class Container> void
export_vector(const char* py_name)
{
    boost::python::type_info info = boost::python::type_id<Container>(); 
    const boost::python::converter::registration* reg = boost::python::converter::registry::query(info);
    if (reg == 0 || reg->m_to_python == 0) {

        boost::python::class_<Container>(py_name)
            .def(boost::python::vector_indexing_suite<Container>())
            .def("__str__", &VectorConverter<Container>::to_string);
        boost::python::converter::registry::push_back(
            &VectorConverter<Container>::convertible,
            &VectorConverter<Container>::construct,
            boost::python::type_id<Container>());
    }
}

// export vector
template<class Container> void
export_vector_no_str(const char* py_name)
{
    boost::python::type_info info = boost::python::type_id<Container>(); 
    const boost::python::converter::registration* reg = boost::python::converter::registry::query(info);
    if (reg == 0 || reg->m_to_python == 0) {

        boost::python::class_<Container>(py_name)
            .def(boost::python::vector_indexing_suite<Container>());
        boost::python::converter::registry::push_back(
            &VectorConverter<Container>::convertible,
            &VectorConverter<Container>::construct,
            boost::python::type_id<Container>());
    }
}

// export vector
template<class Container> void
export_vector_no_str_no_proxy(const char* py_name)
{
    boost::python::type_info info = boost::python::type_id<Container>(); 
    const boost::python::converter::registration* reg = boost::python::converter::registry::query(info);
    if (reg == 0 || reg->m_to_python == 0) {

        boost::python::class_<Container>(py_name)
            .def(boost::python::vector_indexing_suite<Container, true>());
        boost::python::converter::registry::push_back(
            &VectorConverter<Container>::convertible,
            &VectorConverter<Container>::construct,
            boost::python::type_id<Container>());
    }
}


} // end of namespace python
} // end of namespace ipsdk

#endif // __PYIPSDKBASE_PYTHONSTDVECTORUTILS_H__