| RClassUtils {methods} | R Documentation |
These are various functions to support the definition and use of formal classes. Most of them are rarely suitable to be called directly.
Others are somewhat experimental and/or partially implemented only. Do
refer to setClass for normal code development.
testVirtual(properties, extends, prototype, where)
makePrototypeFromClassDef(slots, ClassDef, extends, where)
newEmptyObject()
completeClassDefinition(Class, ClassDef, where, doExtends)
getSlots(x)
getAllSuperClasses(ClassDef, simpleOnly = TRUE)
superClassDepth(ClassDef, soFar, simpleOnly = TRUE)
isVirtualClass(Class, where)
newBasic(Class, ...)
makeExtends(Class, to, coerce, test, replace, by, package, slots,
classDef1, classDef2)
reconcilePropertiesAndPrototype(name, properties, prototype,
superClasses, where)
tryNew(Class, where)
trySilent(expr)
empty.dump()
showClass(Class, complete=TRUE, propertiesAreCalled1tion in its next call
(but note that the dispatch is as in the detailed description below;
the arguments have no effect on selecting the next method.)
If no arguments are included in the call to callNextMethod, the
effect is to call the method with the current arguments.
See the detailed description for what this really means.
Calling with no arguments is often the natural way to use
callNextMethod; see the examples.
Details
The “next” method (i.e., the first inherited method) is defined to
be that method
which would have been called if the current method did not
exist.
This is more-or-less literally what happens: The current method is
deleted from a copy of the methods for the current generic, and
selectMethod is called to find the next method (the
result is cached in a special object, so the search only typically
happens once per session per combination of argument classes).
It is also legal, and often useful, for the method called by
callNextMethod to itself have a call to
callNextMethod. This generally works as you would expect, but
for completeness be aware that it is possible to have ambiguous
inheritance in the S structure, in the sense that the same two
classes can appear as superclasses in the opposite order in
two other class definitions. In this case the effect of a nested
instance of callNextMethod is not well defined. Such
inconsistent class hierarchies are both rare and nearly always the
result of bad design, but they are possible, and currently undetected.
The statement that the method is called with the current arguments is
more precisely as follows. Arguments that were missing in the current
call are still missing (remember that "missing" is a valid
class in a method signature). For a formal argument, say x, that
appears in the original call, there is a corresponding argument in the
next method call equivalent to “x = x”. In effect, this
means that the next method sees the same actual arguments, but
arguments are evaluated only once.
Value
The value returned by the selected method.
References
The R package methods implements, with a few exceptions, the
programming interface for classes
and methods in the book Programming with Data (John
M. Chambers, Springer, 1998), in particular sections 1.6, 2.7, 2.8,
and chapters 7 and 8.
While the programming interface for the methods package follows
the reference, the R software is an original implementation, so
details in the reference that reflect the S4 implementation may appear
differently in R. Also, there are extensions to the programming
interface developed more recently than the reference. For a
discussion of details and ongoing development, see the web page
http://developer.r-project.org/methodsPackage.html and the
pointers from that page.
See Also
Methods for the general behavior of method dispatch
Examples
## some class definitions with simple inheritance
setClass("B0" , representation(b0 = "numeric"))
setClass("B1", representation(b1 = "character"), contains = "B0")
setClass("B2", representation(b2 = "logical"), contains = "B1")
## and a rather silly function to illustrate callNextMethod
f <- function(x) class(x)
setMethod("f", "B0", function(x) c(x@b0^2, callNextMethod()))
setMethod("f", "B1", function(x) c(paste(x@b1,":"), callNextMethod()))
setMethod("f", "B2", function(x) c(x@b2, callNextMethod()))
b1 <- new("B1", b0 = 2, b1 = "Testing")
b2 <- new("B2", b2 = FALSE, b1 = "More testing", b0 = 10)
f(b2)
f(b1)
[Package methods version 2.1.0 Index]