pyFoo.cpp

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <pybind11/stl_bind.h>
#include <foo/Foo.hpp>

namespace py = pybind11;

//PYBIND11_MAKE_OPAQUE(std::vector<std::string>);
//PYBIND11_MAKE_OPAQUE(std::vector<std::vector<std::string>>);
//PYBIND11_MAKE_OPAQUE(std::vector<std::pair<int, int>>);
//PYBIND11_MAKE_OPAQUE(std::vector<std::vector<std::pair<int, int>>>);

PYBIND11_MODULE(pyFoo, m) {
    m.doc() = "pyFoo module"; // optional module docstring

    // Free function
    // Vector of String
    m.def("string_vector_output", &::foo::stringVectorOutput, "A function that return a vector of string.");
    m.def("string_vector_input", &::foo::stringVectorInput, "A function that use a vector of string.");
    m.def("string_vector_ref_input", &::foo::stringVectorInput, "A function that use a vector of string const ref.");

    // Vector of Vector of String
    m.def("string_jagged_array_output", &::foo::stringJaggedArrayOutput, "A function that return a jagged array of string.");
    m.def("string_jagged_array_input", &::foo::stringJaggedArrayInput, "A function that use a jagged array of string.");
    m.def("string_jagged_array_ref_input", &::foo::stringJaggedArrayRefInput, "A function that use a jagged array of string const ref.");

    // Vector of Pair
    m.def("pair_vector_output", &::foo::pairVectorOutput, "A function that return a vector of pair.");
    m.def("pair_vector_input", &::foo::pairVectorInput, "A function that use a vector of pair.");
    m.def("pair_vector_ref_input", &::foo::pairVectorRefInput, "A function that use a vector of pair const ref.");

    // Vector of Vector of Pair
    m.def("pair_jagged_array_output", &::foo::pairJaggedArrayOutput, "A function that return a jagged array of pair.");
    m.def("pair_jagged_array_input", &::foo::pairJaggedArrayInput, "A function that use a jagged array of pair.");
    m.def("pair_jagged_array_ref_input", &::foo::pairJaggedArrayRefInput, "A function that use a jagged array of pair const ref.");

    // Free Function
    m.def("free_function", py::overload_cast<int>(&::foo::freeFunction), "A free function taking an int.");
    m.def("free_function", py::overload_cast<int64_t>(&::foo::freeFunction), "A free function taking an int64.");

    // Class Foo
    py::class_<::foo::Foo>(m, "Foo")
      .def_static("static_function", py::overload_cast<int>(&::foo::Foo::staticFunction))
      .def_static("static_function", py::overload_cast<int64_t>(&::foo::Foo::staticFunction))
      .def(py::init<>())
      .def_property("int", &::foo::Foo::getInt, &::foo::Foo::setInt, py::return_value_policy::copy)
      .def_property("int64", &::foo::Foo::getInt64, &::foo::Foo::setInt64, py::return_value_policy::copy)
      .def("__str__", &::foo::Foo::operator());
}