Loading...
Searching...
No Matches
casacore::assert_< t > Class Template Reference
casa package (libcasa_casa) » Utilities_module

More...

`#include <Assert.h>`

## Public Member Functions

| 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.

## Detailed Description

template<class t>
class casacore::assert_< t >

Utility class for Assert macros.

### Intended use:

Public interface

### Review Status

Reviewed By:
  Friso Olnon
Date Reviewed:
  1995/03/13

### Prerequisite

- module Exceptions

### Etymology

Templated class assert_ is the basis for the macros DebugAssertExit, DebugAssert, AlwaysAssertExit, and AlwaysAssert which form the "public interface" to the Assertion mechanism.

### Synopsis

The present Assertion mechanism uses the exception handling mechanism to throw the errors when an Assertion fails. It can be used in two ways:

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.

Tip: 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;

Tip: 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

The implementation of the Array classes contains many examples of the Assertion mechanism. The following application of the Assertion mechanism is taken from the archive of the aips2.nosp@m.-wor.nosp@m.kers@.nosp@m.nrao.nosp@m..edu mail group (Brian Glendenning, 1994/03/23):

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 its 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
DebugAssert
#define DebugAssert(expr, exception)
Definition Assert.h:183
casacore::AipsError
Definition Error.h:133

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).

Definition at line 126 of file Assert.h.

## Constructor & Destructor Documentation

## assert_() [1/4]

template<class t>

casacore::assert_< t >::assert_ | ( | int | expr,
|  | const char * | msg )

inline

Definition at line 129 of file Assert.h.

## assert_() [2/4]

template<class t>

casacore::assert_< t >::assert_ | ( | const void * | ptr,
|  | const char * | msg )

inline

Definition at line 132 of file Assert.h.

## assert_() [3/4]

template<class t>

casacore::assert_< t >::assert_ | ( | int | expr,
|  | const char * | msg,
|  | const char * | file,
|  | Int | line )

## assert_() [4/4]

template<class t>

casacore::assert_< t >::assert_ | ( | const void * | ptr,
|  | const char * | msg,
|  | const char * | file,
|  | Int | line )

## Member Function Documentation

## null()

template<class t>

void casacore::assert_< t >::null | ( |  | ) |

inline

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

Definition at line 141 of file Assert.h.

The documentation for this class was generated from the following file:

- casa/Utilities/Assert.h