Assert.h

Classes

assert_ -- Utility class for Assert macros. (full description)

template<class t> class assert_

Interface

Public Members

assert_(int expr, const char *msg)

assert_(const void *ptr, const char *msg)

assert_(int expr, const char *msg, const char* file, Int line)

assert_(const void *ptr, const char *msg, const char* file, Int line)

void null()

Description

Review Status

Reviewed By:

Friso Olnon

Date Reviewed:

1995/03/13

Prerequisite

• module Exceptions

Etymology

Synopsis

DebugAssertExit(expr)

AlwaysAssertExit(expr)

cause the program to abort if expr evaluates to a null value. This form is intended for the end users because presumabily at their level there is no way to recover from errors.

DebugAssert(expr, exception)

AlwaysAssert(expr, exception)

throw the specified exception if the expr is null. This form is designed to be used by library elements because it actually raises an exception which can be later caught in the regular way.

DebugAssertExit and DebugAssert are only invoked in debug mode (i.e. when AIPS_DEBUG is defined); otherwise they preprocess to null statements. AlwaysAssertExit and AlwaysAssert are always invoked.

Class assert_ is internal to the Assertion mechanism and should be undocumented. However, documenting the class is the only way to document this mechanism, which for the rest consists of preprocessor macros.

Example

I thought I'd readvertise a technique I use that helps me find problems in the classes I write. I have found this to be an EXTREMELY useful way of discovering bugs automatically (so the users of your class don't have to manually).

In your class, write an ok() member function that returns a Bool. Allow for inheritance and make it a virtual function (in fact, the derived class's ok() would probably call the ok() from it's parent, as well as doing specific stuff for the derived class).

Then in every member function, place a call to ok() in an Assertion. Like this:

    DebugAssert(ok(), AipsError);  // include aips/Assert.h in your .cc file
    

The second argument is the exception you want to throw. AipsError will always do, although you can throw a more particular one if you want to. This Assertion will not be in production code -- i.e. if AIPS_DEBUG is not defined, the above line will be a null statement. I place these lines at the entry to all member functions (except I place them at the end of a constructor!). (I normally don't put an Assertion in an inline function).

In the ok() function you should Assert a class's invariants. This is more or less the same as Asserting that an object's private and protected data are consistent. For example, one of the simple tests I do in the array classes is Assert that the number of elements (which I cache) is indeed equal to the product of its shape (I do ~15 tests in the ok() for the new Array<T> class).

Member Description

assert_(int expr, const char *msg)
assert_(const void *ptr, const char *msg)
assert_(int expr, const char *msg, const char* file, Int line)
assert_(const void *ptr, const char *msg, const char* file, Int line)

void null()

A no-op, but it keeps g++ from complaining about "variable not used" errors