slic_macros.hpp File Reference

#include "axom/config.hpp"
#include "axom/core/Macros.hpp"

Classes
struct	axom::slic::detail::FalseType
	Variable of a type that evaluates as false. More...

Namespaces
	axom
	axom::slic
	axom::slic::detail

Macros
#define	SLIC_INFO(msg)
	Logs an Info message. More...
#define	SLIC_INFO_TAGGED(msg, tag)
	Logs an Info message to a tagged stream. More...
#define	SLIC_INFO_IF(EXP, msg)
	Logs an Info message iff EXP is true. More...
#define	SLIC_INFO_ROOT(msg)   SLIC_INFO_IF(axom::slic::isRoot(), msg)
	Logs an Info message if on root. More...
#define	SLIC_INFO_ROOT_IF(EXP, msg)    SLIC_INFO_IF((EXP) && (axom::slic::isRoot()), msg)
	Logs an Info message if on root and iff EXP is true. More...
#define	SLIC_DEBUG(msg)
	Logs a Debug message. More...
#define	SLIC_DEBUG_IF(EXP, msg)
	Logs an Debug message iff EXP is true. More...
#define	SLIC_DEBUG_ROOT(msg)   SLIC_DEBUG_IF(axom::slic::isRoot(), msg)
	Logs a Debug message if on root. More...
#define	SLIC_DEBUG_ROOT_IF(EXP, msg)    SLIC_DEBUG_IF((EXP) && (axom::slic::isRoot()), msg)
	Logs a Debug message if on root and iff EXP is true. More...
SLIC_ERROR MACROS
Attention These error macros are collective operations. All ranks in the user-supplied communicator must call the macro when used within an MPI distributed environment, and slic::enableAbortOnError() is called for the current active logger (default is enabled for loggers) See also axom::slic::isAbortOnErrorsEnabled() axom::slic::setAbortOnError(bool status)
#define	SLIC_ERROR(msg)
	Logs an error and aborts the application. More...
#define	SLIC_ERROR_IF(EXP, msg)
	Logs an error iff EXP is true and aborts the application. More...
#define	SLIC_ERROR_ROOT(msg)
	Macro that logs given error message only on root. More...
#define	SLIC_ERROR_ROOT_IF(EXP, msg)
	Macro that logs given error message only on root iff EXP is true. More...
SLIC_WARNING MACROS
Attention These warning macros can be set as collective operations. These warning macros are collective if slic::enableAbortOnWarning() is called for the current active logger (default is disabled for loggers). These warning macros must then be called by all ranks in the user-supplied communicator when used within an MPI distributed environment. See also axom::slic::isAbortOnWarningsEnabled() axom::slic::setAbortOnWarning(bool status)
#define	SLIC_WARNING(msg)
	Logs a warning message. More...
#define	SLIC_WARNING_IF(EXP, msg)
	Logs a warning iff EXP is true. More...
#define	SLIC_WARNING_ROOT(msg)
	Macro that logs given warning message only on root. More...
#define	SLIC_WARNING_ROOT_IF(EXP, msg)
	Macro that logs given warning message only on root iff EXP is true. More...
SLIC_ASSERT MACROS
Attention These assert macros are collective operations. All ranks in the user-supplied communicator must call the macro when used within an MPI distributed environment, and slic::enableAbortOnError() is called for the current active logger (default is enabled for loggers) See also axom::slic::isAbortOnErrorsEnabled() axom::slic::setAbortOnError(bool status)
#define	SLIC_ASSERT(EXP)
	Asserts that a given expression is true. If the expression is not true an error will be logged and the application will be aborted. More...
#define	SLIC_ASSERT_MSG(EXP, msg)
	Same as SLIC_ASSERT, but with a custom error message. More...
SLIC_CHECK MACROS
Attention These check macros can be set as collective operations. These check macros are collective if either: slic::debug::checksAreErrors is set to true (default is false) and slic::enableAbortOnError() is called for the current active logger (default is enabled for loggers) slic::debug::checksAreErrors is set to false (default is false) and slic::enableAbortOnWarning() is called for the current active logger (default is disabled for loggers) These check macros must then be called by all ranks in the user-supplied communicator when used within an MPI distributed environment. See also axom::slic::isAbortOnErrorsEnabled() axom::slic::setAbortOnError(bool status) axom::slic::isAbortOnWarningsEnabled() axom::slic::setAbortOnWarning(bool status)
#define	SLIC_CHECK(EXP)
	Checks that a given expression is true. If the expression is not true a warning is logged, but, in contrast to the similar SLIC_ASSERT macro the application is not aborted. More...
#define	SLIC_CHECK_MSG(EXP, msg)
	Same as SLIC_CHECK, but with a custom error message. More...

Variables
static const FalseType	axom::slic::detail::false_value

Macro Definition Documentation

SLIC_ERROR

#define SLIC_ERROR

(

msg

)

Value:

  do                                                              \
  {                                                               \
    std::ostringstream __oss;                                     \
    __oss << msg;                                                 \
    axom::slic::logErrorMessage(__oss.str(), __FILE__, __LINE__); \
    if(axom::slic::isAbortOnErrorsEnabled())                      \
    {                                                             \
      axom::slic::abort();                                        \
    }                                                             \
  } while(axom::slic::detail::false_value)

Logs an error and aborts the application.

Parameters

[in]

msg

user-supplied message

Warning

This macro calls processAbort().

Note

The SLIC_ERROR macro is always active.

Usage:

SLIC_ERROR( "my_val should always be positive" );

SLIC_ERROR_IF

#define SLIC_ERROR_IF	(		EXP,
			msg
	)

Value:

  do                                                                \
  {                                                                 \
    if(EXP)                                                         \
    {                                                               \
      std::ostringstream __oss;                                     \
      __oss << msg;                                                 \
      axom::slic::logErrorMessage(__oss.str(), __FILE__, __LINE__); \
      if(axom::slic::isAbortOnErrorsEnabled())                      \
      {                                                             \
        axom::slic::abort();                                        \
      }                                                             \
    }                                                               \
  } while(axom::slic::detail::false_value)

Logs an error iff EXP is true and aborts the application.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message.

Warning

This macro calls processAbort() iff EXP is true.

Note

The SLIC_ERROR_IF macro is always active.

Usage:

SLIC_ERROR_IF( (val < 0), "my_val should always be positive" );

SLIC_ERROR_ROOT

#define SLIC_ERROR_ROOT

(

msg

)

Value:

  do                                                                \
  {                                                                 \
    if(axom::slic::isRoot())                                        \
    {                                                               \
      std::ostringstream __oss;                                     \
      __oss << msg;                                                 \
      axom::slic::logErrorMessage(__oss.str(), __FILE__, __LINE__); \
      if(axom::slic::isAbortOnErrorsEnabled())                      \
      {                                                             \
        axom::slic::abort();                                        \
      }                                                             \
    }                                                               \
  } while(axom::slic::detail::false_value)

Macro that logs given error message only on root.

Parameters

[in]

msg

user-supplied message.

Warning

This macro calls processAbort() iff EXP is true.

Note

The SLIC_ERROR_ROOT macro is always active.

By default, all ranks are considered to be root. Must call axom::slic::initialize(is_root={true|false}) or set via axom::slic::setIsRoot({true|false}) to filter based on root.

Usage:

SLIC_ERROR_ROOT( "An error has occurred!" );

SLIC_ERROR_ROOT_IF

#define SLIC_ERROR_ROOT_IF	(		EXP,
			msg
	)

Value:

  do                                                                  \
  {                                                                   \
    if(EXP)                                                           \
    {                                                                 \
      if(axom::slic::isRoot())                                        \
      {                                                               \
        std::ostringstream __oss;                                     \
        __oss << msg;                                                 \
        axom::slic::logErrorMessage(__oss.str(), __FILE__, __LINE__); \
        if(axom::slic::isAbortOnErrorsEnabled())                      \
        {                                                             \
          axom::slic::abort();                                        \
        }                                                             \
      }                                                               \
    }                                                                 \
  } while(axom::slic::detail::false_value)

Macro that logs given error message only on root iff EXP is true.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message.

Note

The SLIC_ERROR_ROOT_IF macro is always active.

By default, all ranks are considered to be root. Must call axom::slic::initialize(is_root={true|false}) or set via axom::slic::setIsRoot({true|false}) to filter based on root.

Usage:

SLIC_ERROR_ROOT_IF( (my_val < 0), "my_val should always be positive" );

SLIC_WARNING

#define SLIC_WARNING

(

msg

)

Value:

  do                                                                \
  {                                                                 \
    std::ostringstream __oss;                                       \
    __oss << msg;                                                   \
    axom::slic::logWarningMessage(__oss.str(), __FILE__, __LINE__); \
    if(axom::slic::isAbortOnWarningsEnabled())                      \
    {                                                               \
      axom::slic::abort();                                          \
    }                                                               \
  } while(axom::slic::detail::false_value)

Logs a warning message.

Parameters

[in]

msg

user-supplied message

Note

The SLIC_WARNING macro is always active.

Aborts the application when slic::enableAbortOnWarning()

Usage:

SLIC_WARNING( "my_val should always be positive" );

SLIC_WARNING_IF

#define SLIC_WARNING_IF	(		EXP,
			msg
	)

Value:

  do                                                                  \
  {                                                                   \
    if(EXP)                                                           \
    {                                                                 \
      std::ostringstream __oss;                                       \
      __oss << msg;                                                   \
      axom::slic::logWarningMessage(__oss.str(), __FILE__, __LINE__); \
      if(axom::slic::isAbortOnWarningsEnabled())                      \
      {                                                               \
        axom::slic::abort();                                          \
      }                                                               \
    }                                                                 \
  } while(axom::slic::detail::false_value)

Logs a warning iff EXP is true.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message.

Note

The SLIC_WARNING_IF macro is always active.

Aborts the application when slic::enableAbortOnWarning()

Usage:

SLIC_WARNING_IF( (val < 0), "my_val should always be positive" );

SLIC_WARNING_ROOT

#define SLIC_WARNING_ROOT

(

msg

)

Value:

  do                                                                  \
  {                                                                   \
    if(axom::slic::isRoot())                                          \
    {                                                                 \
      std::ostringstream __oss;                                       \
      __oss << msg;                                                   \
      axom::slic::logWarningMessage(__oss.str(), __FILE__, __LINE__); \
      if(axom::slic::isAbortOnWarningsEnabled())                      \
      {                                                               \
        axom::slic::abort();                                          \
      }                                                               \
    }                                                                 \
  } while(axom::slic::detail::false_value)

Macro that logs given warning message only on root.

Parameters

[in]

msg

user-supplied message.

Note

The SLIC_WARNING_ROOT macro is always active.

By default, all ranks are considered to be root. Must call axom::slic::initialize(is_root={true|false}) or set via axom::slic::setIsRoot({true|false}) to filter based on root.

Usage:

SLIC_WARNING_ROOT( "A warning has occurred!" );

SLIC_WARNING_ROOT_IF

#define SLIC_WARNING_ROOT_IF	(		EXP,
			msg
	)

Value:

  do                                                                    \
  {                                                                     \
    if(EXP)                                                             \
    {                                                                   \
      if(axom::slic::isRoot())                                          \
      {                                                                 \
        std::ostringstream __oss;                                       \
        __oss << msg;                                                   \
        axom::slic::logWarningMessage(__oss.str(), __FILE__, __LINE__); \
        if(axom::slic::isAbortOnWarningsEnabled())                      \
        {                                                               \
          axom::slic::abort();                                          \
        }                                                               \
      }                                                                 \
    }                                                                   \
  } while(axom::slic::detail::false_value)

Macro that logs given warning message only on root iff EXP is true.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message.

Note

The SLIC_WARNING_ROOT_IF macro is always active.

By default, all ranks are considered to be root. Must call axom::slic::initialize(is_root={true|false}) or set via axom::slic::setIsRoot({true|false}) to filter based on root.

Usage:

SLIC_WARNING_ROOT_IF( (val < 0), "my_val should always be positive" );

SLIC_ASSERT

#define SLIC_ASSERT

(

EXP

)

Value:

    do                                                                \
    {                                                                 \
      if(!(EXP))                                                      \
      {                                                               \
        std::ostringstream __oss;                                     \
        __oss << "Failed Assert: " << #EXP << std::ends;              \
        axom::slic::logErrorMessage(__oss.str(), __FILE__, __LINE__); \
        if(axom::slic::isAbortOnErrorsEnabled())                      \
        {                                                             \
          axom::slic::abort();                                        \
        }                                                             \
      }                                                               \
    } while(axom::slic::detail::false_value)

Asserts that a given expression is true. If the expression is not true an error will be logged and the application will be aborted.

Parameters

[in]

EXP

user-supplied boolean expression.

Warning

This macro calls processAbort() iff EXP is false.

Note

This macro is only active when AXOM_DEBUG is defined.

Usage:

SLIC_ASSERT( my_val >= 0 );

SLIC_ASSERT_MSG

#define SLIC_ASSERT_MSG	(		EXP,
			msg
	)

Value:

    do                                                                       \
    {                                                                        \
      if(!(EXP))                                                             \
      {                                                                      \
        std::ostringstream __oss;                                            \
        __oss << "Failed Assert: " << #EXP << std::endl << msg << std::ends; \
        axom::slic::logErrorMessage(__oss.str(), __FILE__, __LINE__);        \
        if(axom::slic::isAbortOnErrorsEnabled())                             \
        {                                                                    \
          axom::slic::abort();                                               \
        }                                                                    \
      }                                                                      \
    } while(axom::slic::detail::false_value)

Same as SLIC_ASSERT, but with a custom error message.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message

Warning

This macro calls processAbort() iff EXP is false.

Note

This macro is only active when AXOM_DEBUG is defined.

See also

SLIC_ASSERT( EXP )

Usage:

SLIC_ASSERT_MSG( my_val >= 0, "my_val must always be positive" );

SLIC_CHECK

#define SLIC_CHECK

(

EXP

)

Value:

    do                                                                    \
    {                                                                     \
      if(!(EXP))                                                          \
      {                                                                   \
        std::ostringstream __oss;                                         \
        __oss << "Failed Check: " << #EXP << std::ends;                   \
        if(axom::slic::debug::checksAreErrors)                            \
        {                                                                 \
          axom::slic::logErrorMessage(__oss.str(), __FILE__, __LINE__);   \
          if(axom::slic::isAbortOnErrorsEnabled())                        \
          {                                                               \
            axom::slic::abort();                                          \
          }                                                               \
        }                                                                 \
        else                                                              \
        {                                                                 \
          axom::slic::logWarningMessage(__oss.str(), __FILE__, __LINE__); \
          if(axom::slic::isAbortOnWarningsEnabled())                      \
          {                                                               \
            axom::slic::abort();                                          \
          }                                                               \
        }                                                                 \
      }                                                                   \
    } while(axom::slic::detail::false_value)

Checks that a given expression is true. If the expression is not true a warning is logged, but, in contrast to the similar SLIC_ASSERT macro the application is not aborted.

Parameters

[in]

EXP

user-supplied boolean expression.

Note

This macro is only active when AXOM_DEBUG is defined.

Usage:

SLIC_CHECK( my_val >= 0 );

SLIC_CHECK_MSG

#define SLIC_CHECK_MSG	(		EXP,
			msg
	)

Value:

    do                                                                      \
    {                                                                       \
      if(!(EXP))                                                            \
      {                                                                     \
        std::ostringstream __oss;                                           \
        __oss << "Failed Check: " << #EXP << std::endl << msg << std::ends; \
        if(axom::slic::debug::checksAreErrors)                              \
        {                                                                   \
          axom::slic::logErrorMessage(__oss.str(), __FILE__, __LINE__);     \
          if(axom::slic::isAbortOnErrorsEnabled())                          \
          {                                                                 \
            axom::slic::abort();                                            \
          }                                                                 \
        }                                                                   \
        else                                                                \
        {                                                                   \
          axom::slic::logWarningMessage(__oss.str(), __FILE__, __LINE__);   \
          if(axom::slic::isAbortOnWarningsEnabled())                        \
          {                                                                 \
            axom::slic::abort();                                            \
          }                                                                 \
        }                                                                   \
      }                                                                     \
    } while(axom::slic::detail::false_value)

Same as SLIC_CHECK, but with a custom error message.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message

Note

This macro is only active when AXOM_DEBUG is defined.

See also

SLIC_DEBUG( EXP )

Usage:

SLIC_CHECK_MSG( my_val >= 0, "my_val must always be positive" );

SLIC_INFO

#define SLIC_INFO

(

msg

)

Value:

  do                                                  \
  {                                                   \
    std::ostringstream __oss;                         \
    __oss << msg;                                     \
    axom::slic::logMessage(axom::slic::message::Info, \
                           __oss.str(),               \
                           __FILE__,                  \
                           __LINE__);                 \
  } while(axom::slic::detail::false_value)

Logs an Info message.

Parameters

[in]

msg

user-supplied message

Note

The SLIC_INFO macro is always active.

Usage:

SLIC_INFO( "informative text goes here" );

SLIC_INFO_TAGGED

#define SLIC_INFO_TAGGED	(		msg,
			tag
	)

Value:

  do                                                  \
  {                                                   \
    std::ostringstream __oss;                         \
    __oss << msg;                                     \
    axom::slic::logMessage(axom::slic::message::Info, \
                           __oss.str(),               \
                           tag,                       \
                           __FILE__,                  \
                           __LINE__,                  \
                           false,                     \
                           true);                     \
  } while(axom::slic::detail::false_value)

Logs an Info message to a tagged stream.

Parameters

[in]	msg	user-supplied message
[in]	tag	user-supplied tag

Note

The SLIC_INFO_TAGGED macro is always active.

Usage:

SLIC_INFO_TAGGED("informative text goes here", "tag");

SLIC_INFO_IF

#define SLIC_INFO_IF	(		EXP,
			msg
	)

Value:

  do                                                    \
  {                                                     \
    if(EXP)                                             \
    {                                                   \
      std::ostringstream __oss;                         \
      __oss << msg;                                     \
      axom::slic::logMessage(axom::slic::message::Info, \
                             __oss.str(),               \
                             __FILE__,                  \
                             __LINE__);                 \
    }                                                   \
  } while(axom::slic::detail::false_value)

Logs an Info message iff EXP is true.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message.

Note

The SLIC_INFO_IF macro is always active.

Usage:

SLIC_INFO_IF( (val < 0), "my_val should always be positive" );

SLIC_INFO_ROOT

#define SLIC_INFO_ROOT

(

msg

)

SLIC_INFO_IF(axom::slic::isRoot(), msg)

Logs an Info message if on root.

Parameters

[in]

msg

user-supplied message.

Note

The SLIC_INFO_ROOT macro is always active.

Usage:

SLIC_INFO_ROOT( "informative text goes here" );

SLIC_INFO_ROOT_IF

#define SLIC_INFO_ROOT_IF	(		EXP,
			msg
	)		SLIC_INFO_IF((EXP) && (axom::slic::isRoot()), msg)

Logs an Info message if on root and iff EXP is true.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message.

Note

The SLIC_INFO_ROOT_IF macro is always active.

Usage:

SLIC_INFO_ROOT_IF( (val < 0), "my_val should always be positive" );

SLIC_DEBUG

#define SLIC_DEBUG

(

msg

)

Value:

    do                                                   \
    {                                                    \
      std::ostringstream __oss;                          \
      __oss << msg;                                      \
      axom::slic::logMessage(axom::slic::message::Debug, \
                             __oss.str(),                \
                             __FILE__,                   \
                             __LINE__);                  \
    } while(axom::slic::detail::false_value)

Logs a Debug message.

Parameters

[in]

msg

user-supplied message

Note

The SLIC_Debug macro is active when AXOM_DEBUG is defined.

Usage:

SLIC_DEBUG( "debug message goes here" );

SLIC_DEBUG_IF

#define SLIC_DEBUG_IF	(		EXP,
			msg
	)

Value:

    do                                                     \
    {                                                      \
      if(EXP)                                              \
      {                                                    \
        std::ostringstream __oss;                          \
        __oss << msg;                                      \
        axom::slic::logMessage(axom::slic::message::Debug, \
                               __oss.str(),                \
                               __FILE__,                   \
                               __LINE__);                  \
      }                                                    \
    } while(axom::slic::detail::false_value)

Logs an Debug message iff EXP is true.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message.

Note

The SLIC_DEBUG_IF macro is active when AXOM_DEBUG is defined.

Usage:

SLIC_DEBUG_IF( (val < 0), "my_val should always be positive" );

SLIC_DEBUG_ROOT

#define SLIC_DEBUG_ROOT

(

msg

)

SLIC_DEBUG_IF(axom::slic::isRoot(), msg)

Logs a Debug message if on root.

Parameters

[in]

msg

user-supplied message.

Note

The SLIC_DEBUG_ROOT macro is active when AXOM_DEBUG is defined.

Usage:

SLIC_DEBUG_ROOT( "informative text goes here" );

SLIC_DEBUG_ROOT_IF

#define SLIC_DEBUG_ROOT_IF	(		EXP,
			msg
	)		SLIC_DEBUG_IF((EXP) && (axom::slic::isRoot()), msg)

Logs a Debug message if on root and iff EXP is true.

Parameters

[in]	EXP	user-supplied boolean expression.
[in]	msg	user-supplied message.

Note

The SLIC_DEBUG_ROOT_IF macro is active when AXOM_DEBUG is defined.

Usage:

SLIC_DEBUG_ROOT_IF( (val < 0), "my_val should always be positive" );