include/pybind11/pybind11.h

28 #  pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning)
69               typename = detail::enable_if_t<detail::is_lambda<Func>::value>>
120             if (!std::is_trivially_destructible<Func>::value)
127         /* Type casters for the function arguments and return value */
130             conditional_t<std::is_void<Return>::value, void_type, Return>
171         /* Generate a readable signature describing the function's arguments and return value types */
184             std::is_convertible<Func, FunctionType>::value &&
204             else if (a.value)
205                 a.descr = strdup(a.value.attr("__repr__")().cast<std::string>().c_str());
244                 // Write default value if available.
412                 arg.value.dec_ref();
448             // If this value is already registered it must mean __init__ is invoked multiple times;
503                     // The `value` may have been preallocated by an old-style `__init__`
544                         handle value;
546                             value = PyDict_GetItemString(kwargs.ptr(), arg.name);
548                         if (value) {
549                             // Consume a kwargs value
555                         } else if (arg.value) {
556                             value = arg.value;
559                         if (value) {
560                             call.args.push_back(value);
772             std::string msg = "Unable to convert function return value to a "
944     void mark_parents_nonsimple(PyTypeObject *value) {
945         auto t = reinterpret_borrow<tuple>(value->tp_bases);
999 template <typename T, enable_if_t<has_operator_delete<T>::value, int> = 0>
1001 template <typename T, enable_if_t<!has_operator_delete<T>::value && has_operator_delete_size<T>::value, int> = 0>
1025     static_assert(detail::is_accessible_base_of<Class, Derived>::value,
1032     static_assert(detail::is_accessible_base_of<Class, Derived>::value,
1049     constexpr static bool has_alias = !std::is_void<type_alias>::value;
1052     static_assert(detail::all_of<is_valid_class_option<options>...>::value,
1055     static_assert(!has_alias || std::is_polymorphic<type>::value,
1066             none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
1067             (   constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
1068                 constexpr_sum(is_base<options>::value...)   == 0 && // no template option bases
1069                 none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
1081         record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
1099     template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
1106     template <typename Base, detail::enable_if_t<!is_base<Base>::value, int> = 0>
1119         static_assert(!std::is_member_function_pointer<Func>::value,
1187         static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
1189                      fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
1196         static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readonly() requires a class member (or base class member)");
1205                      fset([pm](object, const D &value) { *pm = value; }, scope(*this));
1268         static_assert( 0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
1329         } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
1338     /// `.owned`, a new holder will be constructed to manage the value pointer.
1523     PYBIND11_NOINLINE void value(char const* name_, object value, const char *doc = nullptr) {
1531         entries[name] = std::make_pair(value, doc);
1532         m_base.attr(name) = value;
1560         constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value;
1561         constexpr bool is_convertible = std::is_convertible<Type, Scalar>::value;
1565         def("__int__", [](Type value) { return (Scalar) value; });
1567             def("__long__", [](Type value) { return (Scalar) value; });
1570             def("__index__", [](Type value) { return (Scalar) value; });
1574             [](Type &value, Scalar arg) { value = static_cast<Type>(arg); },
1586     enum_& value(char const* name, Type value, const char *doc = nullptr) {
1587         m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc);
1727           typename Type, typename... Extra> iterator make_iterator(Type &value, Extra&&... extra) {
1728     return make_iterator<Policy>(std::begin(value), std::end(value), extra...);
1734           typename Type, typename... Extra> iterator make_key_iterator(Type &value, Extra&&... extra) {
1735     return make_key_iterator<Policy>(std::begin(value), std::end(value), extra...);
2099             if (pybind11::detail::cast_is_temporary_value_reference<ret_type>::value) { \