include/pybind11/cast.h

44         get_internals().loader_patient_stack.push_back(nullptr);
72         if (list_ptr == nullptr) {
156  * Gets a single pybind11 type info for a python type.  Returns nullptr if neither the type nor any
163         return nullptr;
174     return nullptr;
182     return nullptr;
185 /// Return the type info for a given C++ type; on lookup failure can either throw or return nullptr.
198     return nullptr;
203     return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
207     instance *inst = nullptr;
209     const detail::type_info *type = nullptr;
210     void **vh = nullptr;
273         instance *inst = nullptr;
274         const type_vec *types = nullptr;
280                  types->empty() ? nullptr : (*types)[0] /* type info */,
293             curr.type = curr.index < types->size() ? (*types)[curr.index] : nullptr;
316  * `find_type` is omitted (or explicitly specified as nullptr) the first value/holder are returned,
317  * regardless of type (and the resulting .type will be nullptr).
322 PYBIND11_NOINLINE inline value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) {
359         simple_value_holder[0] = nullptr;
425     if (scope.trace != nullptr)
489         : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
499                                          const void *existing_holder = nullptr) {
504         if (src == nullptr)
572         if (vptr == nullptr) {
611         return nullptr;
645             value = nullptr;
722     // with .second = nullptr.  (p.first = nullptr is not an error: it becomes None).
724             const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) {
733         return {nullptr, nullptr};
736     const type_info *typeinfo = nullptr;
737     const std::type_info *cpptype = nullptr;
738     void *value = nullptr;
797 // single inheritance cases). If not, or if `src` is nullptr, it simply returns `src`
798 // and leaves `tinfo` at its default value of nullptr.
818         type = src ? &typeid(*src) : nullptr;
850         const std::type_info *instance_type = nullptr;
864         // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
880             nullptr, nullptr, holder);
907     static Constructor make_copy_constructor(...) { return nullptr; }
908     static Constructor make_move_constructor(...) { return nullptr; }
1083             value = nullptr;
1115     void *value = nullptr;
1200             load_src.ptr(), UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr));
1229             UTF_N == 8  ? PyUnicode_DecodeUTF8(buffer, nbytes, nullptr) :
1230             UTF_N == 16 ? PyUnicode_DecodeUTF16(buffer, nbytes, nullptr, nullptr) :
1231                           PyUnicode_DecodeUTF32(buffer, nbytes, nullptr, nullptr);
1237         return PyUnicode_Decode(buffer, nbytes, UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr);
1274 // ability to use None as a nullptr char* (which the string caster doesn't allow).
1294         if (src == nullptr) return pybind11::none().inc_ref();
1300             handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr);
1307     operator CharT*() { return none ? nullptr : const_cast<CharT *>(static_cast<StringType &>(str_caster).c_str()); }
1762             std::forward<Args>(args_), policy, nullptr))... }
1786     constexpr explicit arg(const char *name = nullptr) : name(name), flag_noconvert(false), flag_none(true) { }
1804     arg_v(arg &&base, T &&x, const char *descr = nullptr)
1818     arg_v(const char *name, T &&x, const char *descr = nullptr)
1823     arg_v(const arg &base, T &&x, const char *descr = nullptr)