mirror of
https://github.com/pybind/pybind11.git
synced 2024-11-11 08:03:55 +00:00
Merge branch 'stl_bind'
This commit is contained in:
commit
00c7d6ccc7
@ -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
|
||||
)
|
||||
|
||||
@ -128,6 +129,7 @@ set(PYBIND11_EXAMPLES
|
||||
example/example14.cpp
|
||||
example/example15.cpp
|
||||
example/example16.cpp
|
||||
example/example17.cpp
|
||||
example/issues.cpp
|
||||
)
|
||||
|
||||
|
@ -99,6 +99,7 @@ Jonas Adler,
|
||||
Sylvain Corlay,
|
||||
Axel Huebl,
|
||||
@hulucc,
|
||||
Sergey Lyskov
|
||||
Johan Mabille,
|
||||
Tomasz Miąsko, and
|
||||
Ben Pritchard.
|
||||
|
@ -779,6 +779,10 @@ exceptions:
|
||||
| | accesses in ``__getitem__``, |
|
||||
| | ``__setitem__``, etc.) |
|
||||
+--------------------------------------+------------------------------+
|
||||
| :class:`pybind11::value_error` | ``ValueError`` (used to |
|
||||
| | indicate wrong value passed |
|
||||
| | in ``container.remove(...)`` |
|
||||
+--------------------------------------+------------------------------+
|
||||
| :class:`pybind11::error_already_set` | Indicates that the Python |
|
||||
| | exception flag has already |
|
||||
| | been initialized |
|
||||
@ -1531,4 +1535,3 @@ work, it is important that all lines are indented consistently, i.e.:
|
||||
|
||||
.. [#f4] http://www.sphinx-doc.org
|
||||
.. [#f5] http://github.com/pybind/pbtest
|
||||
|
||||
|
@ -25,6 +25,7 @@ void init_ex13(py::module &);
|
||||
void init_ex14(py::module &);
|
||||
void init_ex15(py::module &);
|
||||
void init_ex16(py::module &);
|
||||
void init_ex17(py::module &);
|
||||
void init_issues(py::module &);
|
||||
|
||||
#if defined(PYBIND11_TEST_EIGEN)
|
||||
@ -50,6 +51,7 @@ PYBIND11_PLUGIN(example) {
|
||||
init_ex14(m);
|
||||
init_ex15(m);
|
||||
init_ex16(m);
|
||||
init_ex17(m);
|
||||
init_issues(m);
|
||||
|
||||
#if defined(PYBIND11_TEST_EIGEN)
|
||||
|
36
example/example17.cpp
Normal file
36
example/example17.cpp
Normal file
@ -0,0 +1,36 @@
|
||||
/*
|
||||
example/example17.cpp -- Usage of stl_binders functions
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include "example.h"
|
||||
|
||||
#include <pybind11/stl_bind.h>
|
||||
|
||||
class El {
|
||||
public:
|
||||
El() = delete;
|
||||
El(int v) : a(v) { }
|
||||
|
||||
int a;
|
||||
};
|
||||
|
||||
std::ostream & operator<<(std::ostream &s, El const&v) {
|
||||
s << "El{" << v.a << '}';
|
||||
return s;
|
||||
}
|
||||
|
||||
void init_ex17(py::module &m) {
|
||||
pybind11::class_<El>(m, "El")
|
||||
.def(pybind11::init<int>());
|
||||
|
||||
pybind11::bind_vector<unsigned int>(m, "VectorInt");
|
||||
|
||||
pybind11::bind_vector<El>(m, "VectorEl");
|
||||
|
||||
pybind11::bind_vector<std::vector<El>>(m, "VectorVectorEl");
|
||||
}
|
40
example/example17.py
Normal file
40
example/example17.py
Normal file
@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env python
|
||||
from __future__ import print_function
|
||||
|
||||
from example import VectorInt, El, VectorEl, VectorVectorEl
|
||||
|
||||
v_int = VectorInt([0, 0])
|
||||
print(len(v_int))
|
||||
|
||||
print(bool(v_int))
|
||||
|
||||
v_int2 = VectorInt([0, 0])
|
||||
print(v_int == v_int2)
|
||||
|
||||
v_int2[1] = 1
|
||||
print(v_int != v_int2)
|
||||
|
||||
v_int2.append(2)
|
||||
v_int2.append(3)
|
||||
v_int2.insert(0, 1)
|
||||
v_int2.insert(0, 2)
|
||||
v_int2.insert(0, 3)
|
||||
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 = 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)
|
10
example/example17.ref
Normal file
10
example/example17.ref
Normal file
@ -0,0 +1,10 @@
|
||||
2
|
||||
True
|
||||
True
|
||||
True
|
||||
VectorInt[3, 2, 1, 0, 1, 2, 3]
|
||||
VectorInt[3, 2, 0, 0, 99, 2, 3]
|
||||
VectorInt[3, 0, 99, 2, 3]
|
||||
VectorInt[0, 99, 2, 3]
|
||||
VectorEl[El{1}, El{2}]
|
||||
VectorEl[El{1}, El{2}]
|
@ -305,6 +305,7 @@ NAMESPACE_END(detail)
|
||||
class error_already_set : public std::runtime_error { public: error_already_set() : std::runtime_error(detail::error_string()) {} };
|
||||
PYBIND11_RUNTIME_EXCEPTION(stop_iteration)
|
||||
PYBIND11_RUNTIME_EXCEPTION(index_error)
|
||||
PYBIND11_RUNTIME_EXCEPTION(value_error)
|
||||
PYBIND11_RUNTIME_EXCEPTION(cast_error) /// Thrown when pybind11::cast or handle::call fail due to a type casting error
|
||||
|
||||
[[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const char *reason) { throw std::runtime_error(reason); }
|
||||
|
@ -396,6 +396,7 @@ protected:
|
||||
}
|
||||
} catch (const error_already_set &) { return nullptr;
|
||||
} catch (const index_error &e) { PyErr_SetString(PyExc_IndexError, e.what()); return nullptr;
|
||||
} catch (const value_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return nullptr;
|
||||
} catch (const stop_iteration &e) { PyErr_SetString(PyExc_StopIteration, e.what()); return nullptr;
|
||||
} catch (const std::bad_alloc &e) { PyErr_SetString(PyExc_MemoryError, e.what()); return nullptr;
|
||||
} catch (const std::domain_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return nullptr;
|
||||
|
349
include/pybind11/stl_bind.h
Normal file
349
include/pybind11/stl_bind.h
Normal file
@ -0,0 +1,349 @@
|
||||
/*
|
||||
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<>());
|
||||
|
||||
// Register copy constructor (if possible)
|
||||
detail::vector_if_copy_constructible<Vector, Class_>(cl);
|
||||
|
||||
// Register comparison-related operators and functions (if possible)
|
||||
detail::vector_if_equal_operator<Vector, Class_>(cl);
|
||||
|
||||
// Register stream insertion operator (if possible)
|
||||
detail::vector_if_insertion_operator<Vector, Class_>(cl, name);
|
||||
|
||||
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"
|
||||
);
|
||||
|
||||
#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)
|
Loading…
Reference in New Issue
Block a user