Skip to content

P
pybind11
Commit 31b7e140 by Huanchen Zhai Committed by GitHub
Options

bugfix: removing typing and duplicate ``class_`` for… 

bugfix: removing typing and duplicate ``class_`` for KeysView/ValuesView/ItemsView. Fix #4529 (#4985)

* remove typing for KeysView/ValuesView/ItemsView

* add tests for map view types
parent aec6cc54
Showing with 62 additions and 57 deletions
include/pybind11/stl_bind.h
...@@ -645,49 +645,50 @@ auto map_if_insertion_operator(Class_ &cl, std::string const &name) ...@@ -645,49 +645,50 @@ auto map_if_insertion_operator(Class_ &cl, std::string const &name)
"Return the canonical string representation of this map."); "Return the canonical string representation of this map.");
} }
template <typename KeyType>
struct keys_view { struct keys_view {
virtual size_t len() = 0; virtual size_t len() = 0;
virtual iterator iter() = 0; virtual iterator iter() = 0;
virtual bool contains(const KeyType &k) = 0; virtual bool contains(const handle &k) = 0;
virtual bool contains(const object &k) = 0;
virtual ~keys_view() = default; virtual ~keys_view() = default;
}; };
template <typename MappedType>
struct values_view { struct values_view {
virtual size_t len() = 0; virtual size_t len() = 0;
virtual iterator iter() = 0; virtual iterator iter() = 0;
virtual ~values_view() = default; virtual ~values_view() = default;
}; };
template <typename KeyType, typename MappedType>
struct items_view { struct items_view {
virtual size_t len() = 0; virtual size_t len() = 0;
virtual iterator iter() = 0; virtual iterator iter() = 0;
virtual ~items_view() = default; virtual ~items_view() = default;
}; };
template <typename Map, typename KeysView> template <typename Map>
struct KeysViewImpl : public KeysView { struct KeysViewImpl : public detail::keys_view {
explicit KeysViewImpl(Map &map) : map(map) {} explicit KeysViewImpl(Map &map) : map(map) {}
size_t len() override { return map.size(); } size_t len() override { return map.size(); }
iterator iter() override { return make_key_iterator(map.begin(), map.end()); } iterator iter() override { return make_key_iterator(map.begin(), map.end()); }
bool contains(const typename Map::key_type &k) override { return map.find(k) != map.end(); } bool contains(const handle &k) override {
bool contains(const object &) override { return false; } try {
return map.find(k.template cast<typename Map::key_type>()) != map.end();
} catch (const cast_error &) {
return false;
}
}
Map &map; Map &map;
}; };
template <typename Map, typename ValuesView> template <typename Map>
struct ValuesViewImpl : public ValuesView { struct ValuesViewImpl : public detail::values_view {
explicit ValuesViewImpl(Map &map) : map(map) {} explicit ValuesViewImpl(Map &map) : map(map) {}
size_t len() override { return map.size(); } size_t len() override { return map.size(); }
iterator iter() override { return make_value_iterator(map.begin(), map.end()); } iterator iter() override { return make_value_iterator(map.begin(), map.end()); }
Map &map; Map &map;
}; };
template <typename Map, typename ItemsView> template <typename Map>
struct ItemsViewImpl : public ItemsView { struct ItemsViewImpl : public detail::items_view {
explicit ItemsViewImpl(Map &map) : map(map) {} explicit ItemsViewImpl(Map &map) : map(map) {}
size_t len() override { return map.size(); } size_t len() override { return map.size(); }
iterator iter() override { return make_iterator(map.begin(), map.end()); } iterator iter() override { return make_iterator(map.begin(), map.end()); }
...@@ -700,11 +701,9 @@ template <typename Map, typename holder_type = std::unique_ptr<Map>, typename... ...@@ -700,11 +701,9 @@ template <typename Map, typename holder_type = std::unique_ptr<Map>, typename...
class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args &&...args) { class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args &&...args) {
using KeyType = typename Map::key_type; using KeyType = typename Map::key_type;
using MappedType = typename Map::mapped_type; using MappedType = typename Map::mapped_type;
using StrippedKeyType = detail::remove_cvref_t<KeyType>; using KeysView = detail::keys_view;
using StrippedMappedType = detail::remove_cvref_t<MappedType>; using ValuesView = detail::values_view;
using KeysView = detail::keys_view<StrippedKeyType>; using ItemsView = detail::items_view;
using ValuesView = detail::values_view<StrippedMappedType>;
using ItemsView = detail::items_view<StrippedKeyType, StrippedMappedType>;
using Class_ = class_<Map, holder_type>; using Class_ = class_<Map, holder_type>;
// If either type is a non-module-local bound type then make the map binding non-local as well; // If either type is a non-module-local bound type then make the map binding non-local as well;
...@@ -718,39 +717,20 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args && ...@@ -718,39 +717,20 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args &&
} }
Class_ cl(scope, name.c_str(), pybind11::module_local(local), std::forward<Args>(args)...); Class_ cl(scope, name.c_str(), pybind11::module_local(local), std::forward<Args>(args)...);
static constexpr auto key_type_descr = detail::make_caster<KeyType>::name;
static constexpr auto mapped_type_descr = detail::make_caster<MappedType>::name;
std::string key_type_name(key_type_descr.text), mapped_type_name(mapped_type_descr.text);
// If key type isn't properly wrapped, fall back to C++ names // Wrap KeysView if it wasn't already wrapped
if (key_type_name == "%") {
key_type_name = detail::type_info_description(typeid(KeyType));
}
// Similarly for value type:
if (mapped_type_name == "%") {
mapped_type_name = detail::type_info_description(typeid(MappedType));
}
// Wrap KeysView[KeyType] if it wasn't already wrapped
if (!detail::get_type_info(typeid(KeysView))) { if (!detail::get_type_info(typeid(KeysView))) {
class_<KeysView> keys_view( class_<KeysView> keys_view(scope, "KeysView", pybind11::module_local(local));
scope, ("KeysView[" + key_type_name + "]").c_str(), pybind11::module_local(local));
keys_view.def("__len__", &KeysView::len); keys_view.def("__len__", &KeysView::len);
keys_view.def("__iter__", keys_view.def("__iter__",
&KeysView::iter, &KeysView::iter,
keep_alive<0, 1>() /* Essential: keep view alive while iterator exists */ keep_alive<0, 1>() /* Essential: keep view alive while iterator exists */
); );
keys_view.def("__contains__", keys_view.def("__contains__", &KeysView::contains);
static_cast<bool (KeysView::*)(const KeyType &)>(&KeysView::contains));
// Fallback for when the object is not of the key type
keys_view.def("__contains__",
static_cast<bool (KeysView::*)(const object &)>(&KeysView::contains));
} }
// Similarly for ValuesView: // Similarly for ValuesView:
if (!detail::get_type_info(typeid(ValuesView))) { if (!detail::get_type_info(typeid(ValuesView))) {
class_<ValuesView> values_view(scope, class_<ValuesView> values_view(scope, "ValuesView", pybind11::module_local(local));
("ValuesView[" + mapped_type_name + "]").c_str(),
pybind11::module_local(local));
values_view.def("__len__", &ValuesView::len); values_view.def("__len__", &ValuesView::len);
values_view.def("__iter__", values_view.def("__iter__",
&ValuesView::iter, &ValuesView::iter,
...@@ -759,10 +739,7 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args && ...@@ -759,10 +739,7 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args &&
} }
// Similarly for ItemsView: // Similarly for ItemsView:
if (!detail::get_type_info(typeid(ItemsView))) { if (!detail::get_type_info(typeid(ItemsView))) {
class_<ItemsView> items_view( class_<ItemsView> items_view(scope, "ItemsView", pybind11::module_local(local));
scope,
("ItemsView[" + key_type_name + ", ").append(mapped_type_name + "]").c_str(),
pybind11::module_local(local));
items_view.def("__len__", &ItemsView::len); items_view.def("__len__", &ItemsView::len);
items_view.def("__iter__", items_view.def("__iter__",
&ItemsView::iter, &ItemsView::iter,
...@@ -788,25 +765,19 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args && ...@@ -788,25 +765,19 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args &&
cl.def( cl.def(
"keys", "keys",
[](Map &m) { [](Map &m) { return std::unique_ptr<KeysView>(new detail::KeysViewImpl<Map>(m)); },
return std::unique_ptr<KeysView>(new detail::KeysViewImpl<Map, KeysView>(m));
},
keep_alive<0, 1>() /* Essential: keep map alive while view exists */ keep_alive<0, 1>() /* Essential: keep map alive while view exists */
); );
cl.def( cl.def(
"values", "values",
[](Map &m) { [](Map &m) { return std::unique_ptr<ValuesView>(new detail::ValuesViewImpl<Map>(m)); },
return std::unique_ptr<ValuesView>(new detail::ValuesViewImpl<Map, ValuesView>(m));
},
keep_alive<0, 1>() /* Essential: keep map alive while view exists */ keep_alive<0, 1>() /* Essential: keep map alive while view exists */
); );
cl.def( cl.def(
"items", "items",
[](Map &m) { [](Map &m) { return std::unique_ptr<ItemsView>(new detail::ItemsViewImpl<Map>(m)); },
return std::unique_ptr<ItemsView>(new detail::ItemsViewImpl<Map, ItemsView>(m));
},
keep_alive<0, 1>() /* Essential: keep map alive while view exists */ keep_alive<0, 1>() /* Essential: keep map alive while view exists */
); );
......
tests/test_stl_binders.cpp
...@@ -192,6 +192,16 @@ TEST_SUBMODULE(stl_binders, m) { ...@@ -192,6 +192,16 @@ TEST_SUBMODULE(stl_binders, m) {
py::bind_map<std::unordered_map<std::string, double const>>(m, py::bind_map<std::unordered_map<std::string, double const>>(m,
"UnorderedMapStringDoubleConst"); "UnorderedMapStringDoubleConst");
// test_map_view_types
py::bind_map<std::map<std::string, float>>(m, "MapStringFloat");
py::bind_map<std::unordered_map<std::string, float>>(m, "UnorderedMapStringFloat");
py::bind_map<std::map<std::pair<double, int>, int32_t>>(m, "MapPairDoubleIntInt32");
py::bind_map<std::map<std::pair<double, int>, int64_t>>(m, "MapPairDoubleIntInt64");
py::bind_map<std::map<int, py::object>>(m, "MapIntObject");
py::bind_map<std::map<std::string, py::object>>(m, "MapStringObject");
py::class_<E_nc>(m, "ENC").def(py::init<int>()).def_readwrite("value", &E_nc::value); py::class_<E_nc>(m, "ENC").def(py::init<int>()).def_readwrite("value", &E_nc::value);
// test_noncopyable_containers // test_noncopyable_containers
......
tests/test_stl_binders.py
...@@ -317,9 +317,9 @@ def test_map_view_types(): ...@@ -317,9 +317,9 @@ def test_map_view_types():
map_string_double_const = m.MapStringDoubleConst() map_string_double_const = m.MapStringDoubleConst()
unordered_map_string_double_const = m.UnorderedMapStringDoubleConst() unordered_map_string_double_const = m.UnorderedMapStringDoubleConst()
assert map_string_double.keys().__class__.__name__ == "KeysView[str]" assert map_string_double.keys().__class__.__name__ == "KeysView"
assert map_string_double.values().__class__.__name__ == "ValuesView[float]" assert map_string_double.values().__class__.__name__ == "ValuesView"
assert map_string_double.items().__class__.__name__ == "ItemsView[str, float]" assert map_string_double.items().__class__.__name__ == "ItemsView"
keys_type = type(map_string_double.keys()) keys_type = type(map_string_double.keys())
assert type(unordered_map_string_double.keys()) is keys_type assert type(unordered_map_string_double.keys()) is keys_type
...@@ -336,6 +336,30 @@ def test_map_view_types(): ...@@ -336,6 +336,30 @@ def test_map_view_types():
assert type(map_string_double_const.items()) is items_type assert type(map_string_double_const.items()) is items_type
assert type(unordered_map_string_double_const.items()) is items_type assert type(unordered_map_string_double_const.items()) is items_type
map_string_float = m.MapStringFloat()
unordered_map_string_float = m.UnorderedMapStringFloat()
assert type(map_string_float.keys()) is keys_type
assert type(unordered_map_string_float.keys()) is keys_type
assert type(map_string_float.values()) is values_type
assert type(unordered_map_string_float.values()) is values_type
assert type(map_string_float.items()) is items_type
assert type(unordered_map_string_float.items()) is items_type
map_pair_double_int_int32 = m.MapPairDoubleIntInt32()
map_pair_double_int_int64 = m.MapPairDoubleIntInt64()
assert type(map_pair_double_int_int32.values()) is values_type
assert type(map_pair_double_int_int64.values()) is values_type
map_int_object = m.MapIntObject()
map_string_object = m.MapStringObject()
assert type(map_int_object.keys()) is keys_type
assert type(map_string_object.keys()) is keys_type
assert type(map_int_object.items()) is items_type
assert type(map_string_object.items()) is items_type
def test_recursive_vector(): def test_recursive_vector():
recursive_vector = m.RecursiveVector() recursive_vector = m.RecursiveVector()
......
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