diff --git a/CMakeLists.txt b/CMakeLists.txt index 24dd8cbc..3f10bd37 100644 --- a/CMakeLists.txt +++ b/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 ) diff --git a/README.md b/README.md index 93e30dc6..376f5629 100644 --- a/README.md +++ b/README.md @@ -99,6 +99,7 @@ Jonas Adler, Sylvain Corlay, Axel Huebl, @hulucc, +Sergey Lyskov Johan Mabille, Tomasz Miąsko, and Ben Pritchard. diff --git a/example/example17.cpp b/example/example17.cpp index 8370b5c6..87902344 100644 --- a/example/example17.cpp +++ b/example/example17.cpp @@ -1,7 +1,7 @@ /* example/example17.cpp -- Usage of stl_binders functions - Copyright (c) 2016 Wenzel Jakob + 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 +#include - -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_(m, "A") + pybind11::class_(m, "El") .def(pybind11::init()); - pybind11::vector_binder(m, "VectorInt"); + pybind11::bind_vector(m, "VectorInt"); - pybind11::vector_binder(m, "VectorA"); + pybind11::bind_vector(m, "VectorEl"); + + pybind11::bind_vector>(m, "VectorVectorEl"); } diff --git a/example/example17.py b/example/example17.py index 52cda423..65e586bc 100644 --- a/example/example17.py +++ b/example/example17.py @@ -1,14 +1,14 @@ #!/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) diff --git a/example/example17.ref b/example/example17.ref index d54c85ce..55e47a68 100644 --- a/example/example17.ref +++ 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}] diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h index f144bfc6..85e3792b 100644 --- a/include/pybind11/pybind11.h +++ b/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())) diff --git a/include/pybind11/stl_bind.h b/include/pybind11/stl_bind.h new file mode 100644 index 00000000..e27dcfd9 --- /dev/null +++ b/include/pybind11/stl_bind.h @@ -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 +#include +#include +#include + +NAMESPACE_BEGIN(pybind11) +NAMESPACE_BEGIN(detail) + +/* SFINAE helper class used by 'is_comparable */ +template struct container_traits { + template static std::true_type test_comparable(decltype(std::declval() == std::declval())*); + template static std::false_type test_comparable(...); + template static std::true_type test_value(typename T2::value_type *); + template static std::false_type test_value(...); + template static std::true_type test_pair(typename T2::first_type *, typename T2::second_type *); + template static std::false_type test_pair(...); + + static constexpr const bool is_comparable = std::is_same(nullptr))>::value; + static constexpr const bool is_pair = std::is_same(nullptr, nullptr))>::value; + static constexpr const bool is_vector = std::is_same(nullptr))>::value; + static constexpr const bool is_element = !is_pair && !is_vector; +}; + +/* Default: is_comparable -> std::false_type */ +template +struct is_comparable : std::false_type { }; + +/* For non-map data structures, check whether operator== can be instantiated */ +template +struct is_comparable< + T, typename std::enable_if::is_element && + container_traits::is_comparable>::type> + : std::true_type { }; + +/* For a vector/map data structure, recursively check the value type (which is std::pair for maps) */ +template +struct is_comparable::is_vector>::type> { + static constexpr const bool value = + is_comparable::value; +}; + +/* For pairs, recursively check the two data types */ +template +struct is_comparable::is_pair>::type> { + static constexpr const bool value = + is_comparable::value && + is_comparable::value; +}; + +/* Fallback functions */ +template void vector_if_copy_constructible(const Args&...) { } +template void vector_if_equal_operator(const Args&...) { } +template void vector_if_insertion_operator(const Args&...) { } + +template::value, int>::type = 0> +void vector_if_copy_constructible(Class_ &cl) { + cl.def(pybind11::init(), + "Copy constructor"); +} + +template::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 auto vector_if_insertion_operator(Class_ &cl, const char *name) + -> decltype(std::declval() << std::declval(), 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 holder_type = std::unique_ptr>, typename... Args> +pybind11::class_, holder_type> bind_vector(pybind11::module &m, const char *name, Args&&... args) { + using Vector = std::vector; + using SizeType = typename Vector::size_type; + using Class_ = pybind11::class_; + + Class_ cl(m, name, std::forward(args)...); + + cl.def(pybind11::init<>()); + + detail::vector_if_copy_constructible(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()); + } 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; ipush_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(cl); + + // Printing + detail::vector_if_insertion_operator(cl, name); + +#if 0 + // C++ style functions deprecated, leaving it here as an example + cl.def(pybind11::init()); + + 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) diff --git a/include/pybind11/stl_binders.h b/include/pybind11/stl_binders.h deleted file mode 100644 index 93b5cad3..00000000 --- a/include/pybind11/stl_binders.h +++ /dev/null @@ -1,264 +0,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 -#include -#include -#include - - -NAMESPACE_BEGIN(pybind11) -NAMESPACE_BEGIN(detail) - -template -constexpr auto has_equal_operator(int) -> decltype(std::declval() == std::declval(), bool()) { return true; } -template -constexpr bool has_equal_operator(...) { return false; } - -// Workaround for MSVC 2015 -template -struct has_equal_operator_s { - static const bool value = has_equal_operator(0); -}; - - - -template -constexpr auto has_not_equal_operator(int) -> decltype(std::declval() != std::declval(), bool()) { return true; } -template -constexpr bool has_not_equal_operator(...) { return false; } - -// Workaround for MSVC 2015 -template -struct has_not_equal_operator_s { - static const bool value = has_not_equal_operator(0); -}; - - -namespace has_insertion_operator_implementation { -enum class False {}; -struct any_type { - template any_type(T const&); -}; -False operator<<(std::ostream const&, any_type const&); -} -template -constexpr bool has_insertion_operator() { - using namespace has_insertion_operator_implementation; - return std::is_same< decltype(std::declval() << std::declval()), std::ostream & >::value; -} - -// Workaround for MSVC 2015 -template -struct has_insertion_operator_s { - static const bool value = has_insertion_operator(); -}; - - -template::value >::type * = nullptr> -void vector_maybe_default_constructible(Class_ &cl) { - using size_type = typename Vector::size_type; - - cl.def(pybind11::init()); - 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::value >::type * = nullptr> -void vector_maybe_default_constructible(Class_ &) {} - - -template::value >::type * = nullptr> -void vector_maybe_copy_constructible(Class_ &cl) { - cl.def(pybind11::init< Vector const &>()); -} -template::value >::type * = nullptr> -void vector_maybe_copy_constructible(Class_ &) {} - - -template::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::value >::type * = nullptr> -void vector_maybe_has_equal_operator(Class_ &) {} - - -template::value >::type * = nullptr> -void vector_maybe_has_not_equal_operator(Class_ &cl) { - cl.def(pybind11::self != pybind11::self); -} -template::value >::type * = nullptr> -void vector_maybe_has_not_equal_operator(Class_ &) {} - - -template::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::value >::type * = nullptr> -void vector_maybe_has_insertion_operator(char const *, Class_ &) {} - - -NAMESPACE_END(detail) - - -template , typename holder_type = std::unique_ptr< std::vector > > -pybind11::class_, holder_type > vector_binder(pybind11::module &m, char const *name, char const *doc=nullptr) { - using Vector = std::vector; - using SizeType = typename Vector::size_type; - using Class_ = pybind11::class_; - - Class_ cl(m, name, doc); - - cl.def(pybind11::init<>()); - - detail::vector_maybe_default_constructible(cl); - detail::vector_maybe_copy_constructible(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(cl); - detail::vector_maybe_has_not_equal_operator(cl); - - // Printing - detail::vector_maybe_has_insertion_operator(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_ diff --git a/setup.py b/setup.py index 4c6e156a..07465bb6 100644 --- a/setup.py +++ b/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',