pybind11/tests/test_stl.cpp

17 // Test with `std::variant` in C++17 mode, or with `boost::variant` in C++11/14
19 using std::variant;
39 PYBIND11_MAKE_OPAQUE(std::vector<std::string, std::allocator<std::string>>);
47 namespace std {
55     m.def("cast_vector", []() { return std::vector<int>{1}; });
56     m.def("load_vector", [](const std::vector<int> &v) { return v.at(0) == 1 && v.at(1) == 2; });
57     // `std::vector<bool>` is special because it returns proxy objects instead of references
58     m.def("cast_bool_vector", []() { return std::vector<bool>{true, false}; });
59     m.def("load_bool_vector", [](const std::vector<bool> &v) {
63     static std::vector<RValueCaster> lvv{2};
67     m.def("cast_deque", []() { return std::deque<int>{1}; });
68     m.def("load_deque", [](const std::deque<int> &v) { return v.at(0) == 1 && v.at(1) == 2; });
71     m.def("cast_array", []() { return std::array<int, 2> {{1 , 2}}; });
72     m.def("load_array", [](const std::array<int, 2> &a) { return a[0] == 1 && a[1] == 2; });
75     m.def("cast_valarray", []() { return std::valarray<int>{1, 4, 9}; });
76     m.def("load_valarray", [](const std::valarray<int>& v) {
81     m.def("cast_map", []() { return std::map<std::string, std::string>{{"key", "value"}}; });
82     m.def("load_map", [](const std::map<std::string, std::string> &map) {
87     m.def("cast_set", []() { return std::set<std::string>{"key1", "key2"}; });
88     m.def("load_set", [](const std::set<std::string> &set) {
93     m.def("cast_rv_vector", []() { return std::vector<RValueCaster>{2}; });
94     m.def("cast_rv_array", []() { return std::array<RValueCaster, 3>(); });
98     m.def("cast_rv_map", []() { return std::unordered_map<std::string, RValueCaster>{{"a", RValueCaster{}}}; });
100         std::vector<std::array<std::list<std::unordered_map<std::string, RValueCaster>>, 2>> v;
109     static std::array<RValueCaster, 2> lva;
110     static std::unordered_map<std::string, RValueCaster> lvm{{"a", RValueCaster{}}, {"b", RValueCaster{}}};
111     static std::unordered_map<std::string, std::vector<std::list<std::array<RValueCaster, 2>>>> lvn;
125         std::vector<std::unique_ptr<UserType>> v;
134         std::list<Value> move_list() const { return {{0}, {1}, {2}}; }
161     using opt_int = std::optional<int>;
162     using opt_no_assign = std::optional<NoAssign>;
171     }, py::arg_v("x", std::nullopt, "None"));
174     }, py::arg_v("x", std::nullopt, "None"));
176     m.def("nodefer_none_optional", [](std::optional<int>) { return true; });
184     using exp_opt_int = std::experimental::optional<int>;
185     using exp_opt_no_assign = std::experimental::optional<NoAssign>;
194     }, py::arg_v("x", std::experimental::nullopt, "None"));
197     }, py::arg_v("x", std::experimental::nullopt, "None"));
201     static_assert(std::is_same<py::detail::variant_caster_visitor::result_type, py::handle>::value,
208         result_type operator()(std::string) { return "std::string"; }
210         result_type operator()(std::nullptr_t) { return "std::nullptr_t"; }
214     m.def("load_variant", [](variant<int, std::string, double, std::nullptr_t> v) {
221         using V = variant<int, std::string>;
228     m.def("tpl_ctor_vector", [](std::vector<TplCtorClass> &) {});
229     m.def("tpl_ctor_map", [](std::unordered_map<TplCtorClass, TplCtorClass> &) {});
230     m.def("tpl_ctor_set", [](std::unordered_set<TplCtorClass> &) {});
232     m.def("tpl_constr_optional", [](std::optional<TplCtorClass> &) {});
234     m.def("tpl_constr_optional", [](std::experimental::optional<TplCtorClass> &) {});
239     m.def("return_vec_of_reference_wrapper", [](std::reference_wrapper<UserType> p4) {
241         return std::vector<std::reference_wrapper<UserType>> {
242             std::ref(p1), std::ref(p2), std::ref(p3), p4
247     m.def("stl_pass_by_pointer", [](std::vector<int>* v) { return *v; }, "v"_a=nullptr);
250     m.def("func_with_string_or_vector_string_arg_overload", [](std::vector<std::string>) { return 1; });
251     m.def("func_with_string_or_vector_string_arg_overload", [](std::list<std::string>) { return 2; });
252     m.def("func_with_string_or_vector_string_arg_overload", [](std::string) { return 3; });
265               std::vector<Placeholder *> result;
271     m.def("array_cast_sequence", [](std::array<int, 3> x) { return x; });
274     struct Issue1561Inner { std::string data; };
275     struct Issue1561Outer { std::vector<Issue1561Inner> list; };
278         .def(py::init<std::string>())