Method make_class

src/pya/pya/pyaModule.cc:243–680

  }

  PyTypeObject *make_class (const gsi::ClassBase *cls, bool as_static)
  {
    //  drop non-standard names
    if (tl::verbosity () >= 40) {
      tl::info << tl::sprintf (tl::to_string (tr ("Creating class %s.%s")), PyModule_GetName (mp_module->module ()), cls->name ());
    }

    //  NOTE: with as_static = true, this method produces a mixin. This is a class entirely consisting
    //  of static constants and child classes only. It can be mixed into an existing class for emulation
    //  additional base classes.
    //  Everything else, like properties and methods will not work as the method enumeration scheme is
    //  not capable of handling more than a single base class.

    PyTypeObject *pt = PythonClassClientData::py_type (*cls, as_static);
    if (pt != 0) {

      if (! mp_module->is_class_of_module (cls)) {

        //  class is already built, but not member of the module yet (e.g.
        //  on duplicate import into a new module object): add now without building again

        mp_module->register_class (cls);
        tl_assert (mp_module->cls_for_type (pt) == cls);

        //  add to the parent class as child class or add to module

        if (! cls->parent ()) {
          PyList_Append (m_all_list, c2python (cls->name ()));
          Py_INCREF ((PyObject *) pt);
          PyModule_AddObject (mp_module->module (), cls->name ().c_str (), (PyObject *) pt);
        }

      }

      return pt;

    }

    PythonRef bases;

    //  mix-in unnamed extensions and get the base classes

    int n_bases = (cls->base () != 0 ? 1 : 0);
    auto exts = m_extensions_for.find (cls);
    if (exts != m_extensions_for.end ()) {
      n_bases += int (exts->second.size ());
    }

    bases = PythonRef (PyTuple_New (n_bases));

    int ibase = 0;
    if (cls->base () != 0) {
      PyTypeObject *pt = make_class (cls->base (), as_static);
      PyObject *base = (PyObject *) pt;
      Py_INCREF (base);
      PyTuple_SetItem (bases.get (), ibase++, base);
    }