isSealedMethod            package:methods            R Documentation

Check for a Sealed Method or Class

Description:

     These functions check for either a method or a class that has been
     _sealed_ when it was defined, and which therefore cannot be
     re-defined.

Usage:

     isSealedMethod(f, signature, fdef, where)
     isSealedClass(Class, where)

Arguments:

       f: The quoted name of the generic function. 

signature: The class names in the method's signature, as they would be
          supplied to 'setMethod'. 

    fdef: Optional, and usually omitted:  the generic function
          definition for 'f'. 

   Class: The quoted name of the class.

   where: where to search for the method or class definition.  By
          default, searches from the top environment of the call to
          'isSealedMethod' or 'isSealedClass', typically the global
          environment or the namespace of a package containing a call
          to one of the functions.

Details:

     In the R implementation of classes and methods, it is possible to
     seal the definition of either a class or a method.  The basic
     classes (numeric and other types of vectors, matrix and array
     data) are sealed.  So also are the methods for the primitive
     functions on those data types.  The effect is that programmers
     cannot re-define the meaning of these basic data types and
     computations.  More precisely, for primitive functions that depend
     on only one data argument, methods cannot be specified for basic
     classes.  For functions (such as the arithmetic operators) that
     depend on two arguments, methods can be specified if _one_ of
     those arguments is a basic class, but not if both are.

     Programmers can seal other class and method definitions by using
     the 'sealed' argument to 'setClass' or 'setMethod'.

Value:

     The functions return 'FALSE' if the method or class is not sealed
     (including the case that it is not defined); 'TRUE' if it is.

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 see '?Methods' and the links from that
     documentation.

Examples:

     ## these are both TRUE
     isSealedMethod("+", c("numeric", "character"))
     isSealedClass("matrix")

     setClass("track",
                 representation(x="numeric", y="numeric"))
     ## but this is FALSE
     isSealedClass("track")
     ## and so is this
     isSealedClass("A Name for an undefined Class")
     ## and so are these, because only one of the two arguments is basic
     isSealedMethod("+", c("track", "numeric"))
     isSealedMethod("+", c("numeric", "track"))

