exceptions.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#pragma once
 
#include <string>  // std::string, to_string()
#include <stdexcept>  // logic_error
#include <mrpt/core/common.h>
#include <mrpt/core/format.h>
 
/** \def THROW_TYPED_EXCEPTION(msg,exceptionClass) */
#define THROW_TYPED_EXCEPTION(msg, exceptionClass) \
        throw exceptionClass(                          \
                throw_typed_exception(msg, __CURRENT_FUNCTION_NAME__, __LINE__))
 
template <typename T>
inline std::string throw_typed_exception(
        const T& msg, const char* function_name, unsigned int line)
{
        std::string s = "\n\n =============== MRPT EXCEPTION =============\n";
        s += function_name;
        s += ", line ";
        s += mrpt::to_string(line);
        s += ":\n";
        s += msg;
        s += ":\n";
        return s;
}
 
/** \def THROW_EXCEPTION(msg);
 * \param msg This can be a char*, a std::string, or a literal string.
 * Defines a unified way of reporting exceptions
 * \sa MRPT_TRY_START, MRPT_TRY_END, THROW_EXCEPTION_FMT
 */
#define THROW_EXCEPTION(msg) THROW_TYPED_EXCEPTION(msg, std::logic_error);
 
#define THROW_EXCEPTION_FMT(_FORMAT_STRING, ...) \
        THROW_EXCEPTION(mrpt::format(_FORMAT_STRING, __VA_ARGS__));
 
#define THROW_TYPED_EXCEPTION_FMT(exceptionClass, _FORMAT_STRING, ...) \
        THROW_TYPED_EXCEPTION(                                             \
                mrpt::format(_FORMAT_STRING, __VA_ARGS__), exceptionClass)
 
/** \def THROW_STACKED_EXCEPTION
 * \sa MRPT_TRY_START, MRPT_TRY_END
 */
#define THROW_STACKED_EXCEPTION(e)                  \
        throw std::logic_error(throw_stacked_exception( \
                e, __FILE__, __LINE__, __CURRENT_FUNCTION_NAME__))
 
template <typename E>
inline std::string throw_stacked_exception(
        E&& e, const char* file, unsigned long line, const char* funcName)
{
        std::string s = e.what();
        s += "\n";
        s += file;
        s += ":";
        s += mrpt::to_string(line);
        s += ": In `";
        s += funcName;
        s += "`\n";
        return s;
}
 
/** \def THROW_STACKED_EXCEPTION_CUSTOM_MSG
 * \param e The caught exception.
 *      \param stuff Is a printf-like sequence of params, e.g: "The error happens
 *for x=%i",x
 */
#define THROW_STACKED_EXCEPTION_CUSTOM_MSG2(e, stuff, param1) \
        throw std::logic_error(throw_stacked_exception_custom_msg2(e, stuff, param1))
template <typename E, typename T>
inline std::string throw_stacked_exception_custom_msg2(
        E&& e, const char* stuff, T&& param1)
{
        std::string s = e.what();
        s += mrpt::format(stuff, param1);
        s += "\n";
        return s;
}
 
/** For use in CSerializable implementations */
#define MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(__V)                      \
        THROW_EXCEPTION(mrpt::format(                                          \
                "Cannot parse object: unknown serialization version number: '%i'", \
                static_cast<int>(__V)))
 
/** Defines an assertion mechanism.
 * \note Do NOT put code that must be always executed inside this statement, but
 * just comparisons. This is because users might require ASSERT_'s to be ignored
 * for optimized releases.
 * \sa MRPT_TRY_START, MRPT_TRY_END
 */
#define ASSERTMSG_(f, __ERROR_MSG)                             \
        do                                                         \
        {                                                          \
                if (!(f)) THROW_EXCEPTION(::std::string(__ERROR_MSG)); \
        } while (0)
 
/** Defines an assertion mechanism.
 * \note Do NOT put code that must be always executed inside this statement, but
 * just comparisons. This is because users might require ASSERT_'s to be ignored
 * for optimized releases.
 * \sa MRPT_TRY_START, MRPT_TRY_END
 */
#define ASSERT_(f) \
        ASSERTMSG_(f, std::string("Assert condition failed: ") + ::std::string(#f))
 
/** Throws an exception if the number is NaN, IND, or +/-INF, or return the same
 * number otherwise. */
#define MRPT_CHECK_NORMAL_NUMBER(v) \
        do                              \
        {                               \
                ASSERT_(std::isfinite(v));  \
                ASSERT_(!std::isnan(v));    \
        } while (0)
 
// Static asserts: use compiler version if we have a modern GCC (>=4.3) or MSVC
// (>=2010) version, otherwise rely on custom implementation:
#define MRPT_COMPILE_TIME_ASSERT(expression) \
        static_assert(expression, #expression)
 
#define ASRT_FAIL(__CONDITIONSTR, __A, __B, __ASTR, __BSTR) \
        THROW_EXCEPTION(asrt_fail(__CONDITIONSTR, __A, __B, __ASTR, __BSTR))
template <typename A, typename B>
inline std::string asrt_fail(
        std::string s, A&& a, B&& b, const char* astr, const char* bstr)
{
        s += "(";
        s += astr;
        s += ",";
        s += bstr;
        s += ") failed with\n";
        s += astr;
        s += "=";
        s += mrpt::to_string(a);
        s += "\n";
        s += bstr;
        s += "=";
        s += mrpt::to_string(b);
        s += "\n";
        return s;
}
 
/** Assert comparing two values, reporting their actual values upon failure */
#define ASSERT_EQUAL_(__A, __B)                                          \
        do                                                                   \
        {                                                                    \
                if (__A != __B) ASRT_FAIL("ASSERT_EQUAL_", __A, __B, #__A, #__B) \
        } while (0)
 
#define ASSERT_NOT_EQUAL_(__A, __B)                                          \
        do                                                                       \
        {                                                                        \
                if (__A == __B) ASRT_FAIL("ASSERT_NOT_EQUAL_", __A, __B, #__A, #__B) \
        } while (0)
 
#define ASSERT_BELOW_(__A, __B)                                          \
        do                                                                   \
        {                                                                    \
                if (__A >= __B) ASRT_FAIL("ASSERT_BELOW_", __A, __B, #__A, #__B) \
        } while (0)
 
#define ASSERT_ABOVE_(__A, __B)                                          \
        do                                                                   \
        {                                                                    \
                if (__A <= __B) ASRT_FAIL("ASSERT_ABOVE_", __A, __B, #__A, #__B) \
        } while (0)
 
#define ASSERT_BELOWEQ_(__A, __B)                                         \
        do                                                                    \
        {                                                                     \
                if (__A > __B) ASRT_FAIL("ASSERT_BELOWEQ_", __A, __B, #__A, #__B) \
        } while (0)
 
#define ASSERT_ABOVEEQ_(__A, __B)                                         \
        do                                                                    \
        {                                                                     \
                if (__A < __B) ASRT_FAIL("ASSERT_ABOVEEQ_", __A, __B, #__A, #__B) \
        } while (0)
 
/** Defines an assertion mechanism - only when compiled in debug.
 * \note Do NOT put code that must be always executed inside this statement, but
 * just comparisons. This is because users might require ASSERT_'s to be ignored
 * for optimized releases.
 * \sa MRPT_TRY_START, MRPT_TRY_END
 */
#ifdef _DEBUG
#define ASSERTDEB_(f) ASSERT_(f)
#define ASSERTDEBMSG_(f, __ERROR_MSG) ASSERTMSG_(f, __ERROR_MSG)
#define ASSERTDEB_EQUAL_(__A, __B) ASSERT_EQUAL_(__A, __B)
#define ASSERTDEB_NOT_EQUAL_(__A, __B) ASSERT_NOT_EQUAL_(__A, __B)
#define ASSERTDEB_BELOW_(__A, __B) ASSERT_BELOW_(__A, __B)
#define ASSERTDEB_ABOVE_(__A, __B) ASSERT_ABOVE_(__A, __B)
#define ASSERTDEB_BELOWEQ_(__A, __B) ASSERT_BELOWEQ_(__A, __B)
#define ASSERTDEB_ABOVEEQ_(__A, __B) ASSERT_ABOVEEQ_(__A, __B)
#else
#define ASSERTDEB_(f) \
        {                 \
        }
#define ASSERTDEBMSG_(f, __ERROR_MSG) \
        {                                 \
        }
#define ASSERTDEB_EQUAL_(__A, __B) {}
#define ASSERTDEB_NOT_EQUAL_(__A, __B) {}
#define ASSERTDEB_BELOW_(__A, __B) {}
#define ASSERTDEB_ABOVE_(__A, __B) {}
#define ASSERTDEB_BELOWEQ_(__A, __B) {}
#define ASSERTDEB_ABOVEEQ_(__A, __B) {}
 
#endif
 
/** The start of a standard MRPT "try...catch()" block that allows tracing throw
 * the call stack after an exception.
 * \sa MRPT_TRY_END,MRPT_TRY_END_WITH_CLEAN_UP
 */
#define MRPT_TRY_START \
        try                \
        {
/** The end of a standard MRPT "try...catch()" block that allows tracing throw
 * the call stack after an exception.
 * \sa MRPT_TRY_START,MRPT_TRY_END_WITH_CLEAN_UP
 */
#define MRPT_TRY_END                                                       \
        }                                                                      \
        catch (std::bad_alloc&) { throw; }                                     \
        catch (std::exception & __excep) { THROW_STACKED_EXCEPTION(__excep); } \
        catch (...) { THROW_EXCEPTION("Unexpected runtime error!"); }
/** The end of a standard MRPT "try...catch()" block that allows tracing throw
 * the call stack after an exception, including a "clean up" piece of code to be
 * run before throwing the exceptions.
 * \sa MRPT_TRY_END,MRPT_TRY_START
 */
#define MRPT_TRY_END_WITH_CLEAN_UP(stuff)         \
        }                                             \
        catch (std::bad_alloc&) { throw; }            \
        catch (std::exception & __excep)              \
        {                                             \
                {stuff} THROW_STACKED_EXCEPTION(__excep); \
        }                                             \
        catch (...) { {stuff} THROW_EXCEPTION("Unexpected runtime error!"); }
 
#if MRPT_ENABLE_EMBEDDED_GLOBAL_PROFILER
#define MRPT_PROFILE_FUNC_START               \
        ::mrpt::utils::CProfilerProxy BOOST_JOIN( \
                __dum_var, __LINE__)(__CURRENT_FUNCTION_NAME__);
#else
#define MRPT_PROFILE_FUNC_START
#endif
 
// General macros for use within each MRPT method/function. They provide:
//  - Nested exception handling
//  - Automatic profiling stats (in Debug only)
// ---------------------------------------------------------
#define MRPT_START          \
        MRPT_PROFILE_FUNC_START \
        MRPT_TRY_START
 
#define MRPT_END MRPT_TRY_END
 
#define MRPT_END_WITH_CLEAN_UP(stuff) MRPT_TRY_END_WITH_CLEAN_UP(stuff)