Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 1 | /* |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 2 | pybind11/pybind11.h: Main header file of the C++11 python binding generator library |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 3 | |
| 4 | Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch> |
| 5 | |
| 6 | All rights reserved. Use of this source code is governed by a |
| 7 | BSD-style license that can be found in the LICENSE file. |
| 8 | */ |
| 9 | |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 10 | #pragma once |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 11 | |
| 12 | #if defined(_MSC_VER) |
| 13 | #pragma warning(push) |
| 14 | #pragma warning(disable: 4127) // warning C4127: Conditional expression is constant |
| 15 | #pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning) |
| 16 | #pragma warning(disable: 4996) // warning C4996: The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name |
| 17 | #pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter |
| 18 | #pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted |
Wenzel Jakob | cd5cda7 | 2015-08-03 12:17:54 +0200 | [diff] [blame] | 19 | #elif defined(__GNUG__) and !defined(__clang__) |
Wenzel Jakob | 281aa0e | 2015-07-30 15:29:00 +0200 | [diff] [blame] | 20 | #pragma GCC diagnostic push |
| 21 | #pragma GCC diagnostic ignored "-Wunused-but-set-parameter" |
| 22 | #pragma GCC diagnostic ignored "-Wunused-but-set-variable" |
| 23 | #pragma GCC diagnostic ignored "-Wmissing-field-initializers" |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 24 | #endif |
| 25 | |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 26 | #include "cast.h" |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 27 | |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 28 | NAMESPACE_BEGIN(pybind11) |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 29 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 30 | template <typename T> struct arg_t; |
| 31 | |
| 32 | /// Annotation for keyword arguments |
| 33 | struct arg { |
| 34 | arg(const char *name) : name(name) { } |
Wenzel Jakob | 5428930 | 2015-10-26 20:10:24 +0100 | [diff] [blame] | 35 | template <typename T> arg_t<T> operator=(const T &value); |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 36 | const char *name; |
| 37 | }; |
| 38 | |
| 39 | /// Annotation for keyword arguments with default values |
| 40 | template <typename T> struct arg_t : public arg { |
| 41 | arg_t(const char *name, const T &value) : arg(name), value(value) { } |
| 42 | T value; |
| 43 | }; |
Wenzel Jakob | 5428930 | 2015-10-26 20:10:24 +0100 | [diff] [blame] | 44 | template <typename T> arg_t<T> arg::operator=(const T &value) { return arg_t<T>(name, value); } |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 45 | |
| 46 | /// Annotation for methods |
Wenzel Jakob | 5428930 | 2015-10-26 20:10:24 +0100 | [diff] [blame] | 47 | struct is_method { PyObject *class_; is_method(object *o) : class_(o->ptr()) { } }; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 48 | |
| 49 | /// Annotation for documentation |
| 50 | struct doc { const char *value; doc(const char *value) : value(value) { } }; |
| 51 | |
| 52 | /// Annotation for function names |
| 53 | struct name { const char *value; name(const char *value) : value(value) { } }; |
| 54 | |
| 55 | /// Annotation for function siblings |
| 56 | struct sibling { PyObject *value; sibling(handle value) : value(value.ptr()) { } }; |
| 57 | |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 58 | /// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 59 | class cpp_function : public function { |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 60 | private: |
| 61 | /// Chained list of function entries for overloading |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 62 | struct function_entry { |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 63 | const char *name = nullptr; |
Wenzel Jakob | 2b0339f | 2015-09-01 21:38:07 +0200 | [diff] [blame] | 64 | PyObject * (*impl) (function_entry *, PyObject *, PyObject *, PyObject *) = nullptr; |
| 65 | PyMethodDef *def = nullptr; |
Wenzel Jakob | 281aa0e | 2015-07-30 15:29:00 +0200 | [diff] [blame] | 66 | void *data = nullptr; |
Wenzel Jakob | 5428930 | 2015-10-26 20:10:24 +0100 | [diff] [blame] | 67 | void (*free) (void *ptr) = nullptr; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 68 | bool is_constructor = false, is_method = false; |
| 69 | short keywords = 0; |
| 70 | return_value_policy policy = return_value_policy::automatic; |
| 71 | std::string signature; |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 72 | PyObject *class_ = nullptr; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 73 | PyObject *sibling = nullptr; |
| 74 | const char *doc = nullptr; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 75 | function_entry *next = nullptr; |
| 76 | }; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 77 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 78 | function_entry *m_entry; |
| 79 | |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 80 | /// Picks a suitable return value converter from cast.h |
| 81 | template <typename T> using return_value_caster = |
| 82 | detail::type_caster<typename std::conditional< |
| 83 | std::is_void<T>::value, detail::void_type, typename detail::decay<T>::type>::type>; |
| 84 | |
| 85 | /// Picks a suitable argument value converter from cast.h |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 86 | template <typename... T> using arg_value_caster = |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 87 | detail::type_caster<typename std::tuple<T...>>; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 88 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 89 | template <typename... T> static void process_extras(const std::tuple<T...> &args, |
| 90 | function_entry *entry, const char **kw, const char **def) { |
| 91 | process_extras(args, entry, kw, def, typename detail::make_index_sequence<sizeof...(T)>::type()); |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 92 | } |
| 93 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 94 | template <typename... T, size_t ... Index> static void process_extras(const std::tuple<T...> &args, |
| 95 | function_entry *entry, const char **kw, const char **def, detail::index_sequence<Index...>) { |
| 96 | int unused[] = { 0, (process_extra(std::get<Index>(args), entry, kw, def), 0)... }; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 97 | (void) unused; |
| 98 | } |
| 99 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 100 | template <typename... T> static void process_extras(const std::tuple<T...> &args, |
| 101 | PyObject *pyArgs, PyObject *kwargs, bool is_method) { |
| 102 | process_extras(args, pyArgs, kwargs, is_method, typename detail::make_index_sequence<sizeof...(T)>::type()); |
| 103 | } |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 104 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 105 | template <typename... T, size_t... Index> static void process_extras(const std::tuple<T...> &args, |
| 106 | PyObject *pyArgs, PyObject *kwargs, bool is_method, detail::index_sequence<Index...>) { |
| 107 | int index = is_method ? 1 : 0; |
| 108 | int unused[] = { 0, (process_extra(std::get<Index>(args), index, pyArgs, kwargs), 0)... }; |
Wenzel Jakob | efd9e98 | 2015-08-04 18:53:18 +0200 | [diff] [blame] | 109 | (void) unused; (void) index; |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 110 | } |
| 111 | |
| 112 | static void process_extra(const char *doc, function_entry *entry, const char **, const char **) { entry->doc = doc; } |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 113 | static void process_extra(const pybind11::doc &d, function_entry *entry, const char **, const char **) { entry->doc = d.value; } |
| 114 | static void process_extra(const pybind11::name &n, function_entry *entry, const char **, const char **) { entry->name = n.value; } |
| 115 | static void process_extra(const pybind11::arg &a, function_entry *entry, const char **kw, const char **) { |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 116 | if (entry->is_method && entry->keywords == 0) |
| 117 | kw[entry->keywords++] = "self"; |
| 118 | kw[entry->keywords++] = a.name; |
| 119 | } |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 120 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 121 | template <typename T> |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 122 | static void process_extra(const pybind11::arg_t<T> &a, function_entry *entry, const char **kw, const char **def) { |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 123 | if (entry->is_method && entry->keywords == 0) |
| 124 | kw[entry->keywords++] = "self"; |
| 125 | kw[entry->keywords] = a.name; |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 126 | def[entry->keywords++] = strdup(detail::to_string(a.value).c_str()); |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 127 | } |
| 128 | |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 129 | static void process_extra(const pybind11::is_method &m, function_entry *entry, const char **, const char **) { |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 130 | entry->is_method = true; |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 131 | entry->class_ = m.class_; |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 132 | } |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 133 | static void process_extra(const pybind11::return_value_policy p, function_entry *entry, const char **, const char **) { entry->policy = p; } |
| 134 | static void process_extra(pybind11::sibling s, function_entry *entry, const char **, const char **) { entry->sibling = s.value; } |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 135 | |
| 136 | template <typename T> static void process_extra(T, int &, PyObject *, PyObject *) { } |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 137 | static void process_extra(const pybind11::arg &a, int &index, PyObject *args, PyObject *kwargs) { |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 138 | if (kwargs) { |
| 139 | if (PyTuple_GET_ITEM(args, index) != nullptr) { |
| 140 | index++; |
| 141 | return; |
| 142 | } |
| 143 | PyObject *value = PyDict_GetItemString(kwargs, a.name); |
| 144 | if (value) { |
| 145 | Py_INCREF(value); |
| 146 | PyTuple_SetItem(args, index, value); |
| 147 | } |
| 148 | } |
| 149 | index++; |
| 150 | } |
| 151 | template <typename T> |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 152 | static void process_extra(const pybind11::arg_t<T> &a, int &index, PyObject *args, PyObject *kwargs) { |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 153 | if (PyTuple_GET_ITEM(args, index) != nullptr) { |
| 154 | index++; |
| 155 | return; |
| 156 | } |
| 157 | PyObject *value = nullptr; |
| 158 | if (kwargs) |
| 159 | value = PyDict_GetItemString(kwargs, a.name); |
| 160 | if (value) { |
| 161 | Py_INCREF(value); |
| 162 | } else { |
| 163 | value = detail::type_caster<typename detail::decay<T>::type>::cast( |
| 164 | a.value, return_value_policy::automatic, nullptr); |
| 165 | } |
| 166 | PyTuple_SetItem(args, index, value); |
| 167 | index++; |
| 168 | } |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 169 | public: |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 170 | cpp_function() { } |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 171 | |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 172 | /// Vanilla function pointers |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 173 | template <typename Return, typename... Arg, typename... Extra> |
| 174 | cpp_function(Return (*f)(Arg...), Extra&&... extra) { |
| 175 | struct capture { |
| 176 | Return (*f)(Arg...); |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 177 | std::tuple<Extra...> extras; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 178 | }; |
| 179 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 180 | m_entry = new function_entry(); |
| 181 | m_entry->data = new capture { f, std::tuple<Extra...>(std::forward<Extra>(extra)...) }; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 182 | |
| 183 | typedef arg_value_caster<Arg...> cast_in; |
| 184 | typedef return_value_caster<Return> cast_out; |
| 185 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 186 | m_entry->impl = [](function_entry *entry, PyObject *pyArgs, PyObject *kwargs, PyObject *parent) -> PyObject * { |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 187 | capture *data = (capture *) entry->data; |
| 188 | process_extras(data->extras, pyArgs, kwargs, entry->is_method); |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 189 | cast_in args; |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 190 | if (!args.load(pyArgs, true)) |
Wenzel Jakob | b3ee3ea | 2015-10-04 15:17:34 +0200 | [diff] [blame] | 191 | return (PyObject *) 1; /* Special return code: try next overload */ |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 192 | return cast_out::cast(args.template call<Return>(data->f), entry->policy, parent); |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 193 | }; |
| 194 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 195 | const int N = sizeof...(Extra) > sizeof...(Arg) ? sizeof...(Extra) : sizeof...(Arg); |
| 196 | std::array<const char *, N> kw{}, def{}; |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 197 | process_extras(((capture *) m_entry->data)->extras, m_entry, kw.data(), def.data()); |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 198 | |
Wenzel Jakob | 328aa14 | 2015-08-26 17:23:23 +0200 | [diff] [blame] | 199 | detail::descr d = cast_in::name(kw.data(), def.data()); |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 200 | d += " -> "; |
Wenzel Jakob | 328aa14 | 2015-08-26 17:23:23 +0200 | [diff] [blame] | 201 | d += std::move(cast_out::name()); |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 202 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 203 | initialize(d, sizeof...(Arg)); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 204 | } |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 205 | |
| 206 | /// Delegating helper constructor to deal with lambda functions |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 207 | template <typename Func, typename... Extra> cpp_function(Func &&f, Extra&&... extra) { |
| 208 | initialize(std::forward<Func>(f), |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 209 | (typename detail::remove_class<decltype( |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 210 | &std::remove_reference<Func>::type::operator())>::type *) nullptr, |
| 211 | std::forward<Extra>(extra)...); |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 212 | } |
| 213 | |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 214 | /// Class methods (non-const) |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 215 | template <typename Return, typename Class, typename... Arg, typename... Extra> cpp_function( |
| 216 | Return (Class::*f)(Arg...), Extra&&... extra) { |
| 217 | initialize([f](Class *c, Arg... args) -> Return { return (c->*f)(args...); }, |
| 218 | (Return (*) (Class *, Arg...)) nullptr, std::forward<Extra>(extra)...); |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | /// Class methods (const) |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 222 | template <typename Return, typename Class, typename... Arg, typename... Extra> cpp_function( |
| 223 | Return (Class::*f)(Arg...) const, Extra&&... extra) { |
| 224 | initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(args...); }, |
| 225 | (Return (*)(const Class *, Arg ...)) nullptr, std::forward<Extra>(extra)...); |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 226 | } |
| 227 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 228 | /// Return the function name |
| 229 | const char *name() const { return m_entry->name; } |
| 230 | |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 231 | private: |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 232 | /// Functors, lambda functions, etc. |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 233 | template <typename Func, typename Return, typename... Arg, typename... Extra> |
| 234 | void initialize(Func &&f, Return (*)(Arg...), Extra&&... extra) { |
| 235 | struct capture { |
| 236 | typename std::remove_reference<Func>::type f; |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 237 | std::tuple<Extra...> extras; |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 238 | }; |
| 239 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 240 | m_entry = new function_entry(); |
| 241 | m_entry->data = new capture { std::forward<Func>(f), std::tuple<Extra...>(std::forward<Extra>(extra)...) }; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 242 | |
Wenzel Jakob | 19208fe | 2015-10-13 17:37:25 +0200 | [diff] [blame] | 243 | if (!std::is_trivially_destructible<Func>::value) |
| 244 | m_entry->free = [](void *ptr) { delete (capture *) ptr; }; |
| 245 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 246 | typedef arg_value_caster<Arg...> cast_in; |
| 247 | typedef return_value_caster<Return> cast_out; |
| 248 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 249 | m_entry->impl = [](function_entry *entry, PyObject *pyArgs, PyObject *kwargs, PyObject *parent) -> PyObject *{ |
Wenzel Jakob | b3ee3ea | 2015-10-04 15:17:34 +0200 | [diff] [blame] | 250 | capture *data = (capture *) entry->data; |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 251 | process_extras(data->extras, pyArgs, kwargs, entry->is_method); |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 252 | cast_in args; |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 253 | if (!args.load(pyArgs, true)) |
Wenzel Jakob | b3ee3ea | 2015-10-04 15:17:34 +0200 | [diff] [blame] | 254 | return (PyObject *) 1; /* Special return code: try next overload */ |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 255 | return cast_out::cast(args.template call<Return>(data->f), entry->policy, parent); |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 256 | }; |
| 257 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 258 | const int N = sizeof...(Extra) > sizeof...(Arg) ? sizeof...(Extra) : sizeof...(Arg); |
| 259 | std::array<const char *, N> kw{}, def{}; |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 260 | process_extras(((capture *) m_entry->data)->extras, m_entry, kw.data(), def.data()); |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 261 | |
Wenzel Jakob | 328aa14 | 2015-08-26 17:23:23 +0200 | [diff] [blame] | 262 | detail::descr d = cast_in::name(kw.data(), def.data()); |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 263 | d += " -> "; |
Wenzel Jakob | 328aa14 | 2015-08-26 17:23:23 +0200 | [diff] [blame] | 264 | d += std::move(cast_out::name()); |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 265 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 266 | initialize(d, sizeof...(Arg)); |
Wenzel Jakob | d4258ba | 2015-07-26 16:33:49 +0200 | [diff] [blame] | 267 | } |
| 268 | |
Wenzel Jakob | 5257330 | 2015-09-14 16:38:47 +0200 | [diff] [blame] | 269 | static PyObject *dispatcher(PyObject *self, PyObject *args, PyObject *kwargs) { |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 270 | function_entry *overloads = (function_entry *) PyCapsule_GetPointer(self, nullptr); |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 271 | int nargs = (int) PyTuple_Size(args); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 272 | PyObject *result = nullptr; |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 273 | PyObject *parent = nargs > 0 ? PyTuple_GetItem(args, 0) : nullptr; |
Wenzel Jakob | b3ee3ea | 2015-10-04 15:17:34 +0200 | [diff] [blame] | 274 | function_entry *it = overloads; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 275 | try { |
Wenzel Jakob | b3ee3ea | 2015-10-04 15:17:34 +0200 | [diff] [blame] | 276 | for (; it != nullptr; it = it->next) { |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 277 | PyObject *args_ = args; |
| 278 | |
Wenzel Jakob | 5257330 | 2015-09-14 16:38:47 +0200 | [diff] [blame] | 279 | if (it->keywords != 0 && nargs < it->keywords) { |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 280 | args_ = PyTuple_New(it->keywords); |
| 281 | for (int i=0; i<nargs; ++i) { |
| 282 | PyObject *item = PyTuple_GET_ITEM(args, i); |
| 283 | Py_INCREF(item); |
| 284 | PyTuple_SET_ITEM(args_, i, item); |
| 285 | } |
| 286 | } |
| 287 | |
| 288 | result = it->impl(it, args_, kwargs, parent); |
| 289 | |
| 290 | if (args_ != args) { |
| 291 | Py_DECREF(args_); |
| 292 | } |
| 293 | |
Wenzel Jakob | b3ee3ea | 2015-10-04 15:17:34 +0200 | [diff] [blame] | 294 | if (result != (PyObject *) 1) |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 295 | break; |
| 296 | } |
Jonas Adler | 2b9fdbe | 2015-12-15 11:27:19 +0100 | [diff] [blame] | 297 | } catch (const error_already_set &) { return nullptr; |
| 298 | } catch (const index_error &e) { PyErr_SetString(PyExc_IndexError, e.what()); return nullptr; |
| 299 | } catch (const stop_iteration &e) { PyErr_SetString(PyExc_StopIteration, e.what()); return nullptr; |
| 300 | } catch (const std::bad_alloc &e) { PyErr_SetString(PyExc_MemoryError, e.what()); return nullptr; |
| 301 | } catch (const std::domain_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return nullptr; |
| 302 | } catch (const std::invalid_argument &e) { PyErr_SetString(PyExc_ValueError, e.what()); return nullptr; |
| 303 | } catch (const std::length_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return nullptr; |
| 304 | } catch (const std::out_of_range &e) { PyErr_SetString(PyExc_IndexError, e.what()); return nullptr; |
| 305 | } catch (const std::range_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return nullptr; |
| 306 | } catch (const std::exception &e) { PyErr_SetString(PyExc_RuntimeError, e.what()); return nullptr; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 307 | } catch (...) { |
| 308 | PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!"); |
| 309 | return nullptr; |
| 310 | } |
Wenzel Jakob | b3ee3ea | 2015-10-04 15:17:34 +0200 | [diff] [blame] | 311 | if (result == (PyObject *) 1) { |
| 312 | std::string msg = "Incompatible function arguments. The " |
| 313 | "following argument types are supported:\n"; |
| 314 | int ctr = 0; |
Wenzel Jakob | d2a902b | 2015-10-04 20:24:20 +0200 | [diff] [blame] | 315 | for (function_entry *it2 = overloads; it2 != nullptr; it2 = it2->next) { |
Wenzel Jakob | b3ee3ea | 2015-10-04 15:17:34 +0200 | [diff] [blame] | 316 | msg += " "+ std::to_string(++ctr) + ". "; |
Wenzel Jakob | d2a902b | 2015-10-04 20:24:20 +0200 | [diff] [blame] | 317 | msg += it2->signature; |
Wenzel Jakob | b3ee3ea | 2015-10-04 15:17:34 +0200 | [diff] [blame] | 318 | msg += "\n"; |
| 319 | } |
| 320 | PyErr_SetString(PyExc_TypeError, msg.c_str()); |
| 321 | return nullptr; |
| 322 | } else if (result == nullptr) { |
| 323 | std::string msg = "Unable to convert function return value to a " |
| 324 | "Python type! The signature was\n\t"; |
| 325 | msg += it->signature; |
| 326 | PyErr_SetString(PyExc_TypeError, msg.c_str()); |
| 327 | return nullptr; |
| 328 | } else { |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 329 | if (overloads->is_constructor) { |
| 330 | PyObject *inst = PyTuple_GetItem(args, 0); |
| 331 | const detail::type_info *type_info = |
| 332 | capsule(PyObject_GetAttrString((PyObject *) Py_TYPE(inst), |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 333 | const_cast<char *>("__pybind11__")), false); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 334 | type_info->init_holder(inst); |
| 335 | } |
| 336 | return result; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 337 | } |
| 338 | } |
| 339 | |
Wenzel Jakob | 281aa0e | 2015-07-30 15:29:00 +0200 | [diff] [blame] | 340 | static void destruct(function_entry *entry) { |
| 341 | while (entry) { |
| 342 | delete entry->def; |
Wenzel Jakob | 19208fe | 2015-10-13 17:37:25 +0200 | [diff] [blame] | 343 | if (entry->free) |
| 344 | entry->free(entry->data); |
| 345 | else |
| 346 | operator delete(entry->data); |
Wenzel Jakob | 281aa0e | 2015-07-30 15:29:00 +0200 | [diff] [blame] | 347 | function_entry *next = entry->next; |
| 348 | delete entry; |
| 349 | entry = next; |
| 350 | } |
| 351 | } |
| 352 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 353 | void initialize(const detail::descr &descr, int args) { |
| 354 | if (m_entry->name == nullptr) |
| 355 | m_entry->name = ""; |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 356 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 357 | #if PY_MAJOR_VERSION < 3 |
| 358 | if (strcmp(m_entry->name, "__next__") == 0) |
| 359 | m_entry->name = "next"; |
| 360 | #endif |
| 361 | |
| 362 | if (m_entry->keywords != 0 && m_entry->keywords != args) |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 363 | throw std::runtime_error( |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 364 | "cpp_function(): function \"" + std::string(m_entry->name) + "\" takes " + |
| 365 | std::to_string(args) + " arguments, but " + std::to_string(m_entry->keywords) + |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 366 | " pybind11::arg entries were specified!"); |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 367 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 368 | m_entry->is_constructor = !strcmp(m_entry->name, "__init__"); |
| 369 | m_entry->signature = descr.str(); |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 370 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 371 | #if PY_MAJOR_VERSION < 3 |
| 372 | if (m_entry->sibling && PyMethod_Check(m_entry->sibling)) |
| 373 | m_entry->sibling = PyMethod_GET_FUNCTION(m_entry->sibling); |
| 374 | #endif |
| 375 | |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 376 | function_entry *s_entry = nullptr, *entry = m_entry; |
| 377 | if (m_entry->sibling && PyCFunction_Check(m_entry->sibling)) { |
| 378 | capsule entry_capsule(PyCFunction_GetSelf(m_entry->sibling), true); |
| 379 | s_entry = (function_entry *) entry_capsule; |
| 380 | if (s_entry->class_ != m_entry->class_) |
| 381 | s_entry = nullptr; /* Method override */ |
| 382 | } |
| 383 | |
| 384 | if (!s_entry) { |
| 385 | m_entry->def = new PyMethodDef(); |
| 386 | memset(m_entry->def, 0, sizeof(PyMethodDef)); |
| 387 | m_entry->def->ml_name = m_entry->name; |
| 388 | m_entry->def->ml_meth = reinterpret_cast<PyCFunction>(*dispatcher); |
| 389 | m_entry->def->ml_flags = METH_VARARGS | METH_KEYWORDS; |
| 390 | capsule entry_capsule(m_entry, [](PyObject *o) { destruct((function_entry *) PyCapsule_GetPointer(o, nullptr)); }); |
| 391 | m_ptr = PyCFunction_New(m_entry->def, entry_capsule.ptr()); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 392 | if (!m_ptr) |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 393 | throw std::runtime_error("cpp_function::cpp_function(): Could not allocate function object"); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 394 | } else { |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 395 | m_ptr = m_entry->sibling; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 396 | inc_ref(); |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 397 | entry = s_entry; |
| 398 | while (s_entry->next) |
| 399 | s_entry = s_entry->next; |
| 400 | s_entry->next = m_entry; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 401 | } |
Wenzel Jakob | 281aa0e | 2015-07-30 15:29:00 +0200 | [diff] [blame] | 402 | |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 403 | std::string signatures; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 404 | int index = 0; |
| 405 | function_entry *it = entry; |
| 406 | while (it) { /* Create pydoc it */ |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 407 | if (s_entry) |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 408 | signatures += std::to_string(++index) + ". "; |
| 409 | signatures += "Signature : " + std::string(it->signature) + "\n"; |
| 410 | if (it->doc && strlen(it->doc) > 0) |
| 411 | signatures += "\n" + std::string(it->doc) + "\n"; |
| 412 | if (it->next) |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 413 | signatures += "\n"; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 414 | it = it->next; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 415 | } |
| 416 | PyCFunctionObject *func = (PyCFunctionObject *) m_ptr; |
| 417 | if (func->m_ml->ml_doc) |
| 418 | std::free((char *) func->m_ml->ml_doc); |
| 419 | func->m_ml->ml_doc = strdup(signatures.c_str()); |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 420 | if (entry->is_method) { |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 421 | #if PY_MAJOR_VERSION >= 3 |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 422 | m_ptr = PyInstanceMethod_New(m_ptr); |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 423 | #else |
| 424 | m_ptr = PyMethod_New(m_ptr, nullptr, entry->class_); |
| 425 | #endif |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 426 | if (!m_ptr) |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 427 | throw std::runtime_error("cpp_function::cpp_function(): Could not allocate instance method object"); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 428 | Py_DECREF(func); |
| 429 | } |
| 430 | } |
| 431 | }; |
| 432 | |
| 433 | class module : public object { |
| 434 | public: |
Wenzel Jakob | b1b7140 | 2015-10-18 16:48:30 +0200 | [diff] [blame] | 435 | PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check) |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 436 | |
| 437 | module(const char *name, const char *doc = nullptr) { |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 438 | #if PY_MAJOR_VERSION >= 3 |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 439 | PyModuleDef *def = new PyModuleDef(); |
| 440 | memset(def, 0, sizeof(PyModuleDef)); |
| 441 | def->m_name = name; |
| 442 | def->m_doc = doc; |
| 443 | def->m_size = -1; |
| 444 | Py_INCREF(def); |
| 445 | m_ptr = PyModule_Create(def); |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 446 | #else |
| 447 | m_ptr = Py_InitModule3(name, nullptr, doc); |
| 448 | #endif |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 449 | if (m_ptr == nullptr) |
| 450 | throw std::runtime_error("Internal error in module::module()"); |
| 451 | inc_ref(); |
| 452 | } |
| 453 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 454 | template <typename Func, typename... Extra> |
| 455 | module &def(const char *name_, Func &&f, Extra&& ... extra) { |
| 456 | cpp_function func(std::forward<Func>(f), name(name_), |
| 457 | sibling((handle) attr(name_)), std::forward<Extra>(extra)...); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 458 | func.inc_ref(); /* The following line steals a reference to 'func' */ |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 459 | PyModule_AddObject(ptr(), name_, func.ptr()); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 460 | return *this; |
| 461 | } |
| 462 | |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 463 | module def_submodule(const char *name, const char *doc = nullptr) { |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 464 | std::string full_name = std::string(PyModule_GetName(m_ptr)) |
| 465 | + std::string(".") + std::string(name); |
| 466 | module result(PyImport_AddModule(full_name.c_str()), true); |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 467 | if (doc) |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 468 | result.attr("__doc__") = pybind11::str(doc); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 469 | attr(name) = result; |
| 470 | return result; |
| 471 | } |
Wenzel Jakob | db028d6 | 2015-10-13 23:44:25 +0200 | [diff] [blame] | 472 | |
| 473 | static module import(const char *name) { |
Wenzel Jakob | dd57a34 | 2015-12-26 14:04:52 +0100 | [diff] [blame^] | 474 | PyObject *obj = PyImport_ImportModule(name); |
| 475 | if (!obj) |
| 476 | throw std::runtime_error("Module \"" + std::string(name) + "\" not found!"); |
| 477 | return module(obj, false); |
Wenzel Jakob | db028d6 | 2015-10-13 23:44:25 +0200 | [diff] [blame] | 478 | } |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 479 | }; |
| 480 | |
| 481 | NAMESPACE_BEGIN(detail) |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 482 | /// Basic support for creating new Python heap types |
| 483 | class custom_type : public object { |
| 484 | public: |
Wenzel Jakob | b1b7140 | 2015-10-18 16:48:30 +0200 | [diff] [blame] | 485 | PYBIND11_OBJECT_DEFAULT(custom_type, object, PyType_Check) |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 486 | |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 487 | custom_type(object &scope, const char *name_, const std::type_info *tinfo, |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 488 | size_t type_size, size_t instance_size, |
| 489 | void (*init_holder)(PyObject *), const destructor &dealloc, |
| 490 | PyObject *parent, const char *doc) { |
| 491 | PyHeapTypeObject *type = (PyHeapTypeObject*) PyType_Type.tp_alloc(&PyType_Type, 0); |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 492 | #if PY_MAJOR_VERSION >= 3 |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 493 | PyObject *name = PyUnicode_FromString(name_); |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 494 | #else |
| 495 | PyObject *name = PyString_FromString(name_); |
| 496 | #endif |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 497 | if (type == nullptr || name == nullptr) |
| 498 | throw std::runtime_error("Internal error in custom_type::custom_type()"); |
| 499 | Py_INCREF(name); |
| 500 | std::string full_name(name_); |
| 501 | |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 502 | pybind11::str scope_name = (object) scope.attr("__name__"), |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 503 | module_name = (object) scope.attr("__module__"); |
| 504 | |
| 505 | if (scope_name.check()) |
| 506 | full_name = std::string(scope_name) + "." + full_name; |
| 507 | if (module_name.check()) |
| 508 | full_name = std::string(module_name) + "." + full_name; |
| 509 | |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 510 | type->ht_name = name; |
| 511 | #if PY_MAJOR_VERSION >= 3 |
| 512 | type->ht_qualname = name; |
| 513 | #endif |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 514 | type->ht_type.tp_name = strdup(full_name.c_str()); |
| 515 | type->ht_type.tp_basicsize = instance_size; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 516 | type->ht_type.tp_init = (initproc) init; |
| 517 | type->ht_type.tp_new = (newfunc) new_instance; |
| 518 | type->ht_type.tp_dealloc = dealloc; |
| 519 | type->ht_type.tp_flags |= |
| 520 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE; |
| 521 | type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC; |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 522 | #if PY_MAJOR_VERSION < 3 |
| 523 | type->ht_type.tp_flags |= Py_TPFLAGS_CHECKTYPES; |
| 524 | #endif |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 525 | type->ht_type.tp_as_number = &type->as_number; |
| 526 | type->ht_type.tp_as_sequence = &type->as_sequence; |
| 527 | type->ht_type.tp_as_mapping = &type->as_mapping; |
| 528 | type->ht_type.tp_base = (PyTypeObject *) parent; |
Wenzel Jakob | 5116b02 | 2015-09-05 02:09:17 +0200 | [diff] [blame] | 529 | if (doc) { |
| 530 | size_t size = strlen(doc)+1; |
| 531 | type->ht_type.tp_doc = (char *)PyObject_MALLOC(size); |
| 532 | memcpy((void *) type->ht_type.tp_doc, doc, size); |
| 533 | } |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 534 | Py_XINCREF(parent); |
| 535 | |
| 536 | if (PyType_Ready(&type->ht_type) < 0) |
| 537 | throw std::runtime_error("Internal error in custom_type::custom_type()"); |
| 538 | m_ptr = (PyObject *) type; |
| 539 | |
| 540 | /* Needed by pydoc */ |
Wenzel Jakob | 04358b0 | 2015-10-01 16:45:28 +0200 | [diff] [blame] | 541 | attr("__module__") = scope_name; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 542 | |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 543 | auto &type_info = detail::get_internals().registered_types[tinfo]; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 544 | type_info.type = (PyTypeObject *) m_ptr; |
| 545 | type_info.type_size = type_size; |
| 546 | type_info.init_holder = init_holder; |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 547 | attr("__pybind11__") = capsule(&type_info); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 548 | |
| 549 | scope.attr(name) = *this; |
| 550 | } |
| 551 | |
| 552 | protected: |
| 553 | /* Allocate a metaclass on demand (for static properties) */ |
| 554 | handle metaclass() { |
| 555 | auto &ht_type = ((PyHeapTypeObject *) m_ptr)->ht_type; |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 556 | #if PY_MAJOR_VERSION >= 3 |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 557 | auto &ob_type = ht_type.ob_base.ob_base.ob_type; |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 558 | #else |
| 559 | auto &ob_type = ht_type.ob_type; |
| 560 | #endif |
| 561 | |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 562 | if (ob_type == &PyType_Type) { |
| 563 | std::string name_ = std::string(ht_type.tp_name) + "_meta"; |
| 564 | PyHeapTypeObject *type = (PyHeapTypeObject*) PyType_Type.tp_alloc(&PyType_Type, 0); |
| 565 | PyObject *name = PyUnicode_FromString(name_.c_str()); |
| 566 | if (type == nullptr || name == nullptr) |
| 567 | throw std::runtime_error("Internal error in custom_type::metaclass()"); |
| 568 | Py_INCREF(name); |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 569 | type->ht_name = name; |
| 570 | #if PY_MAJOR_VERSION >= 3 |
| 571 | type->ht_qualname = name; |
| 572 | #endif |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 573 | type->ht_type.tp_name = strdup(name_.c_str()); |
| 574 | type->ht_type.tp_base = &PyType_Type; |
| 575 | type->ht_type.tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE; |
| 576 | type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC; |
| 577 | if (PyType_Ready(&type->ht_type) < 0) |
| 578 | throw std::runtime_error("Internal error in custom_type::metaclass()"); |
| 579 | ob_type = (PyTypeObject *) type; |
| 580 | Py_INCREF(type); |
| 581 | } |
| 582 | return handle((PyObject *) ob_type); |
| 583 | } |
| 584 | |
| 585 | static int init(void *self, PyObject *, PyObject *) { |
| 586 | std::string msg = std::string(Py_TYPE(self)->tp_name) + ": No constructor defined!"; |
| 587 | PyErr_SetString(PyExc_TypeError, msg.c_str()); |
| 588 | return -1; |
| 589 | } |
| 590 | |
| 591 | static PyObject *new_instance(PyTypeObject *type, PyObject *, PyObject *) { |
| 592 | const detail::type_info *type_info = capsule( |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 593 | PyObject_GetAttrString((PyObject *) type, const_cast<char*>("__pybind11__")), false); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 594 | instance<void> *self = (instance<void> *) PyType_GenericAlloc(type, 0); |
| 595 | self->value = ::operator new(type_info->type_size); |
| 596 | self->owned = true; |
| 597 | self->parent = nullptr; |
| 598 | self->constructed = false; |
| 599 | detail::get_internals().registered_instances[self->value] = (PyObject *) self; |
| 600 | return (PyObject *) self; |
| 601 | } |
| 602 | |
| 603 | static void dealloc(instance<void> *self) { |
| 604 | if (self->value) { |
| 605 | bool dont_cache = self->parent && ((instance<void> *) self->parent)->value == self->value; |
| 606 | if (!dont_cache) { // avoid an issue with internal references matching their parent's address |
| 607 | auto ®istered_instances = detail::get_internals().registered_instances; |
| 608 | auto it = registered_instances.find(self->value); |
| 609 | if (it == registered_instances.end()) |
| 610 | throw std::runtime_error("Deallocating unregistered instance!"); |
| 611 | registered_instances.erase(it); |
| 612 | } |
| 613 | Py_XDECREF(self->parent); |
| 614 | } |
| 615 | Py_TYPE(self)->tp_free((PyObject*) self); |
| 616 | } |
| 617 | |
Wenzel Jakob | 43398a8 | 2015-07-28 16:12:20 +0200 | [diff] [blame] | 618 | void install_buffer_funcs( |
| 619 | buffer_info *(*get_buffer)(PyObject *, void *), |
| 620 | void *get_buffer_data) { |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 621 | PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr; |
| 622 | type->ht_type.tp_as_buffer = &type->as_buffer; |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 623 | #if PY_MAJOR_VERSION < 3 |
| 624 | type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER; |
| 625 | #endif |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 626 | type->as_buffer.bf_getbuffer = getbuffer; |
| 627 | type->as_buffer.bf_releasebuffer = releasebuffer; |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 628 | auto info = ((detail::type_info *) capsule(attr("__pybind11__"))); |
Wenzel Jakob | 43398a8 | 2015-07-28 16:12:20 +0200 | [diff] [blame] | 629 | info->get_buffer = get_buffer; |
| 630 | info->get_buffer_data = get_buffer_data; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 631 | } |
| 632 | |
| 633 | static int getbuffer(PyObject *obj, Py_buffer *view, int flags) { |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 634 | auto const &typeinfo = ((detail::type_info *) capsule(handle(obj).attr("__pybind11__"))); |
Wenzel Jakob | 43398a8 | 2015-07-28 16:12:20 +0200 | [diff] [blame] | 635 | |
| 636 | if (view == nullptr || obj == nullptr || !typeinfo || !typeinfo->get_buffer) { |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 637 | PyErr_SetString(PyExc_BufferError, "Internal error"); |
| 638 | return -1; |
| 639 | } |
| 640 | memset(view, 0, sizeof(Py_buffer)); |
Wenzel Jakob | 43398a8 | 2015-07-28 16:12:20 +0200 | [diff] [blame] | 641 | buffer_info *info = typeinfo->get_buffer(obj, typeinfo->get_buffer_data); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 642 | view->obj = obj; |
| 643 | view->ndim = 1; |
| 644 | view->internal = info; |
| 645 | view->buf = info->ptr; |
| 646 | view->itemsize = info->itemsize; |
| 647 | view->len = view->itemsize; |
| 648 | for (auto s : info->shape) |
| 649 | view->len *= s; |
| 650 | if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) |
| 651 | view->format = const_cast<char *>(info->format.c_str()); |
| 652 | if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) { |
| 653 | view->ndim = info->ndim; |
| 654 | view->strides = (Py_ssize_t *)&info->strides[0]; |
| 655 | view->shape = (Py_ssize_t *) &info->shape[0]; |
| 656 | } |
| 657 | Py_INCREF(view->obj); |
| 658 | return 0; |
| 659 | } |
| 660 | |
| 661 | static void releasebuffer(PyObject *, Py_buffer *view) { delete (buffer_info *) view->internal; } |
| 662 | }; |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 663 | |
| 664 | /* Forward declarations */ |
| 665 | enum op_id : int; |
| 666 | enum op_type : int; |
| 667 | struct undefined_t; |
| 668 | template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined_t> struct op_; |
| 669 | template <typename... Args> struct init; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 670 | NAMESPACE_END(detail) |
| 671 | |
| 672 | template <typename type, typename holder_type = std::unique_ptr<type>> class class_ : public detail::custom_type { |
| 673 | public: |
| 674 | typedef detail::instance<type, holder_type> instance_type; |
| 675 | |
Wenzel Jakob | b1b7140 | 2015-10-18 16:48:30 +0200 | [diff] [blame] | 676 | PYBIND11_OBJECT(class_, detail::custom_type, PyType_Check) |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 677 | |
| 678 | class_(object &scope, const char *name, const char *doc = nullptr) |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 679 | : detail::custom_type(scope, name, &typeid(type), sizeof(type), |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 680 | sizeof(instance_type), init_holder, dealloc, |
| 681 | nullptr, doc) { } |
| 682 | |
| 683 | class_(object &scope, const char *name, object &parent, |
| 684 | const char *doc = nullptr) |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 685 | : detail::custom_type(scope, name, &typeid(type), sizeof(type), |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 686 | sizeof(instance_type), init_holder, dealloc, |
| 687 | parent.ptr(), doc) { } |
| 688 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 689 | template <typename Func, typename... Extra> |
| 690 | class_ &def(const char *name_, Func&& f, Extra&&... extra) { |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 691 | cpp_function cf(std::forward<Func>(f), name(name_), |
| 692 | sibling(attr(name_)), is_method(this), |
| 693 | std::forward<Extra>(extra)...); |
| 694 | attr(cf.name()) = cf; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 695 | return *this; |
| 696 | } |
| 697 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 698 | template <typename Func, typename... Extra> class_ & |
| 699 | def_static(const char *name_, Func f, Extra&&... extra) { |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 700 | cpp_function cf(std::forward<Func>(f), name(name_), |
| 701 | sibling(attr(name_)), |
| 702 | std::forward<Extra>(extra)...); |
| 703 | attr(cf.name()) = cf; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 704 | return *this; |
| 705 | } |
| 706 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 707 | template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra> |
| 708 | class_ &def(const detail::op_<id, ot, L, R> &op, Extra&&... extra) { |
| 709 | op.template execute<type>(*this, std::forward<Extra>(extra)...); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 710 | return *this; |
| 711 | } |
| 712 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 713 | template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra> |
| 714 | class_ & def_cast(const detail::op_<id, ot, L, R> &op, Extra&&... extra) { |
| 715 | op.template execute_cast<type>(*this, std::forward<Extra>(extra)...); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 716 | return *this; |
| 717 | } |
| 718 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 719 | template <typename... Args, typename... Extra> |
| 720 | class_ &def(const detail::init<Args...> &init, Extra&&... extra) { |
| 721 | init.template execute<type>(*this, std::forward<Extra>(extra)...); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 722 | return *this; |
| 723 | } |
| 724 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 725 | template <typename Func> class_& def_buffer(Func &&func) { |
Wenzel Jakob | 43398a8 | 2015-07-28 16:12:20 +0200 | [diff] [blame] | 726 | struct capture { Func func; }; |
| 727 | capture *ptr = new capture { std::forward<Func>(func) }; |
| 728 | install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* { |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 729 | detail::type_caster<type> caster; |
| 730 | if (!caster.load(obj, false)) |
| 731 | return nullptr; |
Wenzel Jakob | 43398a8 | 2015-07-28 16:12:20 +0200 | [diff] [blame] | 732 | return new buffer_info(((capture *) ptr)->func(caster)); |
| 733 | }, ptr); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 734 | return *this; |
| 735 | } |
| 736 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 737 | template <typename C, typename D, typename... Extra> |
| 738 | class_ &def_readwrite(const char *name, D C::*pm, Extra&&... extra) { |
| 739 | cpp_function fget([pm](const C &c) -> const D &{ return c.*pm; }, |
| 740 | return_value_policy::reference_internal, |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 741 | is_method(this), extra...), |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 742 | fset([pm](C &c, const D &value) { c.*pm = value; }, |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 743 | is_method(this), extra...); |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 744 | def_property(name, fget, fset); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 745 | return *this; |
| 746 | } |
| 747 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 748 | template <typename C, typename D, typename... Extra> |
| 749 | class_ &def_readonly(const char *name, const D C::*pm, Extra&& ...extra) { |
| 750 | cpp_function fget([pm](const C &c) -> const D &{ return c.*pm; }, |
| 751 | return_value_policy::reference_internal, |
Wenzel Jakob | 5708221 | 2015-09-04 23:42:12 +0200 | [diff] [blame] | 752 | is_method(this), std::forward<Extra>(extra)...); |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 753 | def_property_readonly(name, fget); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 754 | return *this; |
| 755 | } |
| 756 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 757 | template <typename D, typename... Extra> |
| 758 | class_ &def_readwrite_static(const char *name, D *pm, Extra&& ...extra) { |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 759 | cpp_function fget([pm](object) -> const D &{ return *pm; }, nullptr, |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 760 | return_value_policy::reference_internal, extra...), |
| 761 | fset([pm](object, const D &value) { *pm = value; }, extra...); |
| 762 | def_property_static(name, fget, fset); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 763 | return *this; |
| 764 | } |
| 765 | |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 766 | template <typename D, typename... Extra> |
| 767 | class_ &def_readonly_static(const char *name, const D *pm, Extra&& ...extra) { |
Wenzel Jakob | bd4a529 | 2015-07-11 17:41:48 +0200 | [diff] [blame] | 768 | cpp_function fget([pm](object) -> const D &{ return *pm; }, nullptr, |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 769 | return_value_policy::reference_internal, std::forward<Extra>(extra)...); |
| 770 | def_property_readonly_static(name, fget); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 771 | return *this; |
| 772 | } |
| 773 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 774 | class_ &def_property_readonly(const char *name, const cpp_function &fget, const char *doc = nullptr) { |
| 775 | def_property(name, fget, cpp_function(), doc); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 776 | return *this; |
| 777 | } |
| 778 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 779 | class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const char *doc = nullptr) { |
| 780 | def_property_static(name, fget, cpp_function(), doc); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 781 | return *this; |
| 782 | } |
| 783 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 784 | class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const char *doc = nullptr) { |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 785 | object doc_obj = doc ? pybind11::str(doc) : (object) const_cast<cpp_function&>(fget).attr("__doc__"); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 786 | object property( |
| 787 | PyObject_CallFunction((PyObject *)&PyProperty_Type, |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 788 | const_cast<char *>("OOOO"), fget.ptr() ? fget.ptr() : Py_None, |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 789 | fset.ptr() ? fset.ptr() : Py_None, Py_None, doc_obj.ptr()), false); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 790 | attr(name) = property; |
| 791 | return *this; |
| 792 | } |
| 793 | |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 794 | class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const char *doc = nullptr) { |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 795 | object doc_obj = doc ? pybind11::str(doc) : (object) const_cast<cpp_function&>(fget).attr("__doc__"); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 796 | object property( |
| 797 | PyObject_CallFunction((PyObject *)&PyProperty_Type, |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 798 | const_cast<char *>("OOOs"), fget.ptr() ? fget.ptr() : Py_None, |
| 799 | fset.ptr() ? fset.ptr() : Py_None, Py_None, doc_obj.ptr()), false); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 800 | metaclass().attr(name) = property; |
| 801 | return *this; |
| 802 | } |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 803 | |
| 804 | template <typename target> class_ alias() { |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 805 | auto &instances = pybind11::detail::get_internals().registered_types; |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 806 | instances[&typeid(target)] = instances[&typeid(type)]; |
| 807 | return *this; |
| 808 | } |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 809 | private: |
Wenzel Jakob | 6e213c9 | 2015-11-24 23:05:58 +0100 | [diff] [blame] | 810 | template <typename T = holder_type, |
| 811 | typename std::enable_if<!std::is_same<std::shared_ptr<type>, T>::value, int>::type = 0> |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 812 | static void init_holder(PyObject *inst_) { |
| 813 | instance_type *inst = (instance_type *) inst_; |
| 814 | new (&inst->holder) holder_type(inst->value); |
| 815 | inst->constructed = true; |
| 816 | } |
Wenzel Jakob | 6e213c9 | 2015-11-24 23:05:58 +0100 | [diff] [blame] | 817 | |
| 818 | template <typename T = holder_type, |
| 819 | typename std::enable_if<std::is_same<std::shared_ptr<type>, T>::value, int>::type = 0> |
| 820 | static void init_holder(PyObject *inst_) { |
| 821 | instance_type *inst = (instance_type *) inst_; |
| 822 | try { |
| 823 | new (&inst->holder) holder_type( |
| 824 | inst->value->shared_from_this() |
| 825 | ); |
| 826 | } catch (const std::bad_weak_ptr &) { |
| 827 | new (&inst->holder) holder_type(inst->value); |
| 828 | } |
| 829 | inst->constructed = true; |
| 830 | } |
| 831 | |
| 832 | |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 833 | static void dealloc(PyObject *inst_) { |
| 834 | instance_type *inst = (instance_type *) inst_; |
| 835 | if (inst->owned) { |
| 836 | if (inst->constructed) |
| 837 | inst->holder.~holder_type(); |
| 838 | else |
| 839 | ::operator delete(inst->value); |
| 840 | } |
| 841 | custom_type::dealloc((detail::instance<void> *) inst); |
| 842 | } |
| 843 | }; |
| 844 | |
| 845 | /// Binds C++ enumerations and enumeration classes to Python |
| 846 | template <typename Type> class enum_ : public class_<Type> { |
| 847 | public: |
| 848 | enum_(object &scope, const char *name, const char *doc = nullptr) |
| 849 | : class_<Type>(scope, name, doc), m_parent(scope) { |
| 850 | auto entries = new std::unordered_map<int, const char *>(); |
Wenzel Jakob | 8456a4d | 2015-10-13 02:42:20 +0200 | [diff] [blame] | 851 | this->def("__repr__", [name, entries](Type value) -> std::string { |
Wenzel Jakob | a750031 | 2015-08-29 02:08:32 +0200 | [diff] [blame] | 852 | auto it = entries->find((int) value); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 853 | return std::string(name) + "." + |
| 854 | ((it == entries->end()) ? std::string("???") |
| 855 | : std::string(it->second)); |
| 856 | }); |
Wenzel Jakob | 6918922 | 2015-10-01 21:32:23 +0200 | [diff] [blame] | 857 | this->def("__int__", [](Type value) { return (int) value; }); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 858 | m_entries = entries; |
| 859 | } |
| 860 | |
| 861 | /// Export enumeration entries into the parent scope |
| 862 | void export_values() { |
| 863 | PyObject *dict = ((PyTypeObject *) this->m_ptr)->tp_dict; |
| 864 | PyObject *key, *value; |
| 865 | Py_ssize_t pos = 0; |
| 866 | while (PyDict_Next(dict, &pos, &key, &value)) |
| 867 | if (PyObject_IsInstance(value, this->m_ptr)) |
| 868 | m_parent.attr(key) = value; |
| 869 | } |
| 870 | |
| 871 | /// Add an enumeration entry |
| 872 | enum_& value(char const* name, Type value) { |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 873 | this->attr(name) = pybind11::cast(value, return_value_policy::copy); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 874 | (*m_entries)[(int) value] = name; |
| 875 | return *this; |
| 876 | } |
| 877 | private: |
| 878 | std::unordered_map<int, const char *> *m_entries; |
| 879 | object &m_parent; |
| 880 | }; |
| 881 | |
| 882 | NAMESPACE_BEGIN(detail) |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 883 | template <typename... Args> struct init { |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 884 | template <typename Base, typename Holder, typename... Extra> void execute(pybind11::class_<Base, Holder> &class_, Extra&&... extra) const { |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 885 | /// Function which calls a specific C++ in-place constructor |
Wenzel Jakob | 7186783 | 2015-07-29 17:43:52 +0200 | [diff] [blame] | 886 | class_.def("__init__", [](Base *instance, Args... args) { new (instance) Base(args...); }, std::forward<Extra>(extra)...); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 887 | } |
| 888 | }; |
| 889 | NAMESPACE_END(detail) |
| 890 | |
| 891 | template <typename... Args> detail::init<Args...> init() { return detail::init<Args...>(); }; |
| 892 | |
| 893 | template <typename InputType, typename OutputType> void implicitly_convertible() { |
| 894 | auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject *{ |
| 895 | if (!detail::type_caster<InputType>().load(obj, false)) |
| 896 | return nullptr; |
| 897 | tuple args(1); |
| 898 | args[0] = obj; |
| 899 | PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr); |
| 900 | if (result == nullptr) |
| 901 | PyErr_Clear(); |
| 902 | return result; |
| 903 | }; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 904 | auto & registered_types = detail::get_internals().registered_types; |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 905 | auto it = registered_types.find(&typeid(OutputType)); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 906 | if (it == registered_types.end()) |
Wenzel Jakob | f5fae92 | 2015-08-24 15:31:24 +0200 | [diff] [blame] | 907 | throw std::runtime_error("implicitly_convertible: Unable to find type " + type_id<OutputType>()); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 908 | it->second.implicit_conversions.push_back(implicit_caster); |
| 909 | } |
| 910 | |
| 911 | inline void init_threading() { PyEval_InitThreads(); } |
| 912 | |
| 913 | class gil_scoped_acquire { |
| 914 | PyGILState_STATE state; |
| 915 | public: |
| 916 | inline gil_scoped_acquire() { state = PyGILState_Ensure(); } |
| 917 | inline ~gil_scoped_acquire() { PyGILState_Release(state); } |
| 918 | }; |
| 919 | |
| 920 | class gil_scoped_release { |
| 921 | PyThreadState *state; |
| 922 | public: |
| 923 | inline gil_scoped_release() { state = PyEval_SaveThread(); } |
| 924 | inline ~gil_scoped_release() { PyEval_RestoreThread(state); } |
| 925 | }; |
| 926 | |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 927 | inline function get_overload(const void *this_ptr, const char *name) { |
| 928 | handle py_object = detail::get_object_handle(this_ptr); |
Wenzel Jakob | ac0fde9 | 2015-10-01 18:37:26 +0200 | [diff] [blame] | 929 | if (!py_object) |
| 930 | return function(); |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 931 | handle type = py_object.get_type(); |
| 932 | auto key = std::make_pair(type.ptr(), name); |
| 933 | |
| 934 | /* Cache functions that aren't overloaded in python to avoid |
| 935 | many costly dictionary lookups in Python */ |
| 936 | auto &cache = detail::get_internals().inactive_overload_cache; |
| 937 | if (cache.find(key) != cache.end()) |
| 938 | return function(); |
| 939 | |
| 940 | function overload = (function) py_object.attr(name); |
| 941 | if (overload.is_cpp_function()) { |
| 942 | cache.insert(key); |
| 943 | return function(); |
| 944 | } |
| 945 | PyFrameObject *frame = PyThreadState_Get()->frame; |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 946 | pybind11::str caller = pybind11::handle(frame->f_code->co_name).str(); |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 947 | if (strcmp((const char *) caller, name) == 0) |
| 948 | return function(); |
| 949 | return overload; |
| 950 | } |
| 951 | |
Wenzel Jakob | b1b7140 | 2015-10-18 16:48:30 +0200 | [diff] [blame] | 952 | #define PYBIND11_OVERLOAD_INT(ret_type, class_name, name, ...) { \ |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 953 | pybind11::gil_scoped_acquire gil; \ |
| 954 | pybind11::function overload = pybind11::get_overload(this, #name); \ |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 955 | if (overload) \ |
| 956 | return overload.call(__VA_ARGS__).cast<ret_type>(); } |
| 957 | |
Wenzel Jakob | b1b7140 | 2015-10-18 16:48:30 +0200 | [diff] [blame] | 958 | #define PYBIND11_OVERLOAD(ret_type, class_name, name, ...) \ |
| 959 | PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \ |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 960 | return class_name::name(__VA_ARGS__) |
| 961 | |
Wenzel Jakob | b1b7140 | 2015-10-18 16:48:30 +0200 | [diff] [blame] | 962 | #define PYBIND11_OVERLOAD_PURE(ret_type, class_name, name, ...) \ |
| 963 | PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \ |
Wenzel Jakob | a2f6fde | 2015-10-01 16:46:03 +0200 | [diff] [blame] | 964 | throw std::runtime_error("Tried to call pure virtual function \"" #name "\""); |
| 965 | |
Wenzel Jakob | 8f4eb00 | 2015-10-15 18:13:33 +0200 | [diff] [blame] | 966 | NAMESPACE_END(pybind11) |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 967 | |
| 968 | #if defined(_MSC_VER) |
| 969 | #pragma warning(pop) |
Wenzel Jakob | cd5cda7 | 2015-08-03 12:17:54 +0200 | [diff] [blame] | 970 | #elif defined(__GNUG__) and !defined(__clang__) |
Wenzel Jakob | 281aa0e | 2015-07-30 15:29:00 +0200 | [diff] [blame] | 971 | #pragma GCC diagnostic pop |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 972 | #endif |
Wenzel Jakob | 281aa0e | 2015-07-30 15:29:00 +0200 | [diff] [blame] | 973 | |