ReportHandler.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/

#ifndef STK_UTIL_ENVIRONMENT_REPORTHANDLER_HPP
#define STK_UTIL_ENVIRONMENT_REPORTHANDLER_HPP

#include <iosfwd>
#include <string>
#include <sstream>

namespace stk_classic {


typedef void (*REH)(const char *message, int type);

typedef void (*ErrorHandler)(const char* expr, const std::string& location, std::ostringstream& message);

void default_report_handler(const char *message, int type);

REH set_report_handler(REH reh);

void report(const char *message, int type);

std::string source_relative_path(const std::string &path);

void default_assert_handler(const char* expr,
                            const std::string& location,
                            std::ostringstream& message);

void default_error_handler(const char* expr,
                           const std::string& location,
                           std::ostringstream& message);

void default_invalid_arg_handler(const char* expr,
                                 const std::string& location,
                                 std::ostringstream& message);

ErrorHandler set_assert_handler(ErrorHandler handler);

ErrorHandler set_error_handler(ErrorHandler handler);

ErrorHandler set_invalid_arg_handler(ErrorHandler handler);

void handle_assert(const char* expr,
                   const std::string& location,
                   std::ostringstream& message);

void handle_error(const char* expr,
                   const std::string& location,
                   std::ostringstream& message);

void handle_invalid_arg(const char* expr,
                        const std::string& location,
                        std::ostringstream& message);



} // namespace stk_classic


#define XSTR_TRACE_LINE(s) STR_TRACE_LINE(s)
#define STR_TRACE_LINE(s) #s

#ifdef __PRETTY_FUNCTION__

#define COUT_TRACE  " Function::Line="<<__PRETTY_FUNCTION__<<":"<<__LINE__
#define STR_TRACE   (std::string(__FILE__) +  ":" + XSTR_TRACE_LINE(__LINE__) + " in " + std::string(__PRETTY_FUNCTION__))

#else

#define COUT_TRACE  " File::Line="<<__FILE__<<":"<<__LINE__
#define STR_TRACE   (std::string(__FILE__) +  ":" + XSTR_TRACE_LINE(__LINE__))

#endif

#define StackTrace std::string(std::string("  exception thrown from ") + stk_classic::source_relative_path(STR_TRACE))

// The do-while is necessary to prevent usage of this macro from changing
// program semantics (e.g. dangling-else problem). The obvious implementation:
// if (expr) ; else throw ...
// is not adequate because it causes ambiguous else statements in this context:
// if (something)
//   ThrowRequire(foo);
// The compiler does not know whether the else statement that the macro inserts
// applies to the "if (something) " or the "if (expr)".
#define ThrowGenericCond(expr, message, handler)                        \
  do {                                                                  \
    if ( !(expr) ) {                                                    \
      std::ostringstream stk_util_internal_throw_require_oss;           \
      stk_util_internal_throw_require_oss << message;                   \
      stk_classic::handler( #expr,                                              \
                    STR_TRACE,                                          \
                    stk_util_internal_throw_require_oss );              \
    }                                                                   \
  } while (false)

// This generic macro is for unconditional throws. We pass "" as the expr
// string, the handler should be smart enough to realize that this means there
// was not expression checked, AKA, this throw was unconditional.
#define ThrowGeneric(message, handler)                                  \
  do {                                                                  \
    std::ostringstream stk_util_internal_throw_require_oss;             \
    stk_util_internal_throw_require_oss << message;                     \
    stk_classic::handler( "",                                                   \
                  STR_TRACE,                                            \
                  stk_util_internal_throw_require_oss );                \
} while (false)

// The macros below define the exceptions that we want to support within
// STK. The intent is that STK developers will never call throw XXX
// directly. This will give us full control over the exceptions being generated
// by STK and how they are handled. These macros are also designed to make
// it as easy as possible for developers to throw exceptions that have good
// error messages and to reduce the volume of coded needed for error handling.
//
// We currently support the following exceptions in STK:
//   logic_error <-> ThrowAssert, ThrowAsserMsg, ThrowRequire, ThrowRequireMsg
//   runtime_error <-> ThrowErrorMsgIf, ThrowErrorMsg
//   invalid_argument <-> ThrowInvalidArgMsgIf, ThrowInvalidArgIf
//
// Please note the logic of the errors is the opposite of the asserts. The
// asserts will throw exceptions if the given expression is false; for the
// error macros, exceptions will be thrown if the given expression is true.
//
// USE:
//     All of the following have versions that do not require a message, but
//     we strongly encourage developers to use the versions that take the
//     message.
//
//   ASSERTS:
//     ThrowAssertMsg(expr, message);
//       If NDEBUG is not defined, throw a logic error if expr evaluates to
//       false, adding message to the error message . Use this for expensive
//       logic-mistake checks that could impact performance.
//
//     ThrowRequireMsg(code, message);
//       Always throw a logic error if expr evaluates to false, adding message
//       to error message. Use this for inexpensive logic-mistake checks
//       that do not impact performance.
//
//   ERRORS:
//     ThrowErrorMsgIf(expr, message);
//       Throw a runtime error if expr evaluates to true, adding message to
//       the error message. Use this to generate errors dealing with system
//       errors or other errors that do not involve invalid parameters being
//       passed to functions.
//
//     ThrowInvalidArgMsgIf(expr, message);
//       Throw an invalid_argument error if expr evaluates to true, adding
//       message to the error message. Use this to generate errors dealing with
//       users passing invalid arguments to functions in the API.
//
// EXAMPLES:
//
// 1) Require that i equals j, demonstate use of put-tos in the message arg
//   ThrowRequireMsg(i == j, "i(" << i << ") != j(" << j << ")");
//
// 2) Check method argument foo is not NULL
//   ThrowInvalidArgMsgIf(foo != NULL, "Arg foo is NULL");

#define ThrowRequireMsg(expr,message) ThrowGenericCond(expr, message, handle_assert)
#define ThrowRequire(expr)            ThrowRequireMsg(expr, "")

#ifdef NDEBUG
#  define ThrowAssert(expr)            ((void) (0))
#  define ThrowAssertMsg(expr,message) ((void) (0))
#else
#  define ThrowAssert(expr)            ThrowRequire(expr)
#  define ThrowAssertMsg(expr,message) ThrowRequireMsg(expr,message)
#endif

#define ThrowErrorMsgIf(expr, message) ThrowGenericCond( !(expr), message, handle_error)
#define ThrowErrorIf(expr)             ThrowErrorMsgIf(expr, "")
#define ThrowErrorMsg(message)         ThrowGeneric( message, handle_error )

#define ThrowInvalidArgMsgIf(expr, message) ThrowGenericCond( !(expr), message, handle_invalid_arg)
#define ThrowInvalidArgIf(expr)             ThrowInvalidArgMsgIf(expr, "")


#endif // STK_UTIL_ENVIRONMENT_REPORTHANDLER_HPP