Description

Usage

computeRestarts(cond = NULL)
conditionCall(c)
conditionMessage(c)
findRestart(name, cond = NULL)
invokeRestart(r, ...)
tryInvokeRestart(r, ...)
invokeRestartInteractively(r)
isRestart(x)
restartDescription(r)
restartFormals(r)
signalCondition(cond)
simpleCondition(message, call = NULL)
simpleError(message, call = NULL)
simpleWarning(message, call = NULL)
simpleMessage(message, call = NULL)
errorCondition(msg, ..., class = NULL, call = NULL)
warningCondition(msg, ..., class = NULL, call = NULL)
tryCatch(expr, ..., finally)
withCallingHandlers(expr, ...)
globalCallingHandlers(...)
withRestarts(expr, ...)
.signalSimpleWarning(msg, call)
.handleSimpleError(h, msg, call)
## S3 method for class 'condition':
as.character(x, ...)
## S3 method for class 'error':
as.character(x, ...)
## S3 method for class 'condition':
conditionCall(c)
## S3 method for class 'condition':
conditionMessage(c)
## S3 method for class 'condition':
print(x, ...)
## S3 method for class 'restart':
print(x, ...)

Arguments

Details

# create an "error" condition handler, called when processing error
withCallingHandlers(stop("xyz"), error=function(e) cat("<error>"))
# prints <error>, then processes the error as normal
# multiple condition handlers can match same condition,
# matching different names in the simpleError condition object.
withCallingHandlers(stop("xyz"),
         simpleError=function(e) cat("<simpleError>"),
         condition=function(e) cat("<condition>"))
# prints <simpleError><condition>, then processes the error as normal
# signalling a condition within a condition handler will scan
# handlers starting after the current handler
withCallingHandlers(stop("xyz"),
         simpleError=function(e) {cat("<simpleError>");signalCondition(e)},
         condition=function(e) cat("<condition>"))
# prints <simpleError><condition><condition>,
# then processes the error as normal
# tryCatch will "catch" its first matching condition handler
# and return its result
tryCatch(stop("xyz"),
         error=function(e) {cat("<error>");123L},
         condition=function(e) {cat("<condition>");456L})
# prints <error>, then returns 123L without processing the error
# nest withCallingHandlers within tryCatch
tryCatch(withCallingHandlers(stop("xyz"),
           simpleError=function(e) {cat("<simpleError>");signalCondition(e)},
           condition=function(e) cat("<condition>")),
         error=function(e) {cat("<error>");123L})
# prints <simpleError><condition><error>,
# then returns 123L without processing the error
# the tryCatch "finally" expression is evaluated when tryCatch returns
tryCatch(stop("xyz"),
         error=function(e) {cat("<error>");123L},
         finally=cat("<finally>"))
# prints <error><finally>,
# then returns 123L without processing the error
# the tryCatch "finally" expression is evaluated when tryCatch returns,
# even if no condition handlers are caught
tryCatch({cat("<expr>");999L},
         error=function(e) {cat("<error>");123L},
         finally=cat("<finally>"))
# prints <expr><finally>, then returns 999L
# use signalCondition to throw user-defined condition
myCondition <- function(message, call=NULL)
  structure(list(message=message, call=call),
            class=c("myCondition", "condition"))
tryCatch(signalCondition(myCondition("foo")),
         myCondition=function(cond) {cat("<my>");123L})
# prints <my>, and returns 123L
# invokeRestart gives an error if a named restart is not found
withRestarts(invokeRestart("noSuchRestart", 123L, 456L),
             foo=function(a,b) c(a,b))
# produces an error: restart not found
# call invokeRestart to jump to restart handler, passing arguments
withRestarts({cat("<start>");invokeRestart("foo", 123L, 456L);789L},
             foo=function(a,b) c(a,b))
# prints <start>, then returns c(123L, 456L)
# restart handler can be specified as a list with restart object fields
withRestarts({cat("<start>");invokeRestart("foo", 123L, 456L);789L},
             foo=list(description="my handler", handler=function(a,b) c(a,b)))
# prints <start>, then returns c(123L, 456L)
# a restart handler can invoke another one passing different arguments
withRestarts({cat("<start>");invokeRestart("foo", 123L, 456L);789L},
             foo=function(a,b) {cat("<first>");invokeRestart("foo", a+1, b+1)},
             foo=function(a,b) {cat("<second>");c(a,b)})
# prints <start><first><second>, then returns c(124L, 457L)
# call invokeRestartInteractively to interactively specify restart arguments
withRestarts(invokeRestartInteractively("foo"),
             foo=function(a,b) c(a,b))
# displayed text, entering "123" and "4+5" as values:
#   Enter values for restart arguments:
#   
#   a: 123
#   b: 4+5
#   [1] 123   9
# searching for a restart, when none is defined
withRestarts(findRestart("noSuchRestart"),
             foo=function(a,b) c(a,b))
# returns NULL, since there is no restart with name "noSuchRestart"       
# searching for a defined restart
withRestarts(findRestart("foo"),
             foo=function(a,b) c(a,b))
# returns a list object with class "restart", and including
# elements name="foo" and handler=function(a,b) c(a,b)
# find all active restarts
withRestarts(computeRestarts(),
             foo=function(a,b) c(a,b))
# returns a list with a restart named "foo", and ending with
# the top-level "abort" restart.
# warning function signals simpleWarning condition
withCallingHandlers({warning("foo");123L},
                    warning=function(e) {cat("<warn>")})
# prints <warn>, prints warning "foo", then returns 123L.
# invoke "muffleWarning" restart to prevent printing warning
withCallingHandlers({warning("foo");123L},
                    warning=function(e) {
                       cat("<warn>")
                       invokeRestart("muffleWarning")
                    })
# prints <warn>, then returns 123L.
# message function signals simpleMessage condition
withCallingHandlers({message("foo");123L},
                    message=function(e) {cat("<msg>")})
# prints <msg>, prints message "foo", then returns 123L.
# invoke "muffleMessage" restart to prevent printing message
withCallingHandlers({message("foo");123L},
                    message=function(e) {
                       cat("<msg>")
                       invokeRestart("muffleMessage")
                    })
# prints <msg>, then returns 123L.
# can muffle packageStartupMessage message without muffling other messages
withCallingHandlers({message("foo");packageStartupMessage("bar");123L},
                    packageStartupMessage=function(e) {
                       cat("<msg>")
                       invokeRestart("muffleMessage")
                    })
# print message "foo", then <msg>, then return 123L
# define an interrupt condition handler to resume an interupted computation
withCallingHandlers(for(x in 1:10){print(x);Sys.sleep(1)},
    interrupt=function(ex){cat("<interrupt>");invokeRestart("resume")})
# on an interrupt, print <interrupt> and continue the loop