mirror of
https://github.com/pybind/pybind11.git
synced 2024-11-11 08:03:55 +00:00
fa5d05e15d
This replaces the current `all_of_t<Pred, Ts...>` with `all_of<Ts...>`, with previous use of `all_of_t<Pred, Ts...>` becoming `all_of<Pred<Ts>...>` (and similarly for `any_of_t`). It also adds a `none_of<Ts...>`, a shortcut for `negation<any_of<Ts...>>`. This allows `all_of` and `any_of` to be used a bit more flexible, e.g. in cases where several predicates need to be tested for the same type instead of the same predicate for multiple types. This commit replaces the implementation with a more efficient version for non-MSVC. For MSVC, this changes the workaround to use the built-in, recursive std::conjunction/std::disjunction instead. This also removes the `count_t` since `any_of_t` and `all_of_t` were the only things using it. This commit also rearranges some of the future std imports to use actual `std` implementations for C++14/17 features when under the appropriate compiler mode, as we were already doing for a few things (like index_sequence). Most of these aren't saving much (the implementation for enable_if_t, for example, is trivial), but I think it makes the intention of the code instantly clear. It also enables MSVC's native std::index_sequence support.
101 lines
2.8 KiB
C++
101 lines
2.8 KiB
C++
/*
|
|
tests/test_stl_binders.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 "pybind11_tests.h"
|
|
|
|
#include <pybind11/stl_bind.h>
|
|
#include <map>
|
|
#include <deque>
|
|
#include <unordered_map>
|
|
|
|
#ifdef _MSC_VER
|
|
// We get some really long type names here which causes MSVC to emit warnings
|
|
# pragma warning(disable: 4503) // warning C4503: decorated name length exceeded, name was truncated
|
|
#endif
|
|
|
|
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;
|
|
}
|
|
|
|
/// Issue #487: binding std::vector<E> with E non-copyable
|
|
class E_nc {
|
|
public:
|
|
explicit E_nc(int i) : value{i} {}
|
|
E_nc(const E_nc &) = delete;
|
|
E_nc &operator=(const E_nc &) = delete;
|
|
E_nc(E_nc &&) = default;
|
|
E_nc &operator=(E_nc &&) = default;
|
|
|
|
int value;
|
|
};
|
|
|
|
template <class Container> Container *one_to_n(int n) {
|
|
auto v = new Container();
|
|
for (int i = 1; i <= n; i++)
|
|
v->emplace_back(i);
|
|
return v;
|
|
}
|
|
|
|
template <class Map> Map *times_ten(int n) {
|
|
auto m = new Map();
|
|
for (int i = 1; i <= n; i++)
|
|
m->emplace(int(i), E_nc(10*i));
|
|
return m;
|
|
}
|
|
|
|
test_initializer stl_binder_vector([](py::module &m) {
|
|
py::class_<El>(m, "El")
|
|
.def(py::init<int>());
|
|
|
|
py::bind_vector<std::vector<unsigned int>>(m, "VectorInt");
|
|
py::bind_vector<std::vector<bool>>(m, "VectorBool");
|
|
|
|
py::bind_vector<std::vector<El>>(m, "VectorEl");
|
|
|
|
py::bind_vector<std::vector<std::vector<El>>>(m, "VectorVectorEl");
|
|
|
|
});
|
|
|
|
test_initializer stl_binder_map([](py::module &m) {
|
|
py::bind_map<std::map<std::string, double>>(m, "MapStringDouble");
|
|
py::bind_map<std::unordered_map<std::string, double>>(m, "UnorderedMapStringDouble");
|
|
|
|
py::bind_map<std::map<std::string, double const>>(m, "MapStringDoubleConst");
|
|
py::bind_map<std::unordered_map<std::string, double const>>(m, "UnorderedMapStringDoubleConst");
|
|
|
|
});
|
|
|
|
test_initializer stl_binder_noncopyable([](py::module &m) {
|
|
py::class_<E_nc>(m, "ENC")
|
|
.def(py::init<int>())
|
|
.def_readwrite("value", &E_nc::value);
|
|
|
|
py::bind_vector<std::vector<E_nc>>(m, "VectorENC");
|
|
m.def("get_vnc", &one_to_n<std::vector<E_nc>>, py::return_value_policy::reference);
|
|
|
|
py::bind_vector<std::deque<E_nc>>(m, "DequeENC");
|
|
m.def("get_dnc", &one_to_n<std::deque<E_nc>>, py::return_value_policy::reference);
|
|
|
|
py::bind_map<std::map<int, E_nc>>(m, "MapENC");
|
|
m.def("get_mnc", ×_ten<std::map<int, E_nc>>, py::return_value_policy::reference);
|
|
|
|
py::bind_map<std::unordered_map<int, E_nc>>(m, "UmapENC");
|
|
m.def("get_umnc", ×_ten<std::unordered_map<int, E_nc>>, py::return_value_policy::reference);
|
|
});
|
|
|