RCU::Check Namespace Reference

Classes
struct	TestInvariant

Typedefs
typedef void(*	TestInvariantFunction) (const void *object)
	effects: apply the test invariant method on an object guarantee: no-fail availability: experts only rationale: this is a templated wrapper for the class specific invariant testers

Enumerations
enum	Type {   assert_soft , assert_hard , assert_noimp , require_soft ,   require_hard , require_noimp , provide_soft , provide_hard ,   provide_noimp , invariant }

Functions
void	fail (const char *package, const char *file, unsigned line, Type type, const char *error)
	effects: report the error and abort either by exception or assert like guarantee: all-fail failures: as requested requires: file != 0 requires: line != 0 requires: type < typeNum requires: error != 0 availability: experts only
bool	testInvariantPrint (TestInvariantFunction function, const void *object)
template<class T>
void	testInvariantVoid (const void *object)
template<class T>
TestInvariant	invariant_tester (T *object)
	effects: create the right invariant testing object returns: the tester

Variables
const char *const	typeLiteral [typeNum]
const bool	typeAbort [typeNum]
const int	typeNum = invariant + 1

Typedef Documentation

TestInvariantFunction

typedef void(* RCU::Check::TestInvariantFunction) (const void *object)

effects: apply the test invariant method on an object guarantee: no-fail availability: experts only rationale: this is a templated wrapper for the class specific invariant testers

Definition at line 93 of file Assert.h.

Enumeration Type Documentation

Type

enum RCU::Check::Type

Enumerator
assert_soft	regular old style assertion
assert_hard
assert_noimp
require_soft	function parameter requirement
require_hard
require_noimp
provide_soft	function postcondition
provide_hard
provide_noimp
invariant	invariant violation

Definition at line 50 of file Assert.h.

      {
    assert_soft,
    assert_hard,
    assert_noimp,

    require_soft,
    require_hard,
    require_noimp,

    provide_soft,
    provide_hard,
    provide_noimp,

    invariant
      };

Function Documentation

fail()

void RCU::Check::fail	(	const char *	package,
		const char *	file,
		unsigned	line,
		Type	type,
		const char *	error )

effects: report the error and abort either by exception or assert like guarantee: all-fail failures: as requested requires: file != 0 requires: line != 0 requires: type < typeNum requires: error != 0 availability: experts only

Definition at line 64 of file Assert.cxx.

    {
      RCU_REQUIRE (file != 0);
      RCU_REQUIRE (line != 0);
      RCU_REQUIRE (type < typeNum);
      RCU_REQUIRE (error != 0);
 
      Message msg;
      msg.package = package;
      msg.file = file;
      msg.line = line;
      msg.type = typeAbort[type] ? MESSAGE_ABORT : MESSAGE_EXCEPTION;
 
      std::string mymessage = typeLiteral[type];
      mymessage += ": ";
      mymessage += error;
      msg.message = mymessage.c_str();
 
      msg.send();
    }

invariant_tester()

template<class T>

TestInvariant RCU::Check::invariant_tester ( T * object )

inline

effects: create the right invariant testing object returns: the tester

Definition at line 121 of file Assert.h.

    {
      return TestInvariant (testInvariantVoid<T>, object);
    }

testInvariantPrint()

bool RCU::Check::testInvariantPrint	(	TestInvariantFunction	function,
		const void *	object )

Definition at line 106 of file Assert.cxx.

    {
      try
      {
    (*function) (object);
    return false;
      } catch (std::exception& e)
      {
    RCU_ERROR_MSG (e.what());
    return true;
      };
    }

testInvariantVoid()

template<class T>

void RCU::Check::testInvariantVoid

(

const void *

object

)

Definition at line 95 of file Assert.h.

    {
      static_cast<const T *>(object)->testInvariant ();
    }

Variable Documentation

typeAbort

const bool RCU::Check::typeAbort

Initial value:

                      =
  {
false,
true,
true,
 
false,
true,
true,
 
false,
true,
true,
 
true,
  }

Definition at line 45 of file Assert.cxx.

                                         {
    false,
    true,
    true,
 
    false,
    true,
    true,
 
    false,
    true,
    true,
 
    true,
      };

typeLiteral

const char *const RCU::Check::typeLiteral

Initial value:

                               =
  {
"assertion failed",
"assertion failed",
"assertion failed",
 
"requirement failed",
"requirement failed",
"requirement failed",
 
"postcondition violated",
"postcondition violated",
"postcondition violated",
 
"invariant violated"
  }

Definition at line 26 of file Assert.cxx.

                                                   {
    "assertion failed",
    "assertion failed",
    "assertion failed",
 
    "requirement failed",
    "requirement failed",
    "requirement failed",
 
    "postcondition violated",
    "postcondition violated",
    "postcondition violated",
 
    "invariant violated"
      };

typeNum

const int RCU::Check::typeNum = invariant + 1

Definition at line 70 of file Assert.h.