std.exception

This module defines functions related to exceptions and general error handling. It also defines functions intended to aid in unit testing.

Synopsis of some of std.exception's functions:

string synopsis()
{
   FILE* f = enforce(fopen("some/file"));
   // f is not null from here on
   FILE* g = enforceEx!WriteException(fopen("some/other/file", "w"));
   // g is not null from here on

   Exception e = collectException(write(g, readln(f)));
   if (e)
   {
       ... an exception occurred...
       ... We have the exception to play around with...
   }

   string msg = collectExceptionMsg(write(g, readln(f)));
   if (msg)
   {
       ... an exception occurred...
       ... We have the message from the exception but not the exception...
   }

   char[] line;
   enforce(readln(f, line));
   return assumeUnique(line);
}

License:
Boost License 1.0

Authors:
Andrei Alexandrescu and Jonathan M Davis

Source:
std/exception.d

void assertNotThrown(T : Throwable = Exception, E)(lazy E expression, string msg = null, string file = __FILE__, size_t line = __LINE__);

Asserts that the given expression does not throw the given type of Throwable. If a Throwable of the given type is thrown, it is caught and does not escape assertNotThrown. Rather, an AssertError is thrown. However, any other Throwables will escape.

Parameters:

T	The Throwable to test for.
expression	The expression to test.
msg	Optional message to output on test failure.

Throws:
AssertError if the given Throwable is thrown.

Examples:

assertNotThrown!StringException(enforceEx!StringException(true, "Error!"));

//Exception is the default.
assertNotThrown(enforceEx!StringException(true, "Error!"));

assert(collectExceptionMsg!AssertError(assertNotThrown!StringException(
           enforceEx!StringException(false, "Error!"))) ==
       `assertNotThrown failed: StringException was thrown.`);

void assertThrown(T : Throwable = Exception, E)(lazy E expression, string msg = null, string file = __FILE__, size_t line = __LINE__);

Asserts that the given expression throws the given type of Throwable. The Throwable is caught and does not escape assertThrown. However, any other Throwables will escape, and if no Throwable of the given type is thrown, then an AssertError is thrown.

Parameters:

T	The Throwable to test for.
expression	The expression to test.
msg	Optional message to output on test failure.

Throws:
AssertError if the given Throwable is not thrown.

Examples:

assertThrown!StringException(enforceEx!StringException(false, "Error!"));

//Exception is the default.
assertThrown(enforceEx!StringException(false, "Error!"));

assert(collectExceptionMsg!AssertError(assertThrown!StringException(
           enforceEx!StringException(true, "Error!"))) ==
       `assertThrown failed: No StringException was thrown.`);

pure @safe T enforce(T, string file = __FILE__, size_t line = __LINE__)(T value, lazy const(char)[] msg = null);

If !!value is true, value is returned. Otherwise, new Exception(msg) is thrown.

Note:
enforce is used to throw exceptions and is therefore intended to aid in error handling. It is not intended for verifying the logic of your program. That is what assert is for. Also, do not use enforce inside of contracts (i.e. inside of in and out blocks and invariants), because they will be compiled out when compiling with -release. Use assert in contracts.

Example:

auto f = enforce(fopen("data.txt"));
auto line = readln(f);
enforce(line.length, "Expected a non-empty line.");

T enforce(T, Dg, string file = __FILE__, size_t line = __LINE__)(T value, scope Dg dg);

If !!value is true, value is returned. Otherwise, the given delegate is called.

The whole safety and purity are inferred from Dg's safety and purity.

pure @safe T enforce(T)(T value, lazy Throwable ex);

If !!value is true, value is returned. Otherwise, ex is thrown.

Example:

auto f = enforce(fopen("data.txt"));
auto line = readln(f);
enforce(line.length, new IOException); // expect a non-empty line

pure @safe T errnoEnforce(T, string file = __FILE__, size_t line = __LINE__)(T value, lazy string msg = null);

If !!value is true, value is returned. Otherwise, new ErrnoException(msg) is thrown. ErrnoException assumes that the last operation set errno to an error code.

Example:

auto f = errnoEnforce(fopen("data.txt"));
auto line = readln(f);
enforce(line.length); // expect a non-empty line

template enforceEx(E) if (is(typeof(new E("","std\\exception.d",488))))

If !!value is true, value is returned. Otherwise, new E(msg, file, line) is thrown.

Example:

 auto f = enforceEx!FileMissingException(fopen("data.txt"));
 auto line = readln(f);
 enforceEx!DataCorruptionException(line.length);

template enforceEx(E) if (is(typeof(new E(""))) && !is(typeof(new E("","std\\exception.d",506))))

Deprecated. It will be removed in October 2012. Please use the version of enforceEx which takes an exception that constructs with new E(msg, file, line).

If !!value is true, value is returned. Otherwise, new E(msg) is thrown.

T collectException(T = Exception, E)(lazy E expression, ref E result);

Catches and returns the exception thrown from the given expression. If no exception is thrown, then null is returned and result is set to the result of the expression.

Note that while collectException can be used to collect any Throwable and not just Exceptions, it is generally ill-advised to catch anything that is neither an Exception nor a type derived from Exception. So, do not use collectException to collect non-Exceptions unless you're sure that that's what you really want to do.

Parameters:

T	The type of exception to catch.
expression	The expression which may throw an exception.
result	The result of the expression if no exception is thrown.

Example:

int[] a = new int[3];
int b;
assert(collectException(a[4], b));

T collectException(T : Throwable = Exception, E)(lazy E expression);

Catches and returns the exception thrown from the given expression. If no exception is thrown, then null is returned. E can be void.

Parameters:

T	The type of exception to catch.
expression	The expression which may throw an exception.

string collectExceptionMsg(T = Exception, E)(lazy E expression);

Catches the exception thrown from the given expression and returns the msg property of that exception. If no exception is thrown, then null is returned. E can be void.

If an exception is thrown but it has an empty message, then emptyExceptionMsg is returned.

Note that while collectExceptionMsg can be used to collect any Throwable and not just Exceptions, it is generally ill-advised to catch anything that is neither an Exception nor a type derived from Exception. So, do not use collectExceptionMsg to collect non-Exceptions unless you're sure that that's what you really want to do.

Parameters:

T	The type of exception to catch.
expression	The expression which may throw an exception.

Examples:

void throwFunc() {throw new Exception("My Message.");}
assert(collectExceptionMsg(throwFunc()) == "My Message.");

void nothrowFunc() {}
assert(collectExceptionMsg(nothrowFunc()) is null);

void throwEmptyFunc() {throw new Exception("");}
assert(collectExceptionMsg(throwEmptyFunc()) == emptyExceptionMsg);

string emptyExceptionMsg;

Value that collectExceptionMsg returns when it catches an exception with an empty exception message.

pure nothrow immutable(T)[] assumeUnique(T)(ref T[] array);

Casts a mutable array to an immutable array in an idiomatic manner. Technically, assumeUnique just inserts a cast, but its name documents assumptions on the part of the caller. assumeUnique(arr) should only be called when there are no more active mutable aliases to elements of arr. To strenghten this assumption, assumeUnique(arr) also clears arr before returning. Essentially assumeUnique(arr) indicates commitment from the caller that there is no more mutable access to any of arr's elements (transitively), and that all future accesses will be done through the immutable array returned by assumeUnique.

Typically, assumeUnique is used to return arrays from functions that have allocated and built them.

Example:

 string letters()
 {
   char[] result = new char['z' - 'a' + 1];
   foreach (i, ref e; result)
   {
     e = 'a' + i;
   }
   return assumeUnique(result);
 }

The use in the example above is correct because result was private to letters and is unaccessible in writing after the function returns. The following example shows an incorrect use of assumeUnique.

Bad:

 private char[] buffer;
 string letters(char first, char last)
 {
   if (first >= last) return null; // fine
   auto sneaky = buffer;
   sneaky.length = last - first + 1;
   foreach (i, ref e; sneaky)
   {
     e = 'a' + i;
   }
   return assumeUnique(sneaky); // BAD
 }

The example above wreaks havoc on client code because it is modifying arrays that callers considered immutable. To obtain an immutable array from the writable array buffer, replace the last line with:

 return to!(string)(sneaky); // not that sneaky anymore

The call will duplicate the array appropriately.

Checking for uniqueness during compilation is possible in certain cases (see the unique and lent keywords in the ArchJava language), but complicates the language considerably. The downside of assumeUnique's convention-based usage is that at this time there is no formal checking of the correctness of the assumption; on the upside, the idiomatic use of assumeUnique is simple and rare enough to be tolerable.

pure nothrow @trusted bool pointsTo(S, T, Tdummy = void)(ref const S source, ref const T target);

Returns true if source's representation embeds a pointer that points to target's representation or somewhere inside it. Note that evaluating pointsTo(x, x) checks whether x has internal pointers.

class ErrnoException: object.Exception;

Thrown if errors that set errno occur.

std

etc

core

std.exception