Pb with .findInheritedMethods

Hi again,


Here is a very simplified version of a class hierarchy
defined in the Biobase package (Bioconductor). I post
here because this seems to be an S4 related problem:

    setClass("A", representation(name="character"))
    setMethod("initialize", "A", function(.Object) {.Object at name <- "I'm
    an A"; .Object})

    setClass("Ab", contains="A")
    setMethod("initialize", "Ab", function(.Object) callNextMethod(.Object))

    setClass("Abc", contains="Ab")

    setClass("Abcd", contains = c("Abc"))

Now if I do:

    tmp1 <- new("Abc")
    tmp2 <- new("Abcd")

I get the following warning:

    Warning message:
    Ambiguous method selection for "initialize", target "Abcd" (the
    first of the signatures shown will be used)
        Abc
        Ab
     in: .findInheritedMethods(classes, fdef, mtable)

I don't really understand why .findInheritedMethods is
complaining here...
And if I don't do 'tmp1 <- new("Abc")' before I
do 'tmp2 <- new("Abcd")', then I don't get the warning
anymore!

Does anybody have an explanation for this?


Thanks,
H.

A problem with callNextMethod, which is caching an inherited method as
if it was not inherited, causing confusion on the next search.  Should
be fairly easy to fix, but may be a while before I get time to do so.

By the way, I hope your simplified example does not reflect what
happens in the actual one.
   callNextMethod(.Object)
throws away all the ... arguments to new(), which rather defeats the
purpose of having initialize() methods.  Generally, callNextMethod()
should get no arguments or all the arguments it needs, including ...
See ?callNextMethod

....
More generally I don't see what's wrong with not passing
to callNextMethod all the arguments coming from the call
to new:

    setClass("A", representation(toto="integer"))
    setMethod("initialize", "A", function(.Object, toto0) {.Object at toto
    <- as.integer(toto0); .Object})
    new("A", 45.1)

    setClass("Ab", contains="A")
    setMethod("initialize", "Ab", function(.Object, x, y)
    callNextMethod(.Object, x*y+1))
    new("Ab", 5, 2)
  

Regards,

H.

As I mentioned, this relates to writing methods for initialize().
Imagine someone else extends the class "Ab", for which you wrote a
method.  If they add slots to their class and you do not pass down ...
to callNextMethod(), then you have blocked users from setting values
for those slots in calls to new(), since the ... argument is thrown
away by your method.

The other aspect to this is that the last specialized method in your
chain of class definitions should end up with: callNextMethod(.Object,
...)  Then the default initialize() method will set values for named
slots.