Manipulação de exceção e desenrolar a pilha em R

Question

A fim de estabelecer um conjunto coerente de manuseio de exceção de interface para os meus colegas e os meus R scripts, eu gostaria de empregar a seguinte tryCatch estrutura.

1. Exterior tryCatch é enrolado em torno de um dado R script.Ele é usado para capturar e manipular erros fatais que exigem o script para abortar.
2. Específicas do utilizador tryCatch comandos dentro do utilizador scripts.Estes devem pegar e, eventualmente, lidar com
   • 2a.erros não fatais, onde nenhum script aborto é necessário
   • 2b.fatal-erros que exigem o script para abortar.O erro é tratado pelo exterior tryCatch [1.]
   • 2c.fatal-erros com informações de erro adicionais.Erro tratada pelo exterior tryCatch.

O código a seguir é como eu gostaria de implementar estas funcionalidades.No entanto, como eu não sou um perito em R, eu gostaria de perguntar se essa é uma boa abordagem.Especificamente:

Q1.É ok para não especificar um manipulador de erro no interior tryCatch e esperar para o exterior tryCatch para lidar com esse erro (ver 2b.acima e abaixo do código)?

Q2.É rethrowing o mesmo erro (consulte 2c.acima/abaixo) dentro de um manipulador de corrigir/considerado bom estilo de codificação?

Obrigado!

#outer tryCatch, see 1.
tryCatch({
  #user code block
  #2a. user specific tryCatch, object "vec" not defined
  tryCatch(print(vec),error=function(e) {print("Non-fatal error. Script execution continued.");print(e);})

  #2b. user specific tryCatch
  tryCatch(vec*2)

  #2c. user specific tryCatch
  tryCatch(vec*parameter1, error=function(e) {print("Additional fatal error information. Script execution aborted.");stop(e);})
  #end of user code block
},
     #outer tryCatch error handler in order to handle fatal errors
     error=function(e) {print("Fatal error");print(e);} 
    )

Answer 1

É perfeitamente possível pegar apenas alguns erros, deixando outras para o exterior manipulador ou nenhum manipulador de todos.O erro do sistema é um pouco mais flexível do que o normalmente usado, portanto, para re-lançar um erro que você poderia pensar em criar o seu próprio tipo de erro

ourError <-
    function(original, message, class="ourError")
{
    msg <- paste(message, conditionMessage(original), sep="\n  ")
    structure(list(message = msg, call = conditionCall(original)),
              class = c(class, class(original)))
}

e jogando e / ou manipulação de

tryCatch(vec*parameter1, error=function(e) {
    err <- ourError(e, "addition fatal info; script aborted")
    stop(err)
})

Uma vantagem é que outros comportamentos podem ser especificada no nível superior do processador, usando a classe devolvidos por ourError()

tryCatch({
    tryCatch(stop("oops"), error=function(e) {
        err <- ourError(e, "addition fatal info; script aborted",
                      c("fatal", "ourError"))
        stop(err)
    })
}, ourError=function(err) {
    message("We caught but didn't handle this:\n", err)
}, error =function(err) {
    message("This one got away: ", err)
})