The R Project SVN – R – Diff – /trunk/src/library/methods/man/initialize-methods.Rd

 \alias{initialize-methods}
 \alias{initialize,ANY-method}
 \alias{initialize,traceable-method}
 \alias{initialize,signature-method}
 \alias{initialize,environment-method}
+\description{
-\description{The arguments to function \code{\link{new}} to create an
+  The arguments to function \code{\link{new}} to create an object from a
-object from a particular class can be interpreted specially for that
+  particular class can be interpreted specially for that class, by the
-class, by the definition of a method for function \code{initialize}
+  definition of a method for function \code{initialize} for the class.
-for the class.  This documentation describes some existing
+  This documentation describes some existing methods, and also outlines
-methods, and also outlines how to write new ones.
+  how to write new ones.
+}
-\section{Methods}{\describe{
+\section{Methods}{
+  \describe{
+    \item{.Object = "ANY"}{
-\item{.Object = "ANY"}{The default method for \code{initialize} takes
+      The default method for \code{initialize} takes either named or
-    either named or unnamed arguments.  Argument names must be the
+      unnamed arguments.  Argument names must be the names of slots in
-    names of slots in this class definition, and the corresponding
+      this class definition, and the corresponding arguments must be
-    arguments must be valid objects for the slot (that is, have the
+      valid objects for the slot (that is, have the same class as
-    same class as specified for the slot, or some superclass of that
+      specified for the slot, or some superclass of that class).  If the
-    class). If the object comes from a superclass, it is not coerced
+      object comes from a superclass, it is not coerced strictly, so
-    strictly, so normally it will retain its current class (specifically,
+      normally it will retain its current class (specifically,
-    \code{\link{as}(object, Class, strict = FALSE)}).
+      \code{\link{as}(object, Class, strict = FALSE)}).
-    Unnamed arguments must be objects of this class, of one of its
+      Unnamed arguments must be objects of this class, of one of its
-    superclasses, or one of its subclasses (from the class, from a
+      superclasses, or one of its subclasses (from the class, from a
-    class this class extends, or from a class that extends this
+      class this class extends, or from a class that extends this
-    class). If the object is from a superclass, this normally defines
+      class). If the object is from a superclass, this normally defines
-    some of the slots in the object.  If the object is from a
+      some of the slots in the object.  If the object is from a
-    subclass, the new object is that argument, coerced to the current
+      subclass, the new object is that argument, coerced to the current
-    class.
+      class.
-    Unnamed arguments are processed first, in the order they appear.
+      Unnamed arguments are processed first, in the order they appear.
-    Then named arguments are processed.  Therefore, explicit values
+      Then named arguments are processed.  Therefore, explicit values
-    for slots always override any values inferred from superclass or
+      for slots always override any values inferred from superclass or
-    subclass arguments.
+      subclass arguments.
+    }
+    \item{.Object = "traceable"}{
+      Objects of a class that extends \code{traceable} are used to
+      implement debug tracing (see \link{traceable-class} and
+      \code{\link[base]{trace}}).
+      The \code{initialize} method for these classes takes special
+      arguments \code{def, tracer, exit, at, print}.  The first of these
+      is the object to use as the original definition (e.g., a
+      function).  The others correspond to the arguments to
+      \code{\link[base]{trace}}.
+    }
+    \item{.Object = "environment"}{
+      The \code{initialize} method for environments takes a named list
+      of objects to be used to initialize the environment.
+    }
+    \item{.Object = "signature"}{
+      This is a method for internal use only.
+      It takes an optional \code{functionDef} argument to provide a
+      generic function with a \code{signature} slot to define the
+      argument names.  See \link{Methods} for details.
+    }
+  }
+}
-\item{.Object = "traceable"}{ Objects of a class that extends
- \code{traceable} are used to implement debug tracing (see
- \link{traceable-class} and \code{\link[base]{trace}}).
-The \code{initialize} method for these classes takes special arguments
-\code{def, tracer, exit, at, print}.  The first of these is the object
-to use as the original definition (e.g., a function).  The others
-correspond to the arguments to \code{\link[base]{trace}}.
- }
-\item{.Object = "environment"}{The \code{initialize} method for
-    environments takes a named list of objects to be used to
-    initialize the environment. }
-\item{.Object = "signature"}{ This is a method for internal use only.
- It takes an optional \code{functionDef} argument to provide a generic
- function with a \code{signature} slot to define the argument names.
- See \link{Methods} for details.
- }
-}}
-\section{Writing Initialization Methods}{Initialization methods
+\section{Writing Initialization Methods}{
-  provide a general mechanism corresponding to generator functions in
+  Initialization methods provide a general mechanism corresponding to
-  other languages.
+  generator functions in other languages.
   The arguments to \code{\link{initialize}} are \code{.Object} and
   \dots. Nearly always, \code{initialize} is called from \code{new},
   not directly.  The \code{.Object} argument is then the
   prototype object from the class.
   your method definition, in addition to \code{.Object} (always) and
   \dots (optionally).  For example, the method for class
   \code{"traceable"} documented above would be created by a call to
   \code{\link{setMethod}} of the form:
+  \preformatted{
-\code{setMethod("initialize", "traceable",}
+    setMethod("initialize", "traceable",
-\cr
-\code{    function(.Object, def, tracer, exit, at, print) } \dots
+      function(.Object, def, tracer, exit, at, print) \dots
-\cr
+    )
-\code{)}
+  }
-In this example, no other arguments are meaningful, and the resulting
+  In this example, no other arguments are meaningful, and the resulting
-method will throw an error if other names are supplied.
+  method will throw an error if other names are supplied.
-When your new class extends another class, you may want to call the
+  When your new class extends another class, you may want to call the
-initialize method for this superclass (either a special method or the
+  initialize method for this superclass (either a special method or the
-default).  For example, suppose you want to define a method for your
+  default).  For example, suppose you want to define a method for your
-class, with special argument \code{x}, but you also want users to be
+  class, with special argument \code{x}, but you also want users to be
-able to set slots specifically.  If you want \code{x} to override the
+  able to set slots specifically.  If you want \code{x} to override the
-slot information, the beginning of your method definition might look
+  slot information, the beginning of your method definition might look
-something like this:
+  something like this:
+  \preformatted{
-\code{function(.Object, x, ...) \{}
+    function(.Object, x, ...) \{
-\cr
-\code{    Object <- callNextMethod(.Object, ...) }
+      Object <- callNextMethod(.Object, ...)
-\cr
-\code{    if(!missing(x)) \{ # do something with x }
+      if(!missing(x)) \{ # do something with x
+  }
-You could also choose to have the inherited method override, by first
+  You could also choose to have the inherited method override, by first
-interpreting \code{x}, and then calling the next method.
+  interpreting \code{x}, and then calling the next method.
+}
 \keyword{methods}
 \keyword{programming}

The R Project SVN R

(root)/trunk/src/library/methods/man/initialize-methods.Rd – Rev 25816 → 26610