| % File src/library/methods/man/showMethods.Rd |
| % Part of the R package, https://www.R-project.org |
| % Copyright 1995-2016 R Core Team |
| % Distributed under GPL 2 or later |
| |
| \name{showMethods} |
| \alias{showMethods} |
| \alias{.S4methods} |
| \title{Show all the methods for the specified function(s) or class} |
| \description{ |
| Show a summary of the methods for one or more generic functions, |
| possibly restricted to those involving specified classes. |
| } |
| \usage{ |
| showMethods(f = character(), where = topenv(parent.frame()), |
| classes = NULL, includeDefs = FALSE, |
| inherited = !includeDefs, |
| showEmpty, printTo = stdout(), fdef) |
| .S4methods(generic.function, class) |
| } |
| \arguments{ |
| \item{f}{one or more function names. If omitted, all functions |
| will be shown that match the other arguments. |
| |
| The argument can also be an expression that evaluates to a single |
| generic function, in which |
| case argument \code{fdef} is ignored. Providing an expression for |
| the function allows examination of hidden or anonymous functions; |
| see the example for \code{isDiagonal()}.} |
| \item{where}{Where to find the generic function, if not supplied as an |
| argument. When \code{f} is missing, or length 0, this also |
| determines which generic functions to examine. If \code{where} is |
| supplied, only the generic functions returned by |
| \code{getGenerics(where)} are eligible for printing. If |
| \code{where} is also missing, all the cached generic functions are |
| considered.} |
| \item{classes}{If argument \code{classes} is supplied, it is a vector |
| of class names that restricts the displayed results to those methods |
| whose signatures include one or more of those classes.} |
| \item{includeDefs}{If \code{includeDefs} is \code{TRUE}, include the |
| definitions of the individual methods in the printout.} |
| \item{inherited}{logical indicating if methods that have been found by |
| inheritance, so far in the session, will be included and marked as |
| inherited. Note that an inherited method will not usually appear |
| until it has been used in this session. See |
| \code{\link{selectMethod}} if you want to know what method would be |
| dispatched for particular classes of arguments.} |
| \item{showEmpty}{logical indicating whether methods with no defined |
| methods matching the other criteria should be shown at all. By |
| default, \code{TRUE} if and only if argument \code{f} is not |
| missing.} |
| \item{printTo}{The connection on which the information will be |
| shown; by default, on standard output.} |
| \item{fdef}{Optionally, the generic function definition to use; if |
| missing, one is found, looking in \code{where} if that is specified. |
| See also comment in \sQuote{Details}.} |
| \item{generic.function, class}{See \code{methods}.} |
| } |
| \details{ |
| See \code{methods} for a description of \code{.S4methods}. |
| |
| The name and package of the generic are followed by the list of |
| signatures for which methods are currently defined, according to the |
| criteria determined by the various arguments. Note that the package |
| refers to the source of the generic function. Individual methods |
| for that generic can come from other packages as well. |
| |
| When more than one generic function is involved, either as specified or |
| because \code{f} was missing, the functions are found and |
| \code{showMethods} is recalled for each, including the generic as the |
| argument \code{fdef}. In complicated situations, this can avoid some |
| anomalous results. |
| } |
| \value{ |
| If \code{printTo} is \code{FALSE}, the character vector that would |
| have been printed is returned; otherwise the value is the connection |
| or filename, via \code{\link{invisible}}. |
| } |
| \references{ |
| 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.) |
| } |
| \seealso{ |
| \code{\link{setMethod}}, and \code{\link{GenericFunctions}} |
| for other tools involving methods; |
| \code{\link{selectMethod}} will show you the method dispatched for a |
| particular function and signature of classes for the arguments. |
| |
| \code{\link{methods}} provides method discovery tools for light-weight |
| interactive use. |
| } |
| \examples{ |
| require(graphics) |
| \dontshow{ |
| setClass("track", slots = c(x="numeric", y="numeric")) |
| ## First, with only one object as argument: |
| setMethod("plot", signature(x="track", y="missing"), |
| function(x, y, ...) plot(slot(x, "x"), slot(x, "y"), ...)) |
| ## Second, plot the data from the track on the y-axis against anything |
| ## as the x data. |
| setMethod("plot", signature(y = "track"), |
| function(x, y, ...) plot(x, slot(y, "y"), ...)) |
| setMethod("plot", "track", |
| function(x, y, ...) plot(slot(x, "y"), y, ...)) |
| } |
| ## Assuming the methods for plot |
| ## are set up as in the example of help(setMethod), |
| ## print (without definitions) the methods that involve class "track": |
| showMethods("plot", classes = "track") |
| \dontrun{ |
| # Function "plot": |
| # x = ANY, y = track |
| # x = track, y = missing |
| # x = track, y = ANY |
| |
| require("Matrix") |
| showMethods("\%*\%")# many! |
| methods(class = "Matrix")# nothing |
| showMethods(class = "Matrix")# everything |
| showMethods(Matrix:::isDiagonal) # a non-exported generic |
| }%end{dontrun} |
| |
| %% An example of showing methods from a loaded, |
| %% but not attached namespace. |
| if(no4 <- is.na(match("stats4", loadedNamespaces()))) |
| loadNamespace("stats4") |
| showMethods(classes = "mle") # -> a method for show() |
| if(no4) unloadNamespace("stats4") |
| } |
| \keyword{methods} |