Odd Interrogate Inheritance Issue [SOLVED] about panda3d HOT 8 CLOSED

Hmm, that codebase has quite strange inheritance. Why does everything virtually inherit from TypedObject? Only one base need do so; since ClickablePopup already inherits indirectly from TypedObject, for example, there's nothing to gain from a class that derives from ClickablePopup also inheriting from TypedObject.

Which class in question is interrogate erroring about, though? It would help to also see the error message itself.

from panda3d.

The error itself is "2>..\src\nametag_igate.cxx(2542): error C2385: ambiguous access of 'as_typed_object'
2> could be the 'as_typed_object' in base 'TypedObject'
2> or could be the 'as_typed_object' in base 'TypedObject'
2>..\src\nametag_igate.cxx(2542): error C3861: 'as_typed_object': identifier not found
2>..\src\nametag_igate.cxx(4028): error C2385: ambiguous access of 'as_typed_object'
2> could be the 'as_typed_object' in base 'TypedObject'
2> or could be the 'as_typed_object' in base 'TypedObject'
2>..\src\nametag_igate.cxx(4028): error C3861: 'as_typed_object': identifier not found"

and i can't get rid of TypedObject for either of the bases for Nametag2d as both bases have things that need to be published. The rest of the virtual bases are for inheritance or to prevent conflicting class usage.

from panda3d.

And both sections the error happens just in case you're curious about that

/**
 * Python function wrapper for:
 * Nametag2d &Nametag2d::operator =(Nametag2d const &tag)
 */
static PyObject *Dtool_Nametag2d_operator_86(PyObject *self, PyObject *arg) {
  Nametag2d *local_this = NULL;
  if (!Dtool_Call_ExtractThisPointer_NonConst(self, Dtool_Nametag2d, (void **)&local_this, "Nametag2d.assign")) {
    return NULL;
  }
  // 1-Nametag2d &Nametag2d::operator =(Nametag2d const &tag)
  Nametag2d const *arg_this = (Nametag2d *)DTOOL_Call_GetPointerThisClass(arg, Dtool_Ptr_Nametag2d, 1, "Nametag2d.assign", true, true);
  if (arg_this != NULL) {
    (*local_this).operator =(*arg_this);
    Nametag2d *return_value = local_this;
    if (return_value != (Nametag2d *)NULL) {
      return_value->ref();
    }
    if (Dtool_CheckErrorOccurred()) {
      if (return_value != (Nametag2d *)NULL) {
        unref_delete(return_value);
      }
      return NULL;
    }
    if (return_value == NULL) {
      Py_INCREF(Py_None);
      return Py_None;
    } else {
      return DTool_CreatePyInstanceTyped((void *)return_value, *Dtool_Ptr_Nametag2d, true, false, return_value->as_typed_object()->get_type_index());
    }
  }
  if (!_PyErr_OCCURRED()) {
    return Dtool_Raise_BadArgumentsError(
      "assign(const Nametag2d self, const Nametag2d tag)\n");
  }
  return NULL;
}

/**
 * Python function wrapper for:
 * Nametag2d *NametagGroup::get_nametag_2d(void)
 */
static PyObject *Dtool_NametagGroup_get_nametag_2d_131(PyObject *self, PyObject *) {
  NametagGroup *local_this = NULL;
  if (!Dtool_Call_ExtractThisPointer_NonConst(self, Dtool_NametagGroup, (void **)&local_this, "NametagGroup.get_nametag_2d")) {
    return NULL;
  }
  // 1-Nametag2d *NametagGroup::get_nametag_2d(void)
  Nametag2d *return_value = (*local_this).get_nametag_2d();
  if (return_value != (Nametag2d *)NULL) {
    return_value->ref();
  }
  if (Dtool_CheckErrorOccurred()) {
    if (return_value != (Nametag2d *)NULL) {
      unref_delete(return_value);
    }
    return NULL;
  }
  if (return_value == NULL) {
    Py_INCREF(Py_None);
    return Py_None;
  } else {
    return DTool_CreatePyInstanceTyped((void *)return_value, *Dtool_Ptr_Nametag2d, true, false, return_value->as_typed_object()->get_type_index());
  }
}

from panda3d.

This is not really an issue of Interrogate, but of your odd inheritance that makes the call to the inherited method as_typed_object() ambiguous. This applies to any code that calls it, including the interrogate-generated code. The compiler gets confused; since your object inherits from TypedObject several times, it won't know which version of the inherited method to pick.

(In theory, interrogate could pick a class and force a devirtualised call. But how would it know which one to pick?)

It's usually a bad idea to inherit multiple times from TypedObject. But if you must do so, you need to define a method in the class that inherits multiple times, to disambiguate the call to as_typed_object().

CollisionVisualizer is a Panda class that inherits multiple times from TypedObject, and it defines the following methods to resolve this conflict:

from panda3d.

Oh, and for the record:

and i can't get rid of TypedObject for either of the bases for Nametag2d as both bases have things that need to be published. The rest of the virtual bases are for inheritance or to prevent conflicting class usage.

You don't need to inherit from TypedObject to publish anything via Interrogate. It will wrap the types just fine without any TypedObject in your inheritance tree.

(It's only needed for dynamic upcasting; so that a method that returns a PandaNode pointer will automatically upcast to a GeomNode on the Python side if it's really a GeomNode. Even then, you only need one TypedObject in the class hierarchy; adding multiple inheritances to TypedObject will just confuse matters.)

Needing virtual inheritance is usually a sign that you may need to rethink your class hierarchy. It's a tool that should be used sparingly; I don't believe virtual inheritance is needed in any part of the Panda3D codebase.

from panda3d.

I wrote this code a few years ago. It's broken and unfinished (how did it even get leaked?). I do not recommend using it.

from panda3d.

It was public Loblao. Also i only plan on using it as a base as i slowly RE Disney's Nametags

from panda3d.

Also thanks for the help rdb. (Didn't know you didn't need a TypedObject to publish...) And the class hierarchy will now finally be able to under go some renovations as i needed that to compile to do some testing and etc.

from panda3d.