mlErrorMacros.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_ERROR_MACROS_H
#define ML_ERROR_MACROS_H
 
#include <utility>
#include <type_traits>
#include "mlConfig.h"
 
#include "mlMacros.h"
 
// ------------------------------------------------------
// Disabling some bogus warnings in MeVis release mode
// ------------------------------------------------------
#if defined(_MSC_VER)
  #pragma warning(push)
  #if !defined(_DEBUG)
    #pragma warning(disable: 4701)  // local variable *may* be used without init
    #pragma warning(disable: 4702)  // unreachable code
    #pragma warning(disable: 4710)  // private constructors are disallowed
    #pragma warning(disable: 4097)  // typedef-name 'identifier1' used as synonym for class-name 'identifier2'
    #pragma warning(disable: 4512)  // 'class' : assignment operator could not be generated
    #pragma warning(disable: 4127)  // conditional expression is constant
    #pragma warning(disable: 4711)  // selected for automatic inline expansion
  #endif
  #pragma warning(disable: 4127)    // conditional expression is constant
#endif
 
#include "mlLogging.h"
 
#if defined(_MSC_VER)
  #pragma warning(pop)
#endif
 
 
  //----------------------------------------
  //----------------------------------------
#ifdef _DEBUG
  #define ML_TRY
  #define ML_CATCH
  #define ML_CATCH_RETURN
  #define ML_CATCH_RETURN_FALSE
  #define ML_CATCH_RETURN_NULL
  #define ML_CATCH_RETHROW
  #define ML_CATCH_BLOCK(__paramType)  if (MLAlwaysFalse)
#else
  #define ML_TRY                       try
  #define ML_CATCH                     catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); }
  #define ML_CATCH_RETURN              catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); return; }
  #define ML_CATCH_RETURN_FALSE        catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); return false; }
  #define ML_CATCH_RETURN_NULL         catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); return 0; }
  #define ML_CATCH_RETHROW             catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); throw; }
  #define ML_CATCH_BLOCK(__paramType)  catch(__paramType)
#endif
 
 
 
  //----------------------------------------
  //----------------------------------------
  #define ML_CHECK(x)                if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); }
#ifdef _DEBUG
  #define ML_CHECK_ONLY_IN_DEBUG(x)  ML_CHECK(x)
#else
  #define ML_CHECK_ONLY_IN_DEBUG(x)  /* Behaves like assert, not compiled in release mode */
#endif
  #define ML_CHECK_RETURN(x)         if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return; }
  #define ML_CHECK_RETURN_FALSE(x)   if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return false; }
  #define ML_CHECK_RETURN_NULL(x)    if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return 0; }
  #define ML_CHECK_THROW(x)          if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); throw ML_BAD_POINTER_OR_0; }
  #define ML_CHECK_RUNTIME_TYPE(x)   if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_TYPE_NOT_REGISTERED); throw ML_TYPE_NOT_REGISTERED; }
 
  #define ML_HARAKIRI                MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0);
 
 
 
  //----------------------------------------
  //----------------------------------------
  #define ML_CHECK_FLOAT(x)               if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); }
  #define ML_CHECK_FLOAT_RETURN(x)        if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return; }
  #define ML_CHECK_FLOAT_RETURN_FALSE(x)  if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return false; }
  #define ML_CHECK_FLOAT_RETURN_NULL(x)   if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return 0; }
  #define ML_CHECK_FLOAT_THROW(x)         if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); throw ML_BAD_POINTER_OR_0; }
  #define ML_CHECK_FLOAT_RUNTIME_TYPE(x)  if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_TYPE_NOT_REGISTERED); throw ML_TYPE_NOT_REGISTERED; }
 
 
 
//-----------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------
#define _ML_INFORMATION_ADD_ON(FUNC_NAME, REASON, HANDLING)
 
#define _ML_WARNING_ADD_ON(FUNC_NAME, REASON, HANDLING)
 
#define _ML_ERROR_ADD_ON(FUNC_NAME, REASON, HANDLING)
 
#define _ML_FATAL_ERROR_ADD_ON(FUNC_NAME, REASON, HANDLING)
 
#define _ML_ERROR_SHOW_ASSERT_BOX(PARAM)
 
 
 
 
 
//--------------------------------------------------------------------------------------------
//
//
//--------------------------------------------------------------------------------------------
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define _ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, RTYPE)                              \
    {                                                                                                       \
      /* Get runtime information from RTYPE which could be a crashing expression.*/                         \
      const ML_UTILS_NAMESPACE::RuntimeType *rtt7645 = nullptr;                                             \
      try{ rtt7645 = RTYPE; if (MLAlwaysFalse){ throw ML_UNKNOWN_EXCEPTION;} } catch(...){ rtt7645 = nullptr; }\
      _ML_FATAL_ERROR_ADD_ON(FUNC_NAME, REASON, HANDLING)                                                   \
      ML_UTILS_NAMESPACE::MLErrorOutput.printAndNotify(ML_FATAL,                                            \
                                                       ML_PREFIX, "Function=", FUNC_NAME, REASON, HANDLING, \
                                                       __FILE__, __LINE__, RT_OBJ, rtt7645);                \
      _ML_ERROR_SHOW_ASSERT_BOX(0);                                                                         \
    }
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define _ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, RTYPE)                                    \
    {                                                                                                       \
      /* Get runtime information from RTYPE which could be a crashing expression.*/                         \
      const ML_UTILS_NAMESPACE::RuntimeType *rtt1987 = nullptr;                                                \
      try{ rtt1987 = RTYPE; if (MLAlwaysFalse){ throw ML_UNKNOWN_EXCEPTION;} } catch(...){ rtt1987 = nullptr; }\
      _ML_ERROR_ADD_ON(FUNC_NAME, REASON, HANDLING)                                                         \
      ML_UTILS_NAMESPACE::MLErrorOutput.printAndNotify(ML_ERROR,                                            \
                                                       ML_PREFIX, "Function=", FUNC_NAME, REASON, HANDLING, \
                                                       __FILE__, __LINE__, RT_OBJ, rtt1987);                \
      _ML_ERROR_SHOW_ASSERT_BOX(0);                                                                         \
    }
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define _ML_PRINT_WARNING_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, RTYPE)                                  \
    {                                                                                                       \
      /* Get runtime information from RTYPE which could be a crashing expression.*/                         \
      const ML_UTILS_NAMESPACE::RuntimeType *rt9477 = nullptr;                                                 \
      try{ rt9477 = RTYPE; if (MLAlwaysFalse){ throw ML_UNKNOWN_EXCEPTION;} } catch(...){ rt9477 = nullptr; }  \
      _ML_WARNING_ADD_ON(FUNC_NAME, REASON, HANDLING)                                                       \
      ML_UTILS_NAMESPACE::MLErrorOutput.printAndNotify(ML_WARNING,                                          \
                                                       ML_PREFIX, "Function=", FUNC_NAME, REASON, HANDLING, \
                                                       __FILE__, __LINE__, RT_OBJ, rt9477);                 \
      /* No showing of assert box here. That would be to drastic. */                                        \
    }
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define _ML_PRINT_INFORMATION_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, RTYPE)                              \
    {                                                                                                       \
      /* Get runtime information from RTYPE which could be a crashing expression.*/                         \
      const ML_UTILS_NAMESPACE::RuntimeType *rtAx598 = nullptr;                                                \
      try{ rtAx598 = RTYPE; if (MLAlwaysFalse){ throw ML_UNKNOWN_EXCEPTION;} } catch(...){ rtAx598 = nullptr; }\
      _ML_INFORMATION_ADD_ON(FUNC_NAME, REASON, HANDLING)                                                   \
      ML_UTILS_NAMESPACE::MLErrorOutput.printAndNotify(ML_INFORMATION,                                      \
                                                       ML_PREFIX, "Function=", FUNC_NAME, REASON, HANDLING, \
                                                       __FILE__, __LINE__, RT_OBJ, rtAx598);                \
      /* No showing of assert box here. That would be to drastic. */                                        \
    }
 
 
 
//--------------------------------------------------------------------------------------------
//
//
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) \
  /* Use OR with MLAlwaysFalse to avoid compiler warnings about unreachable code when constant RT_OBJ is passed from other macro. */ \
  _ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (((RT_OBJ) || MLAlwaysFalse) ? (RT_OBJ)->getTypeId() : nullptr))
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_FATAL_ERROR_DUMP_NON_NULL(FUNC_NAME, REASON, HANDLING, RT_OBJ) \
  _ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (RT_OBJ)->getTypeId())
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) \
  /* Use OR with MLAlwaysFalse to avoid compiler warnings about unreachable code when constant RT_OBJ is passed from other macro. */ \
  _ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (((RT_OBJ) || MLAlwaysFalse) ? (RT_OBJ)->getTypeId() : nullptr))
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_ERROR_DUMP_NON_NULL(FUNC_NAME, REASON, HANDLING, RT_OBJ) \
  _ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (RT_OBJ)->getTypeId())
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_WARNING_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) \
  /* Use OR with MLAlwaysFalse to avoid compiler warnings about unreachable code when constant RT_OBJ is passed from other macro. */ \
  _ML_PRINT_WARNING_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (((RT_OBJ) || MLAlwaysFalse) ? (RT_OBJ)->getTypeId() : nullptr))
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_INFORMATION_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) \
  /* Use OR with MLAlwaysFalse to avoid compiler warnings about unreachable code when constant RT_OBJ is passed from other macro. */ \
  _ML_PRINT_INFORMATION_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (((RT_OBJ) || MLAlwaysFalse) ? (RT_OBJ)->getTypeId() : nullptr))
 
 
 
 
//--------------------------------------------------------------------------------------------
//
//
//--------------------------------------------------------------------------------------------
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_FATAL_ERROR(FUNC_NAME, REASON, HANDLING) \
  _ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, nullptr, nullptr)
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_ERROR(FUNC_NAME, REASON, HANDLING) \
  _ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, nullptr, nullptr)
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_WARNING(FUNC_NAME, REASON, HANDLING) \
  _ML_PRINT_WARNING_DUMP(FUNC_NAME, REASON, HANDLING, nullptr, nullptr)
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_INFORMATION(FUNC_NAME, REASON, HANDLING) \
  _ML_PRINT_INFORMATION_DUMP(FUNC_NAME, REASON, HANDLING, nullptr, nullptr)
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PRINT_INFO(FUNC_NAME, HANDLING) \
  _ML_PRINT_INFORMATION_DUMP(FUNC_NAME, ML_RESULT_OK, HANDLING, nullptr, nullptr)
 
 
 
 
 
#endif