How to handle try-catch blocks, nothrow and logfiles

[Ali Çehreli via Digitalmars-d-learn]

On 05/24/2014 10:09 AM, Tim wrote:

 > I'm working on an application where I want log all exceptions but I'm
 > not sure what's the best way to realize that.

A common solution is to log it in the exception class'es constructor. We 
even dump the backtrace with libunwind in our C++ application.

However, you may quickly realize that not every thrown exception is 
log-worthy. The reason is, e.g. a MyMissingFile exception may not be 
important when there is a default action to follow. No need to log in 
that case.

Just to note, although these are valid issues, exceptions are still the 
best option for error handling.

 > Sure I can do the following:
 >
 > void myMethod() nothrow
 > {
 >     try
 >     {
 >       // Do something
 >     }
 >     catch (Exception e)
 >     {
 >       // Write log file
 >     }
 > }

As you say, that does not scale. :)

 > 2) When I want create an application where all methods are defined
 > as >nothrow< - how can I realize that? Writing to a log-file is already
 > throwable.

You can bypass the compiler by wrapping the throwing expression in 
assumeWontThrow (as I have shown just yesterday during my DConf 
lightning talk. How timely... :))

Contrary to its name assumeWontThrow throws an Error (not Exception) if 
the expression actually throws.

// This function requires that the argument is less than 10
void bar(int i)
{
     import std.exception : enforce;

     enforce(i < 10);
     // ...
}

void foo() nothrow
{
     import std.exception : assumeWontThrow;

     // I know that bar(7) won't throw. So, it's
     // safe to bypass the compiler in this case.
     assumeWontThrow(bar(7));

     /* Note: UFCS may look less natural:
      *
      *     bar(7).assumeWontThrow;
      *
      * bar(7) is NOT executed before assumeWontThrow. Rather, 
assumeWontThrow
      * takes a lazy parameter. So, bar(7) is assumed to be nothrow.
      */

     // ...
}

void main()
{
     foo();
}

Ali