void write_pinterface_impl()

in src/tool/python/code_writers.h [1432:1596]

• 142 lines of code
• 13 McCabe index (conditional complexity)

    void write_pinterface_impl(writer& w, TypeDef const& type)
    {
        if (!is_ptype(type))
            return;

        auto guard{ w.push_generic_params(type.GenericParam()) };

        w.write("\ntemplate<%>\nstruct @ : public py::proj::%::@\n{\n",
            bind_list<write_template_arg>(", ", type.GenericParam()),
            type.TypeName(),
            bind<write_type_namespace>(type),
            type.TypeName());

        {
            writer::indent_guard g{ w };

            w.write("@(%<%> o) : _obj(o) {}\n", type.TypeName(), type, bind_list<write_template_arg_name>(", ", type.GenericParam()));
            w.write("winrt::Windows::Foundation::IUnknown const& get_unknown() noexcept override { return _obj; }\n");
            w.write("std::size_t hash() noexcept override { return py::get_instance_hash(_obj); }\n");

            std::set<std::string_view> method_names{};
            enumerate_methods(w, type, [&](auto const& method)
            {
                method_names.insert(method.Name());
            });

            for (auto&& method_name : method_names)
            {
                w.write("PyObject* %(PyObject* args) noexcept override\n{\n", method_name);
                {
                    writer::indent_guard gg{ w };
                    write_method_overloads(w, type, method_name);
                }
                w.write("}\n");
            }

            enumerate_properties(w, type, [&](auto const& prop)
            {
                auto methods = get_property_methods(prop);
                auto get_method = std::get<0>(methods);
                auto put_method = std::get<1>(methods);

                w.write("PyObject* %() noexcept override\n{\n", get_method.Name());
                {
                    writer::indent_guard gg{ w };
                    write_try_catch(w, [&](writer& w) { write_method_body_contents(w, type, get_method); });
                }
                w.write("}\n");

                if (put_method)
                {
                    w.write("int %(PyObject* arg) noexcept override\n{\n", put_method.Name());
                    {
                        writer::indent_guard gg{ w };
                        write_setter_try_catch(w, [&](writer& w) { write_method_body_contents(w, type, put_method, true); });
                    }
                    w.write("}\n");

                }
            });

            enumerate_events(w, type, [&](auto const& evt)
            {
                auto methods = get_event_methods(evt);
                auto add_method = std::get<0>(methods);
                auto remove_method = std::get<1>(methods);

                w.write("PyObject* %(PyObject* arg) noexcept override\n{\n", add_method.Name());
                {
                    writer::indent_guard gg{ w };
                    write_try_catch(w, [&](writer& w) { write_method_body_contents(w, type, add_method); });
                }
                w.write("}\n");

                w.write("PyObject* %(PyObject* arg) noexcept override\n{\n", remove_method.Name());
                {
                    writer::indent_guard gg{ w };
                    write_try_catch(w, [&](writer& w) { write_method_body_contents(w, type, remove_method); });
                }
                w.write("}\n");
            });

            if (implements_iasync(type))
            {
                w.write("PyObject* dunder_await() noexcept override { return py::dunder_await(_obj); }\n");
            }

            if (implements_iiterable(type) || implements_iiterator(type))
            {
                w.write("PyObject* dunder_iter() noexcept override\n{\n");
                {
                    writer::indent_guard gg{ w };
                    write_dunder_iter_body(w, type);
                }
                w.write("}\n");
            }

            if (implements_iiterator(type))
            {
                w.write("PyObject* dunder_iternext() noexcept override\n{\n");
                {
                    writer::indent_guard gg{ w };
                    write_dunder_iter_next_body(w, type);
                }
                w.write("}\n");
            }

            if (implements_sequence(type))
            {
                w.write("Py_ssize_t seq_length() noexcept override\n{\n");
                {
                    writer::indent_guard gg{ w };
                    write_seq_length_body(w, type);
                }
                w.write("}\n");

                w.write("PyObject* seq_item(Py_ssize_t i) noexcept override\n{\n");
                {
                    writer::indent_guard gg{ w };
                    write_seq_item_body(w, type);
                }
                w.write("}\n");

                if (implements_ivector(type))
                {
                    w.write("int seq_assign(Py_ssize_t i, PyObject* value) noexcept override\n{\n");
                    {
                        writer::indent_guard gg{ w };
                        write_seq_assign_body(w, type);
                    }
                    w.write("}\n");
                }
            }

            if (implements_mapping(type))
            {
                w.write("Py_ssize_t map_length() noexcept override\n{\n");
                {
                    writer::indent_guard gg{ w };
                    write_map_length_body(w, type);
                }
                w.write("}\n");

                w.write("PyObject* map_subscript(PyObject* key) noexcept override\n{\n");
                {
                    writer::indent_guard gg{ w };
                    write_map_subscript_body(w, type);
                }
                w.write("}\n");

                if (implements_imap(type))
                {
                    w.write("int map_assign(PyObject* key, PyObject* value) noexcept override\n{\n");
                    {
                        writer::indent_guard gg{ w };
                        write_map_assign_body(w, type);
                    }
                    w.write("}\n");
                }
            }

            w.write("\n%<%> _obj{ nullptr };\n", type, bind_list<write_template_arg_name>(", ", type.GenericParam()));
        }
        w.write("};\n");
    }