Exception.hpp File Reference

#include <string>
#include <sstream>
#include <cfloat>
#include <climits>
#include <cstdlib>
#include <boost/preprocessor/stringize.hpp>

Include dependency graph for Exception.hpp:

Go to the source code of this file.

Classes
class	Exception
Defines
#define	EXCEPTION(message)
#define	EXCEPT_IF_NOT(test) if (!(test)) EXCEPTION("Assertion tripped: " BOOST_PP_STRINGIZE(test))
#define	TERMINATE(message) Exception::Terminate(message, __FILE__, __LINE__)
#define	NEVER_REACHED TERMINATE("Should have been impossible to reach this line of code"); exit(EXIT_FAILURE)
#define	UNUSED_OPT(var)
#define	EXPECT0(cmd, arg)
#define	ABORT_IF_NON0_WITH_MSG(retcode, msg)
#define	ABORT_IF_NON0(cmd, arg)
#define	EXPECT_NON0(cmd, arg)
#define	IGNORE_RET(cmd, arg)
Variables
const unsigned	UNSIGNED_UNSET = UINT_MAX
const int	INT_UNSET = INT_MAX
const double	DOUBLE_UNSET = DBL_MAX

Detailed Description

Contains the Exception class, along with some macros that are widely used throughout the code.

Definition in file Exception.hpp.

Define Documentation

#define ABORT_IF_NON0	(	cmd,
		arg		)

Value:

{ \
    std::string _arg(arg);        \
    int ret = cmd(_arg.c_str());  \
    ABORT_IF_NON0_WITH_MSG(ret, "Error executing command: " #cmd "(" + _arg + ")") \
    }

Handy for calling functions like system which return non-zero on error. Terminate if an error occurs.

This macro should be used instead of EXPECT0 within blocks that are only executed by one process, but need to kill all processes if an error occurs.

Parameters:

	cmd	command to call
	arg	its argument (will be converted to std::string)

Definition at line 248 of file Exception.hpp.

Referenced by AbstractConvergenceTester< CELL, CARDIAC_PROBLEM, DIM, PROBLEM_DIM >::Converge(), OutputFileHandler::CopyFileTo(), HeartConfig::CopySchema(), CardiacSimulation::CreateAndRun(), OutputDirectoryFifoQueue::CreateNextDir(), OutputFileHandler::MakeFoldersAndReturnFullPath(), OutputFileHandler::OutputFileHandler(), AbstractTetrahedralMesh< SPACE_DIM, SPACE_DIM >::save(), and AbstractCardiacTissue< SPACE_DIM >::save().

#define ABORT_IF_NON0_WITH_MSG	(	retcode,
		msg		)

Value:

if (retcode != 0) {                          \
        TERMINATE(msg);                          \
    }

Handy for calling functions like system which return non-zero on error. Terminate if the return code is non-zero, printing a suitable message.

Parameters:

	retcode	command return code
	msg	error message to display

Definition at line 233 of file Exception.hpp.

#define EXCEPT_IF_NOT ( test ) if (!(test)) EXCEPTION("Assertion tripped: " BOOST_PP_STRINGIZE(test))

Convenience macro for changing an assert into an exception - has the same calling semantics, but throws.

Parameters:

test

the test that must always be true.

Definition at line 151 of file Exception.hpp.

Referenced by CellMLToSharedLibraryConverter::ConvertCellmlToSo(), FileFinder::GetLeafName(), FileFinder::GetParent(), AbstractCardiacTissue< ELEMENT_DIM, SPACE_DIM >::GetPurkinjeCell(), CommandLineArguments::GetValueCorrespondingToOption(), AbstractCardiacTissue< ELEMENT_DIM, SPACE_DIM >::rGetPurkinjeCellsDistributed(), and AbstractCardiacTissue< ELEMENT_DIM, SPACE_DIM >::rGetPurkinjeIionicCacheReplicated().

#define EXCEPTION ( message )

Value:

do {                                             \
        std::stringstream msg_stream;                \
        msg_stream << message;                       \
        throw Exception(msg_stream.str(), __FILE__, __LINE__); \
    } while (false)

Convenience macro for throwing an exception, in order to add file and line info.

Parameters:

message

the error message to use, as a streamed expression

Definition at line 136 of file Exception.hpp.

#define EXPECT0	(	cmd,
		arg		)

Value:

{      \
    std::string _arg(arg);       \
    int ret = cmd(_arg.c_str()); \
    if (ret != 0) {              \
        EXCEPTION("Error executing command: " #cmd "(" + _arg + ")"); \
    } }

Handy for calling functions like system which return non-zero on error. Throws if an error occurs.

Note:: DO NOT use this macro within an if (PetscTools::AmMaster) block, as then you'll get deadlock if an exception is thrown when running in parallel! (Unless the block is wrapped in a try-catch and exception replication handler.) Instead, use ABORT_IF_NON0.

Parameters:

	cmd	command to call
	arg	its argument (will be converted to std::string)

Definition at line 219 of file Exception.hpp.

Referenced by CellMLToSharedLibraryConverter::ConvertCellmlToSo(), AbstractConvergenceTester< CELL, CARDIAC_PROBLEM, DIM, PROBLEM_DIM >::DisplayRun(), and PetscSetup::setUpWorld().

#define EXPECT_NON0	(	cmd,
		arg		)

Value:

{   \
    std::string _arg = (arg);     \
    int ret = cmd(_arg.c_str());  \
    if (ret == 0) {               \
        EXCEPTION("Command: " #cmd "(" + _arg + ") succeeded and it shouldn't have"); \
    } }

Handy for calling functions like system which return non-zero on error. This time we expect failure; throws if the command succeeds.

Parameters:

	cmd	command to call
	arg	its argument (will be converted to std::string)

Definition at line 260 of file Exception.hpp.

#define IGNORE_RET	(	cmd,
		arg		)

Value:

{   \
    std::string _arg = (arg);    \
    int ret = cmd(_arg.c_str()); \
    ret = ret;                   \
    }

Handy for calling functions like system which return non-zero on error. This version ignores the return code, in case you don't care about errors for some reason...

Parameters:

	cmd	command to call
	arg	its argument (will be converted to std::string)

Definition at line 273 of file Exception.hpp.

Referenced by CellMLToSharedLibraryConverter::ConvertCellmlToSo().

#define NEVER_REACHED TERMINATE("Should have been impossible to reach this line of code"); exit(EXIT_FAILURE)

Use for control paths that will never be executed, just to make sure they aren't.

The exit statement at the end of NEVER_REACHED is not really needed but prevents g++ from complaining about uninitialised variables when you have code that looks like:

   RelativeTo::Value relative_to;
   switch (rPath.relative_to())
   {
       case cp::relative_to_type::cwd:
           relative_to = RelativeTo::CWD;
           break;
       case cp::relative_to_type::chaste_test_output:
           relative_to = RelativeTo::ChasteTestOutput;
           break;
       case cp::relative_to_type::chaste_source_root:
           relative_to = RelativeTo::ChasteSourceRoot;
           break;
       case cp::relative_to_type::absolute:
           relative_to = RelativeTo::Absolute;
           break;
       default:
           NEVER_REACHED;
           break;
   }

relative_to is considered potentially uninitialised in the default branch unless the compiler finds a exit, assert or throw statement.

Definition at line 194 of file Exception.hpp.

#define TERMINATE ( message ) Exception::Terminate(message, __FILE__, __LINE__)

Terminate execution safely, even when running in parallel. Use for level 4 errors: execution cannot continue from this point and hence should be terminated (even when running with NDEBUG).

Parameters:

message

explanatory message

Definition at line 161 of file Exception.hpp.

Referenced by AbstractBidomainSolver< ELEMENT_DIM, SPACE_DIM >::InitialiseForSolve(), PCBlockDiagonal::PCBlockDiagonalCreate(), PCLDUFactorisation::PCLDUFactorisationCreate(), PCTwoLevelsBlockDiagonal::PCTwoLevelsBlockDiagonalCreate(), LinearSystem::SetPcType(), and LinearSystem::Solve().

#define UNUSED_OPT ( var )

This is to cope with NDEBUG causing variables to not be used, when they are only used in assert()s.

Parameters:

var

the "unused" variable

Definition at line 204 of file Exception.hpp.