From a382d906efda9b096c4e841ebcff83be85fa3e5c Mon Sep 17 00:00:00 2001 From: David Shah Date: Tue, 3 Jul 2018 10:55:32 +0200 Subject: python: Developing context wrappers for maps Signed-off-by: David Shah --- common/pybindings.cc | 6 ++--- common/pybindings.h | 7 ++++++ common/pycontainers.h | 64 +++++++++++++++++++++++++++++++++------------------ common/pywrappers.h | 19 +++++++++++++++ 4 files changed, 70 insertions(+), 26 deletions(-) (limited to 'common') diff --git a/common/pybindings.cc b/common/pybindings.cc index f84d21f5..b15a6c79 100644 --- a/common/pybindings.cc +++ b/common/pybindings.cc @@ -107,9 +107,9 @@ BOOST_PYTHON_MODULE(MODULE_NAME) // WRAP_MAP(decltype(CellInfo::ports), "IdPortMap"); // WRAP_MAP(decltype(CellInfo::pins), "IdIdMap"); - class_("BaseCtx", no_init) - .add_property("nets", make_getter(&Context::nets, return_internal_reference<>())) - .add_property("cells", make_getter(&Context::cells, return_internal_reference<>())); + class_("BaseCtx", no_init); + //.add_property("nets", make_getter(&Context::nets, return_internal_reference<>())) + //.add_property("cells", make_getter(&Context::cells, return_internal_reference<>())); // WRAP_MAP_UPTR(decltype(Context::nets), "IdNetMap"); // WRAP_MAP_UPTR(decltype(Context::cells), "IdCellMap"); diff --git a/common/pybindings.h b/common/pybindings.h index 852fb21f..c4d84442 100644 --- a/common/pybindings.h +++ b/common/pybindings.h @@ -72,6 +72,13 @@ template <> struct string_converter inline std::string to_str(Context *ctx, IdString id) { return id.str(ctx); } }; +template <> struct string_converter +{ + inline IdString from_str(Context *ctx, std::string name) { return ctx->id(name); } + + inline std::string to_str(Context *ctx, IdString id) { return id.str(ctx); } +}; + } // namespace PythonConversion NEXTPNR_NAMESPACE_END diff --git a/common/pycontainers.h b/common/pycontainers.h index 6870c3a4..845c2847 100644 --- a/common/pycontainers.h +++ b/common/pycontainers.h @@ -112,7 +112,7 @@ struct range_wrapper iterator_wrapper().wrap(iter_name); } - typedef iterator_wrapper iter_wrap; + typedef iterator_wrapper iter_wrap; }; #define WRAP_RANGE(t, conv) \ @@ -288,18 +288,20 @@ Special case of above for map key/values where value is a unique_ptr template struct map_pair_wrapper_uptr { typedef std::pair T; + typedef PythonConversion::ContextualWrapper wrapped_pair; typedef typename T::second_type::element_type V; struct pair_iterator_wrapper { - static object next(std::pair &iter) + static object next(std::pair &iter) { if (iter.second == 0) { iter.second++; - return object(iter.first.first); + return object(PythonConversion::string_converter().to_str( + iter.first.ctx, iter.first.base.first)); } else if (iter.second == 1) { iter.second++; - return object(iter.first.second.get()); + return object(PythonConversion::ContextualWrapper(iter.first.ctx, *iter.first.base.second.get())); } else { PyErr_SetString(PyExc_StopIteration, "End of range reached"); boost::python::throw_error_already_set(); @@ -311,32 +313,41 @@ template struct map_pair_wrapper_uptr static void wrap(const char *python_name) { - class_>(python_name, no_init).def("__next__", next); + class_>(python_name, no_init).def("__next__", next); } }; - static object get(T &x, int i) + static object get(wrapped_pair &x, int i) { if ((i >= 2) || (i < 0)) KeyError(); - return (i == 1) ? object(x.second.get()) : object(x.first); + return (i == 1) ? object(PythonConversion::ContextualWrapper(x.ctx, *x.base.second.get())) + : object(x.base.first); } - static int len(T &x) { return 2; } + static int len(wrapped_pair &x) { return 2; } - static std::pair iter(T &x) { return std::make_pair(boost::ref(x), 0); }; + static std::pair iter(wrapped_pair &x) { return std::make_pair(boost::ref(x), 0); }; - static V &second_getter(T &t) { return *t.second.get(); } + static std::string first_getter(wrapped_pair &t) + { + return PythonConversion::string_converter().to_str(t.ctx, t.base.first); + } + + static PythonConversion::ContextualWrapper second_getter(wrapped_pair &t) + { + return PythonConversion::ContextualWrapper(t.ctx, *t.base.second.get()); + } static void wrap(const char *pair_name, const char *iter_name) { pair_iterator_wrapper::wrap(iter_name); - class_(pair_name, no_init) + class_(pair_name, no_init) .def("__iter__", iter) .def("__len__", len) .def("__getitem__", get) - .def_readonly("first", &T::first) - .add_property("second", make_function(second_getter, return_internal_reference<>())); + .add_property("first", first_getter) + .add_property("second", second_getter); } }; @@ -348,22 +359,29 @@ template struct map_wrapper_uptr { typedef typename std::remove_cv::type>::type K; typedef typename T::mapped_type::pointer V; + typedef typename T::mapped_type::element_type &Vr; typedef typename T::value_type KV; + typedef typename PythonConversion::ContextualWrapper wrapped_map; - static V get(T &x, K const &i) + static PythonConversion::ContextualWrapper get(wrapped_map &x, std::string const &i) { - if (x.find(i) != x.end()) - return x.at(i).get(); + K k = PythonConversion::string_converter().from_str(x.ctx, i); + if (x.base.find(k) != x.base.end()) + return PythonConversion::ContextualWrapper(x.ctx, *x.base.at(k).get()); KeyError(); std::terminate(); } - static void set(T &x, K const &i, V const &v) { x[i] = typename T::mapped_type(v); } + static void set(wrapped_map &x, std::string const &i, V const &v) + { + x.base[PythonConversion::string_converter().from_str(x.ctx, i)] = typename T::mapped_type(v); + } - static void del(T const &x, K const &i) + static void del(T const &x, std::string const &i) { - if (x.find(i) != x.end()) - x.erase(i); + K k = PythonConversion::string_converter().from_str(x.ctx, i); + if (x.base.find(k) != x.base.end()) + x.base.erase(k); else KeyError(); std::terminate(); @@ -372,12 +390,12 @@ template struct map_wrapper_uptr static void wrap(const char *map_name, const char *kv_name, const char *kv_iter_name, const char *iter_name) { map_pair_wrapper_uptr::wrap(kv_name, kv_iter_name); - typedef range_wrapper> rw; + typedef range_wrapper, PythonConversion::wrap_context> rw; typename rw::iter_wrap().wrap(iter_name); - class_(map_name, no_init) + class_(map_name, no_init) .def("__iter__", rw::iter) .def("__len__", &T::size) - .def("__getitem__", get, return_internal_reference<>()) + .def("__getitem__", get) .def("__setitem__", set, with_custodian_and_ward<1, 2>()); } }; diff --git a/common/pywrappers.h b/common/pywrappers.h index 55d70e42..125308e3 100644 --- a/common/pywrappers.h +++ b/common/pywrappers.h @@ -150,6 +150,25 @@ template static void def_wrap(WrapCls cls_, const char *name) { cls_.def(name, wrapped_fn); } }; +// Wrapped getter +template struct readonly_wrapper +{ + using class_type = typename WrapIfNotContext::maybe_wrapped_t; + using conv_val_type = typename v_conv::ret_type; + + static conv_val_type wrapped_getter(class_type &cls) + { + Context *ctx = get_ctx(cls); + Class &base = get_base(cls); + return v_conv()(ctx, (base.*mem)); + } + + template static void def_wrap(WrapCls cls_, const char *name) + { + cls_.add_property(name, wrapped_getter); + } +}; + } // namespace PythonConversion NEXTPNR_NAMESPACE_END -- cgit v1.2.3