Skip to content

P
pybind11
Commit 25c03cec by Wenzel Jakob
Options

stl_bind redesign & cleanup pass

parent 26aca3d8
Showing with 384 additions and 289 deletions
CMakeLists.txt
......@@ -108,6 +108,7 @@ set(PYBIND11_HEADERS
include/pybind11/pybind11.h
include/pybind11/pytypes.h
include/pybind11/stl.h
include/pybind11/stl_bind.h
include/pybind11/typeid.h
)
......
README.md
......@@ -99,6 +99,7 @@ Jonas Adler,
Sylvain Corlay,
Axel Huebl,
@hulucc,
Sergey Lyskov
Johan Mabille,
Tomasz Miąsko, and
Ben Pritchard.
......
example/example17.cpp
/*
example/example17.cpp -- Usage of stl_binders functions
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
Copyright (c) 2016 Sergey Lyskov
All rights reserved. Use of this source code is governed by a
BSD-style license that can be found in the LICENSE file.
......@@ -9,29 +9,28 @@
#include "example.h"
#include <pybind11/stl_binders.h>
#include <pybind11/stl_bind.h>
class A {
class El {
public:
A() = delete;
A(int v) :a(v) {}
El() = delete;
El(int v) : a(v) { }
int a;
};
std::ostream & operator<<(std::ostream &s, A const&v) {
s << "A{" << v.a << '}';
std::ostream & operator<<(std::ostream &s, El const&v) {
s << "El{" << v.a << '}';
return s;
}
void init_ex17(py::module &m) {
pybind11::class_<A>(m, "A")
pybind11::class_<El>(m, "El")
.def(pybind11::init<int>());
pybind11::vector_binder<int>(m, "VectorInt");
pybind11::bind_vector<int>(m, "VectorInt");
pybind11::bind_vector<El>(m, "VectorEl");
pybind11::vector_binder<A>(m, "VectorA");
pybind11::bind_vector<std::vector<El>>(m, "VectorVectorEl");
}
example/example17.py
#!/usr/bin/env python
from __future__ import print_function
from example import VectorInt, VectorA, A
from example import VectorInt, El, VectorEl, VectorVectorEl
v_int = VectorInt(2)
v_int = VectorInt([0, 0])
print(len(v_int))
print(bool(v_int))
v_int2 = VectorInt(2)
v_int2 = VectorInt([0, 0])
print(v_int == v_int2)
v_int2[1] = 1
......@@ -24,8 +24,17 @@ print(v_int2)
v_int.append(99)
v_int2[2:-2] = v_int
print(v_int2)
del v_int2[1:3]
print(v_int2)
del v_int2[0]
print(v_int2)
v_a = VectorA()
v_a.append(A(1))
v_a.append(A(2))
v_a = VectorEl()
v_a.append(El(1))
v_a.append(El(2))
print(v_a)
vv_a = VectorVectorEl()
vv_a.append(v_a)
vv_b = vv_a[0]
print(vv_b)
example/example17.ref
......@@ -4,8 +4,7 @@ True
True
VectorInt[3, 2, 1, 0, 1, 2, 3]
VectorInt[3, 2, 0, 0, 99, 2, 3]
A constructor
A destructor
A constructor
A destructor
VectorA[A{1}, A{2}]
VectorInt[3, 0, 99, 2, 3]
VectorInt[0, 99, 2, 3]
VectorEl[El{1}, El{2}]
VectorEl[El{1}, El{2}]
include/pybind11/pybind11.h
......@@ -212,7 +212,7 @@ protected:
rec->is_constructor = !strcmp(rec->name, "__init__");
rec->has_args = false;
rec->has_kwargs = false;
rec->nargs = args;
rec->nargs = (uint16_t) args;
#if PY_MAJOR_VERSION < 3
if (rec->sibling && PyMethod_Check(rec->sibling.ptr()))
......
include/pybind11/stl_bind.h 0 → 100644
/*
pybind11/std_bind.h: Binding generators for STL data types
Copyright (c) 2016 Sergey Lyskov and Wenzel Jakob
All rights reserved. Use of this source code is governed by a
BSD-style license that can be found in the LICENSE file.
*/
#pragma once
#include "common.h"
#include "operators.h"
#include <type_traits>
#include <utility>
#include <algorithm>
#include <sstream>
NAMESPACE_BEGIN(pybind11)
NAMESPACE_BEGIN(detail)
/* SFINAE helper class used by 'is_comparable */
template <typename T> struct container_traits {
template <typename T2> static std::true_type test_comparable(decltype(std::declval<const T2 &>() == std::declval<const T2 &>())*);
template <typename T2> static std::false_type test_comparable(...);
template <typename T2> static std::true_type test_value(typename T2::value_type *);
template <typename T2> static std::false_type test_value(...);
template <typename T2> static std::true_type test_pair(typename T2::first_type *, typename T2::second_type *);
template <typename T2> static std::false_type test_pair(...);
static constexpr const bool is_comparable = std::is_same<std::true_type, decltype(test_comparable<T>(nullptr))>::value;
static constexpr const bool is_pair = std::is_same<std::true_type, decltype(test_pair<T>(nullptr, nullptr))>::value;
static constexpr const bool is_vector = std::is_same<std::true_type, decltype(test_value<T>(nullptr))>::value;
static constexpr const bool is_element = !is_pair && !is_vector;
};
/* Default: is_comparable -> std::false_type */
template <typename T, typename SFINAE = void>
struct is_comparable : std::false_type { };
/* For non-map data structures, check whether operator== can be instantiated */
template <typename T>
struct is_comparable<
T, typename std::enable_if<container_traits<T>::is_element &&
container_traits<T>::is_comparable>::type>
: std::true_type { };
/* For a vector/map data structure, recursively check the value type (which is std::pair for maps) */
template <typename T>
struct is_comparable<T, typename std::enable_if<container_traits<T>::is_vector>::type> {
static constexpr const bool value =
is_comparable<typename T::value_type>::value;
};
/* For pairs, recursively check the two data types */
template <typename T>
struct is_comparable<T, typename std::enable_if<container_traits<T>::is_pair>::type> {
static constexpr const bool value =
is_comparable<typename T::first_type>::value &&
is_comparable<typename T::second_type>::value;
};
/* Fallback functions */
template <typename, typename, typename... Args> void vector_if_copy_constructible(const Args&...) { }
template <typename, typename, typename... Args> void vector_if_equal_operator(const Args&...) { }
template <typename, typename, typename... Args> void vector_if_insertion_operator(const Args&...) { }
template<typename Vector, typename Class_, typename std::enable_if<std::is_copy_constructible<typename Vector::value_type>::value, int>::type = 0>
void vector_if_copy_constructible(Class_ &cl) {
cl.def(pybind11::init<const Vector &>(),
"Copy constructor");
}
template<typename Vector, typename Class_, typename std::enable_if<is_comparable<Vector>::value, int>::type = 0>
void vector_if_equal_operator(Class_ &cl) {
using T = typename Vector::value_type;
cl.def(self == self);
cl.def(self != self);
cl.def("count",
[](const Vector &v, const T &x) {
return std::count(v.begin(), v.end(), x);
},
arg("x"),
"Return the number of times ``x`` appears in the list"
);
cl.def("remove", [](Vector &v, const T &x) {
auto p = std::find(v.begin(), v.end(), x);
if (p != v.end())
v.erase(p);
else
throw pybind11::value_error();
},
arg("x"),
"Remove the first item from the list whose value is x. "
"It is an error if there is no such item."
);
cl.def("__contains__",
[](const Vector &v, const T &x) {
return std::find(v.begin(), v.end(), x) != v.end();
},
arg("x"),
"Return true the container contains ``x``"
);
}
template <typename Vector, typename Class_> auto vector_if_insertion_operator(Class_ &cl, const char *name)
-> decltype(std::declval<std::ostream&>() << std::declval<typename Vector::value_type>(), void()) {
using size_type = typename Vector::size_type;
cl.def("__repr__",
[name](Vector &v) {
std::ostringstream s;
s << name << '[';
for (size_type i=0; i < v.size(); ++i) {
s << v[i];
if (i != v.size() - 1)
s << ", ";
}
s << ']';
return s.str();
},
"Return the canonical string representation of this list."
);
}
NAMESPACE_END(detail)
template <typename T, typename Allocator = std::allocator<T>, typename holder_type = std::unique_ptr<std::vector<T, Allocator>>, typename... Args>
pybind11::class_<std::vector<T, Allocator>, holder_type> bind_vector(pybind11::module &m, const char *name, Args&&... args) {
using Vector = std::vector<T, Allocator>;
using SizeType = typename Vector::size_type;
using Class_ = pybind11::class_<Vector, holder_type>;
Class_ cl(m, name, std::forward<Args>(args)...);
cl.def(pybind11::init<>());
detail::vector_if_copy_constructible<Vector, Class_>(cl);
cl.def("__init__", [](Vector &v, iterable it) {
new (&v) Vector();
try {
v.reserve(len(it));
for (handle h : it)
v.push_back(h.cast<typename Vector::value_type>());
} catch (...) {
v.~Vector();
throw;
}
});
cl.def("append", (void (Vector::*) (const T &)) & Vector::push_back,
arg("x"),
"Add an item to the end of the list");
cl.def("extend",
[](Vector &v, Vector &src) {
v.reserve(v.size() + src.size());
v.insert(v.end(), src.begin(), src.end());
},
arg("L"),
"Extend the list by appending all the items in the given list"
);
cl.def("insert",
[](Vector &v, SizeType i, const T &x) {
v.insert(v.begin() + i, x);
},
arg("i") , arg("x"),
"Insert an item at a given position."
);
cl.def("pop",
[](Vector &v) {
if (v.empty())
throw pybind11::index_error();
T t = v.back();
v.pop_back();
return t;
},
"Remove and return the last item"
);
cl.def("pop",
[](Vector &v, SizeType i) {
if (i >= v.size())
throw pybind11::index_error();
T t = v[i];
v.erase(v.begin() + i);
return t;
},
arg("i"),
"Remove and return the item at index ``i``"
);
cl.def("__bool__",
[](const Vector &v) -> bool {
return !v.empty();
},
"Check whether the list is nonempty"
);
cl.def("__getitem__",
[](const Vector &v, SizeType i) {
if (i >= v.size())
throw pybind11::index_error();
return v[i];
}
);
cl.def("__setitem__",
[](Vector &v, SizeType i, const T &t) {
if (i >= v.size())
throw pybind11::index_error();
v[i] = t;
}
);
cl.def("__delitem__",
[](Vector &v, SizeType i) {
if (i >= v.size())
throw pybind11::index_error();
v.erase(v.begin() + i);
},
"Delete list elements using a slice object"
);
cl.def("__len__", &Vector::size);
cl.def("__iter__",
[](Vector &v) {
return pybind11::make_iterator(v.begin(), v.end());
},
pybind11::keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */
);
/// Slicing protocol
cl.def("__getitem__",
[](const Vector &v, slice slice) -> Vector * {
ssize_t start, stop, step, slicelength;
if (!slice.compute(v.size(), &start, &stop, &step, &slicelength))
throw pybind11::error_already_set();
Vector *seq = new Vector();
seq->reserve((size_t) slicelength);
for (int i=0; i<slicelength; ++i) {
seq->push_back(v[start]);
start += step;
}
return seq;
},
arg("s"),
"Retrieve list elements using a slice object"
);
cl.def("__setitem__",
[](Vector &v, slice slice, const Vector &value) {
ssize_t start, stop, step, slicelength;
if (!slice.compute(v.size(), &start, &stop, &step, &slicelength))
throw pybind11::error_already_set();
if ((size_t) slicelength != value.size())
throw std::runtime_error("Left and right hand size of slice assignment have different sizes!");
for (int i=0; i<slicelength; ++i) {
v[start] = value[i];
start += step;
}
},
"Assign list elements using a slice object"
);
cl.def("__delitem__",
[](Vector &v, slice slice) {
ssize_t start, stop, step, slicelength;
if (!slice.compute(v.size(), &start, &stop, &step, &slicelength))
throw pybind11::error_already_set();
if (step == 1 && false) {
v.erase(v.begin() + start, v.begin() + start + slicelength);
} else {
for (ssize_t i = 0; i < slicelength; ++i) {
v.erase(v.begin() + start);
start += step - 1;
}
}
},
"Delete list elements using a slice object"
);
// Comparisons
detail::vector_if_equal_operator<Vector, Class_>(cl);
// Printing
detail::vector_if_insertion_operator<Vector, Class_>(cl, name);
#if 0
// C++ style functions deprecated, leaving it here as an example
cl.def(pybind11::init<size_type>());
cl.def("resize",
(void (Vector::*) (size_type count)) & Vector::resize,
"changes the number of elements stored");
cl.def("erase",
[](Vector &v, SizeType i) {
if (i >= v.size())
throw pybind11::index_error();
v.erase(v.begin() + i);
}, "erases element at index ``i``");
cl.def("empty", &Vector::empty, "checks whether the container is empty");
cl.def("size", &Vector::size, "returns the number of elements");
cl.def("push_back", (void (Vector::*)(const T&)) &Vector::push_back, "adds an element to the end");
cl.def("pop_back", &Vector::pop_back, "removes the last element");
cl.def("max_size", &Vector::max_size, "returns the maximum possible number of elements");
cl.def("reserve", &Vector::reserve, "reserves storage");
cl.def("capacity", &Vector::capacity, "returns the number of elements that can be held in currently allocated storage");
cl.def("shrink_to_fit", &Vector::shrink_to_fit, "reduces memory usage by freeing unused memory");
cl.def("clear", &Vector::clear, "clears the contents");
cl.def("swap", &Vector::swap, "swaps the contents");
cl.def("front", [](Vector &v) {
if (v.size()) return v.front();
else throw pybind11::index_error();
}, "access the first element");
cl.def("back", [](Vector &v) {
if (v.size()) return v.back();
else throw pybind11::index_error();
}, "access the last element ");
#endif
return cl;
}
NAMESPACE_END(pybind11)
include/pybind11/stl_binders.h deleted 100644 → 0
/*
pybind11/std_binders.h: Convenience wrapper functions for STL containers with C++ like interface
Copyright (c) 2016 Sergey Lyskov
All rights reserved. Use of this source code is governed by a
BSD-style license that can be found in the LICENSE file.
*/
#ifndef _INCLUDED_std_binders_h_
#define _INCLUDED_std_binders_h_
#include "common.h"
#include "operators.h"
#include <type_traits>
#include <utility>
#include <algorithm>
#include <sstream>
NAMESPACE_BEGIN(pybind11)
NAMESPACE_BEGIN(detail)
template<typename T>
constexpr auto has_equal_operator(int) -> decltype(std::declval<T>() == std::declval<T>(), bool()) { return true; }
template<typename T>
constexpr bool has_equal_operator(...) { return false; }
// Workaround for MSVC 2015
template<typename T>
struct has_equal_operator_s {
static const bool value = has_equal_operator<T>(0);
};
template<typename T>
constexpr auto has_not_equal_operator(int) -> decltype(std::declval<T>() != std::declval<T>(), bool()) { return true; }
template<typename T>
constexpr bool has_not_equal_operator(...) { return false; }
// Workaround for MSVC 2015
template<typename T>
struct has_not_equal_operator_s {
static const bool value = has_not_equal_operator<T>(0);
};
namespace has_insertion_operator_implementation {
enum class False {};
struct any_type {
template<typename T> any_type(T const&);
};
False operator<<(std::ostream const&, any_type const&);
}
template<typename T>
constexpr bool has_insertion_operator() {
using namespace has_insertion_operator_implementation;
return std::is_same< decltype(std::declval<std::ostream&>() << std::declval<T>()), std::ostream & >::value;
}
// Workaround for MSVC 2015
template<typename T>
struct has_insertion_operator_s {
static const bool value = has_insertion_operator<T>();
};
template<typename Vector, typename Class_, typename std::enable_if< std::is_default_constructible<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_default_constructible(Class_ &cl) {
using size_type = typename Vector::size_type;
cl.def(pybind11::init<size_type>());
cl.def("resize", (void (Vector::*)(size_type count)) &Vector::resize, "changes the number of elements stored");
/// Slicing protocol
cl.def("__getitem__", [](Vector const &v, pybind11::slice slice) -> Vector * {
pybind11::ssize_t start, stop, step, slicelength;
if(!slice.compute(v.size(), &start, &stop, &step, &slicelength))
throw pybind11::error_already_set();
Vector *seq = new Vector(slicelength);
for (int i=0; i<slicelength; ++i) {
(*seq)[i] = v[start]; start += step;
}
return seq;
});
}
template<typename Vector, typename Class_, typename std::enable_if< !std::is_default_constructible<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_default_constructible(Class_ &) {}
template<typename Vector, typename Class_, typename std::enable_if< std::is_copy_constructible<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_copy_constructible(Class_ &cl) {
cl.def(pybind11::init< Vector const &>());
}
template<typename Vector, typename Class_, typename std::enable_if< !std::is_copy_constructible<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_copy_constructible(Class_ &) {}
template<typename Vector, typename Class_, typename std::enable_if< has_equal_operator_s<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_has_equal_operator(Class_ &cl) {
using T = typename Vector::value_type;
cl.def(pybind11::self == pybind11::self);
cl.def("count", [](Vector const &v, T const & value) { return std::count(v.begin(), v.end(), value); }, "counts the elements that are equal to value");
cl.def("remove", [](Vector &v, T const &t) {
auto p = std::find(v.begin(), v.end(), t);
if(p != v.end()) v.erase(p);
else throw pybind11::value_error();
}, "Remove the first item from the list whose value is x. It is an error if there is no such item.");
cl.def("__contains__", [](Vector const &v, T const &t) { return std::find(v.begin(), v.end(), t) != v.end(); }, "return true if item in the container");
}
template<typename Vector, typename Class_, typename std::enable_if< !has_equal_operator_s<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_has_equal_operator(Class_ &) {}
template<typename Vector, typename Class_, typename std::enable_if< has_not_equal_operator_s<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_has_not_equal_operator(Class_ &cl) {
cl.def(pybind11::self != pybind11::self);
}
template<typename Vector, typename Class_, typename std::enable_if< !has_not_equal_operator_s<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_has_not_equal_operator(Class_ &) {}
template<typename Vector, typename Class_, typename std::enable_if< has_insertion_operator_s<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_has_insertion_operator(char const *name, Class_ &cl) {
using size_type = typename Vector::size_type;
cl.def("__repr__", [name](Vector &v) {
std::ostringstream s;
s << name << '[';
for(size_type i=0; i<v.size(); ++i) {
s << v[i];
if(i != v.size()-1) s << ", ";
}
s << ']';
return s.str();
});
}
template<typename Vector, typename Class_, typename std::enable_if< !has_insertion_operator_s<typename Vector::value_type>::value >::type * = nullptr>
void vector_maybe_has_insertion_operator(char const *, Class_ &) {}
NAMESPACE_END(detail)
template <typename T, typename Allocator = std::allocator<T>, typename holder_type = std::unique_ptr< std::vector<T, Allocator> > >
pybind11::class_<std::vector<T, Allocator>, holder_type > vector_binder(pybind11::module &m, char const *name, char const *doc=nullptr) {
using Vector = std::vector<T, Allocator>;
using SizeType = typename Vector::size_type;
using Class_ = pybind11::class_<Vector, holder_type >;
Class_ cl(m, name, doc);
cl.def(pybind11::init<>());
detail::vector_maybe_default_constructible<Vector>(cl);
detail::vector_maybe_copy_constructible<Vector>(cl);
// Element access
cl.def("front", [](Vector &v) {
if(v.size()) return v.front();
else throw pybind11::index_error();
}, "access the first element");
cl.def("back", [](Vector &v) {
if(v.size()) return v.back();
else throw pybind11::index_error();
}, "access the last element ");
// Not needed, the operator[] is already providing bounds checking cl.def("at", (T& (Vector::*)(SizeType i)) &Vector::at, "access specified element with bounds checking");
// Capacity, C++ style
cl.def("max_size", &Vector::max_size, "returns the maximum possible number of elements");
cl.def("reserve", &Vector::reserve, "reserves storage");
cl.def("capacity", &Vector::capacity, "returns the number of elements that can be held in currently allocated storage");
cl.def("shrink_to_fit", &Vector::shrink_to_fit, "reduces memory usage by freeing unused memory");
// Modifiers, C++ style
cl.def("clear", &Vector::clear, "clears the contents");
cl.def("swap", &Vector::swap, "swaps the contents");
// Modifiers, Python style
cl.def("append", (void (Vector::*)(const T&)) &Vector::push_back, "adds an element to the end");
cl.def("insert", [](Vector &v, SizeType i, const T&t) {v.insert(v.begin()+i, t);}, "insert an item at a given position");
cl.def("extend", [](Vector &v, Vector &src) { v.reserve( v.size() + src.size() ); v.insert(v.end(), src.begin(), src.end()); }, "extend the list by appending all the items in the given vector");
cl.def("pop", [](Vector &v) {
if(v.size()) {
T t = v.back();
v.pop_back();
return t;
}
else throw pybind11::index_error();
}, "remove and return last item");
cl.def("pop", [](Vector &v, SizeType i) {
if(i >= v.size()) throw pybind11::index_error();
T t = v[i];
v.erase(v.begin() + i);
return t;
}, "remove and return item at index");
cl.def("erase", [](Vector &v, SizeType i) {
if(i >= v.size()) throw pybind11::index_error();
v.erase(v.begin() + i);
}, "erases element at index");
// Python friendly bindings
#ifdef PYTHON_ABI_VERSION // Python 3+
cl.def("__bool__", [](Vector &v) -> bool { return v.size() != 0; }); // checks whether the container has any elements in it
#else
cl.def("__nonzero__", [](Vector &v) -> bool { return v.size() != 0; }); // checks whether the container has any elements in it
#endif
cl.def("__getitem__", [](Vector const &v, SizeType i) {
if(i >= v.size()) throw pybind11::index_error();
return v[i];
});
cl.def("__setitem__", [](Vector &v, SizeType i, T const & t) {
if(i >= v.size()) throw pybind11::index_error();
v[i] = t;
});
cl.def("__len__", &Vector::size);
cl.def("__iter__", [](Vector &v) { return pybind11::make_iterator(v.begin(), v.end()); },
pybind11::keep_alive<0, 1>() /* Essential: keep object alive while iterator exists */);
/// Slicing protocol
cl.def("__setitem__", [](Vector &v, pybind11::slice slice, Vector const &value) {
pybind11::ssize_t start, stop, step, slicelength;
if(!slice.compute(v.size(), &start, &stop, &step, &slicelength))
throw pybind11::error_already_set();
if((size_t) slicelength != value.size())
throw std::runtime_error("Left and right hand size of slice assignment have different sizes!");
for(int i=0; i<slicelength; ++i) {
v[start] = value[i]; start += step;
}
});
// Comparisons
detail::vector_maybe_has_equal_operator<Vector>(cl);
detail::vector_maybe_has_not_equal_operator<Vector>(cl);
// Printing
detail::vector_maybe_has_insertion_operator<Vector>(name, cl);
// C++ style functions deprecated, leaving it here as an example
//cl.def("empty", &Vector::empty, "checks whether the container is empty");
//cl.def("size", &Vector::size, "returns the number of elements");
//cl.def("push_back", (void (Vector::*)(const T&)) &Vector::push_back, "adds an element to the end");
//cl.def("pop_back", &Vector::pop_back, "removes the last element");
return cl;
}
NAMESPACE_END(pybind11)
#endif // _INCLUDED_std_binders_h_
setup.py
......@@ -24,6 +24,7 @@ setup(
'include/pybind11/numpy.h',
'include/pybind11/pybind11.h',
'include/pybind11/stl.h',
'include/pybind11/stl_bind.h',
'include/pybind11/common.h',
'include/pybind11/functional.h',
'include/pybind11/operators.h',
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment