class                  package:base                  R Documentation

_O_b_j_e_c_t _C_l_a_s_s_e_s

_D_e_s_c_r_i_p_t_i_o_n:

     R possesses a simple generic function mechanism which can be used
     for an object-oriented style of programming.  Method dispatch
     takes place based on the class of the first argument to the
     generic function.

_U_s_a_g_e:

     class(x)
     class(x) <- value
     unclass(x)
     inherits(x, what, which = FALSE)

     oldClass(x)
     oldClass(x) <- value

_A_r_g_u_m_e_n_t_s:

       x: a R object

what, value: a character vector naming classes.  'value' can also be
          'NULL'.

   which: logical affecting return value: see 'Details'.

_D_e_t_a_i_l_s:

     Many R objects have a 'class' attribute, a character vector giving
     the names of the classes from which the object _inherits_. If the
     object does not have a class attribute, it has an implicit class,
     '"matrix"', '"array"' or the result of 'mode(x)' (except that
     integer vectors have implicit class '"integer"').  (Functions
     'oldClass' and 'oldClass<-' get and set the attribute, which can
     also be done directly.)

     When a generic function 'fun' is applied to an object with class
     attribute 'c("first", "second")', the system searches for a
     function called 'fun.first' and, if it finds it, applies it to the
     object.  If no such function is found, a function called
     'fun.second' is tried.  If no class name produces a suitable
     function, the function 'fun.default' is used (if it exists).  If
     there is no class attribute, the implicit class is tried, then the
     default method.

     The function 'class' prints the vector of names of classes an
     object inherits from.  Correspondingly, 'class<-' sets the classes
     an object inherits from.  Assigning a zero-length vector or 'NULL'
     removes the class attribute.

     'unclass' returns (a copy of) its argument with its class
     attribute removed.  (It is not allowed for objects which cannot be
     copied, namely environments and external pointers.)

     'inherits' indicates whether its first argument inherits from any
     of the classes specified in the 'what' argument.  If 'which' is
     'TRUE' then an integer vector of the same length as 'what' is
     returned. Each element indicates the position in the 'class(x)'
     matched by the element of 'what'; zero indicates no match. If
     'which' is 'FALSE' then 'TRUE' is  returned by 'inherits' if any
     of the names in 'what' match with any 'class'.

     These functions with the exception of 'inherits' are primitive, so
     argument names are ignored.

_F_o_r_m_a_l _c_l_a_s_s_e_s:

     An additional mechanism of _formal_ classes is available in
     packages 'methods' which is attached by default.  For objects
     which have a formal class, its name is returned by 'class' as a
     character vector of length one.

     The replacement version of the function sets the class to the
     value provided.  For classes that have a formal definition,
     directly replacing the class this way is strongly deprecated.  The
     expression 'as(object, value)' is the way to coerce an object to a
     particular class.

     The analogue of 'inherits' for formal classes is 'is'.

_N_o_t_e:

     Functions 'oldClass' and 'oldClass<-' behave in the same way as
     functions of those names in S-PLUS 5/6, _but_ in R 'UseMethod'
     dispatches on the class as returned by 'class' (with some
     interpolated classes: see the link) rather than 'oldClass'. 
     _However_, group generics dispatch on the 'oldClass' for
     efficiency, and internal generics only dispatch on objects for
     which 'is.object' is true.

_S_e_e _A_l_s_o:

     'UseMethod', 'NextMethod', 'group generic', 'internal generic'

_E_x_a_m_p_l_e_s:

     x <- 10
     class(x) # "numeric"
     oldClass(x) # NULL
     inherits(x, "a") #FALSE
     class(x) <- c("a", "b")
     inherits(x,"a") #TRUE
     inherits(x, "a", TRUE) # 1
     inherits(x, c("a", "b", "c"), TRUE) # 1 2 0