\HeaderA{GenericFunctions}{Tools for Managing Generic Functions}{GenericFunctions}
\aliasA{allGenerics}{GenericFunctions}{allGenerics}
\aliasA{dumpMethod}{GenericFunctions}{dumpMethod}
\aliasA{dumpMethods}{GenericFunctions}{dumpMethods}
\aliasA{findFunction}{GenericFunctions}{findFunction}
\aliasA{getGenerics}{GenericFunctions}{getGenerics}
\aliasA{isGeneric}{GenericFunctions}{isGeneric}
\aliasA{isGroup}{GenericFunctions}{isGroup}
\aliasA{removeGeneric}{GenericFunctions}{removeGeneric}
\aliasA{removeMethods}{GenericFunctions}{removeMethods}
\aliasA{setReplaceMethod}{GenericFunctions}{setReplaceMethod}
\aliasA{signature}{GenericFunctions}{signature}
\keyword{programming}{GenericFunctions}
\keyword{classes}{GenericFunctions}
\keyword{methods}{GenericFunctions}
\begin{Description}\relax
The functions documented here manage collections of methods associated
with a generic function, as well as providing information about the
generic functions themselves.
\end{Description}
\begin{Usage}
\begin{verbatim}
isGeneric(f, where, fdef, getName = FALSE)
isGroup(f, where, fdef)
removeGeneric(f, where)

dumpMethod(f, signature, file, where, def)
findFunction(f, generic = TRUE, where = topenv(parent.frame()))
dumpMethods(f, file, signature, methods, where)
signature(...)

removeMethods(f, where = topenv(parent.frame()), all = missing(where))
setReplaceMethod(f, ..., where = topenv(parent.frame()))

getGenerics(where, searchForm = FALSE)
\end{verbatim}
\end{Usage}
\begin{Arguments}
\begin{ldescription}
\item[\code{f}] The character string naming the function. 
\item[\code{where}] The environment, name space, or search-list position
from which to search for objects.  By default, start at the
top-level environment of the calling function, typically the global
environment (i.e., use the search list), or the name space of a
package from which the call came.  It is important to supply this
argument when calling any of these functions indirectly.  With
package name spaces, the default is likely to be wrong in such calls.
\item[\code{signature}] The class signature of the relevant method.  A
signature is a named or unnamed vector of character strings.  If
named, the names must be formal argument names for the generic
function.  If \code{signature} is unnamed, the default is to use
the first \code{length(signature)} formal arguments of the
function. 
\item[\code{file}] The file or connection on which to dump method definitions. 
\item[\code{def}] The function object defining the method; if omitted, the
current method definition corresponding to the signature. 
\item[\code{...}] Named or unnamed arguments to form a signature.
\item[\code{generic}] In testing or finding functions, should generic
functions be included.  Supply as \code{FALSE} to get only
non-generic functions.
\item[\code{fdef}] Optional, the generic function definition.

Usually omitted in calls to \code{isGeneric}
\item[\code{getName}] If \code{TRUE}, \code{isGeneric} returns the name of
the generic.  By default, it returns \code{TRUE}. 
\item[\code{methods}] The methods object containing the methods to be dumped.  By default,
the methods defined for this generic (optionally on the specified
\code{where} location).

\item[\code{all}] in \code{removeMethods}, logical indicating if all
(default) or only the first method found should be removed.
\item[\code{searchForm}] In \code{getGenerics}, if \code{TRUE}, the
\code{package} slot of the returned result is in the form used
by \code{search()}, otherwise as the simple package name (e.g,
\code{"package:base"} vs \code{"base"}).

\end{ldescription}
\end{Arguments}
\begin{Section}{Summary of Functions}
\describe{
\item[\code{isGeneric}:] Is there a function named \code{f}, and if so, is it a generic?

The \code{getName} argument allows a function to find the name
from a function definition.  If it is \code{TRUE} then the name of
the generic is returned, or \code{FALSE} if this is not a generic
function definition.

The behavior of \code{isGeneric} and \code{\LinkA{getGeneric}{getGeneric}} for
primitive functions is slightly different.  These functions don't
exist as formal function objects (for efficiency and historical
reasons), regardless of whether methods have been defined for
them.  A call to \code{isGeneric} tells you whether methods have
been defined for this primitive function, anywhere in the current
search list, or in the specified position \code{where}.  In
contrast, a call to \code{\LinkA{getGeneric}{getGeneric}} will return what the
generic for that function would be, even if no methods have been
currently defined for it.


\item[\code{removeGeneric}, \code{removeMethods}:] Remove all the methods for the generic function of this
name.  In addition, \code{removeGeneric} removes the function
itself; \code{removeMethods} restores the non-generic function
which was the default method.   If there was no default method,
\code{removeMethods} leaves a generic function with no methods.

\item[\code{standardGeneric}:] Dispatches a method from the current function call for the generic
function \code{f}.  It is an error to call
\code{standardGeneric} anywhere except in the body of the
corresponding generic function.

Note that \code{\LinkA{standardGeneric}{standardGeneric}} is a primitive function in
the \pkg{base} package
for efficiency 
reasons, but rather documented here where it belongs naturally.

\item[\code{dumpMethod}:] Dump the method for this generic function and signature.

\item[\code{findFunction}:] return a list of either the positions on the search list, or the
current top-level environment, on which a function object
for \code{name} exists.  The returned value is \emph{always} a
list, use the first element to access the first visible version
of the function.  See the example.

\emph{NOTE:} Use this rather than \code{\LinkA{find}{find}} with
\code{mode="function"}, which is not as meaningful, and has a few
subtle bugs from its use of regular expressions.  Also,
\code{findFunction} works correctly in the code for a package
when attaching the package via a call to \code{\LinkA{library}{library}}.

\item[\code{dumpMethods}:] Dump all the methods for this generic.

\item[\code{signature}:] Returns a named list of classes to be matched to arguments of a
generic function.

\item[\code{getGenerics}:] returns the names of the generic
functions that have methods defined on \code{where}; this
argument can be an environment or an index into the search
list.  By default, the whole search list is used.
(\code{allGenerics()} is a \emph{deprecated} alias for \code{getGenerics}.)

The methods definitions are stored with
package qualifiers; for example, methods for function
\code{"initialize"} might refer to two different functions
of that name, on different packages.  The package names
corresponding to the method list object are contained in the
slot \code{package} of the returned object.  The form of
the returned name can be plain (e.g., \code{"base"}), or in
the form used in the search list (\code{"package:base"})
according to the value of \code{searchForm}

}
\end{Section}
\begin{Section}{Details}
\describe{
\item[\code{setGeneric}:] If there is already a non-generic function of this name, it will
be used to define the generic unless \code{def} is supplied, and
the current function will become the default method for the
generic.

If \code{def} is supplied, this defines the generic function, and
no default method will exist (often a good feature, if the
function should only be available for a meaningful subset of all
objects).

Arguments \code{group} and \code{valueClass} are retained for
consistency with S-Plus, but are currently not used.

\item[\code{isGeneric}:] If the \code{fdef} argument is supplied, take this as the
definition of the generic, and test whether it is really a
generic, with \code{f} as the name of the generic.  (This argument
is not available in S-Plus.)

\item[\code{removeGeneric}:] If \code{where} supplied, just remove the version on this element
of the search list; otherwise, removes the first version
encountered.

\item[\code{standardGeneric}:] Generic functions should usually have a call to
\code{standardGeneric} as their entire body.  They can, however,
do any other computations as well.

The usual \code{setGeneric} (directly or through calling
\code{setMethod}) creates a function with a call to
\code{standardGeneric}.

\item[\code{dumpMethod}:] The resulting source file will recreate the method.

\item[\code{findFunction}:] If \code{generic} is \code{FALSE}, ignore generic functions.

\item[\code{dumpMethods}:] If \code{signature} is supplied only the methods matching this
initial signature are dumped.  (This feature is not found in
S-Plus:  don't use it if you want compatibility.)

\item[\code{signature}:] The advantage of using \code{signature} is to provide a check on
which arguments you meant, as well as clearer documentation in
your method specification.  In addition, \code{signature} checks
that each of the elements is a single character string.

\item[\code{removeMethods}:] Returns \code{TRUE} if \code{f} was a generic function,
\code{FALSE} (silently) otherwise.

If there is a default method, the function will be re-assigned as
a simple function with this definition.
Otherwise, the generic function remains but with no methods (so
any call to it will generate an error).  In either case, a
following call to \code{setMethod} will consistently
re-establish the same generic function as before.

}
\end{Section}
\begin{References}\relax
Chambers, John M. (2008)
\emph{Software for Data Analysis: Programming with R}
Springer.  (For the R version.)

Chambers, John M. (1998)
\emph{Programming with Data}
Springer (For the original S4 version.)
\end{References}
\begin{SeeAlso}\relax
\code{\LinkA{getMethod}{getMethod}} (also for \code{selectMethod}),
\code{\LinkA{setGeneric}{setGeneric}},
\code{\LinkA{setClass}{setClass}},
\code{\LinkA{showMethods}{showMethods}}
\end{SeeAlso}
\begin{Examples}
\begin{ExampleCode}
require(stats) # for lm

## get the function "myFun" -- throw an error if 0 or > 1 versions visible:
findFuncStrict <- function(fName) {
  allF <- findFunction(fName)
  if(length(allF) == 0)
    stop("No versions of ",fName," visible")
  else if(length(allF) > 1)
    stop(fName," is ambiguous: ", length(allF), " versions")
  else
    get(fName, allF[[1]])
}

try(findFuncStrict("myFun"))# Error: no version
lm <- function(x) x+1
try(findFuncStrict("lm"))#    Error: 2 versions
findFuncStrict("findFuncStrict")# just 1 version
rm(lm)



## method dumping ------------------------------------

setClass("A", representation(a="numeric"))
setMethod("plot", "A", function(x,y,...){ cat("A meth\n") })
dumpMethod("plot","A", file="")
## Not run: 
setMethod("plot", "A",
function (x, y, ...)
{
    cat("AAAAA\n")
}
)
## End(Not run)
tmp <- tempfile()
dumpMethod("plot","A", file=tmp)
## now remove, and see if we can parse the dump
stopifnot(removeMethod("plot", "A"))
source(tmp)
stopifnot(is(getMethod("plot", "A"), "MethodDefinition"))

## same with dumpMethods() :
setClass("B", contains="A")
setMethod("plot", "B", function(x,y,...){ cat("B ...\n") })
dumpMethods("plot", file=tmp)
stopifnot(removeMethod("plot", "A"),
          removeMethod("plot", "B"))
source(tmp)
stopifnot(is(getMethod("plot", "A"), "MethodDefinition"),
          is(getMethod("plot", "B"), "MethodDefinition"))
\end{ExampleCode}
\end{Examples}

