ucom3/include/adtfucom3/exception_handling.h

Go to the documentation of this file.

 
#pragma once
 
#include <a_utils.h>
#include <string>
#include <sstream>
#include <exception>
 
namespace adtf
{
namespace ucom
{
namespace kiwi
{
 
std::string nested_exceptions_to_string(const std::exception& error);
 
namespace detail
{
 
inline void format_nested_exception(const std::exception& error, std::ostream& stream, bool add_line_break = false)
{
    try
    {
        std::rethrow_if_nested(error);
    }
    catch (const std::exception& nested_exception)
    {
        format_nested_exception(nested_exception, stream, true);
    }
    catch (...)
    {
    }
 
    stream << "exception: " << error.what();
    if (add_line_break)
    {
        stream << '\n';
    }
}
 
inline tResult annotate_result(const tResult& oOriginal,
                               const char* strFile,
                               int nLine,
                               const char* strFunction,
                               const tChar* strDescription = "")
{
    const auto strOriginalDescription = oOriginal.GetDescription();
 
 
 
    const auto strAnnotatedDescription = adtf::util::cString::Format("%s [%s:%d(%s)]\n%s",
                                                                     strOriginalDescription,
                                                                     adtf::util::cFilename(oOriginal.GetFile()).GetName().GetPtr(),
                                                                     oOriginal.GetLine(),
                                                                     oOriginal.GetFunction(),
                                                                     strDescription);
 
    return tResult(oOriginal.GetErrorCode(),
                   strAnnotatedDescription,
                   nLine,
                   adtf::util::cFilename(strFile).GetName().GetPtr(),
                   strFunction);
}
 
inline tResult current_exception_to_result(const char* file, size_t line, const char* function)
{
    auto exception = std::current_exception();
    try
    {
        if (exception)
        {
            std::rethrow_exception(exception);
        }
    }
    catch(const std::exception& error)
    {
        return tResult(ERR_FAILED,
                       adtf::ucom::kiwi::nested_exceptions_to_string(error).c_str(),
                       static_cast<int32_t>(line),
                       adtf::util::cFilename(file).GetName(),
                       function);
    }
    catch(const tResult& oError)
    {
        return annotate_result(oError, file, static_cast<int32_t>(line), function);
    }
    catch(...)
    {
        return tResult(ERR_FAILED,
                       "unknown exception",
                       static_cast<int32_t>(line),
                       file,
                       function);
    }
 
    RETURN_NOERROR;
}
 
 
 
}
 
inline std::string nested_exceptions_to_string(const std::exception& error)
{
    std::ostringstream stream;
    detail::format_nested_exception(error, stream);
    return stream.str();
}
 
inline std::string current_exception_to_string()
{
    auto exception = std::current_exception();
    try
    {
        if (exception)
        {
            std::rethrow_exception(exception);
        }
    }
    catch(const std::exception& error)
    {
        return nested_exceptions_to_string(error);
    }
    catch(const tResult& oError)
    {
        return adtf::util::to_string(oError).GetPtr();
    }
    catch(...)
    {
        return "unknown exception";
    }
 
    return "";
}
 
inline tResult current_exception_to_result()
{
    return detail::current_exception_to_result(__FILE__, __LINE__, __FUNC__);
}
 
}
 
using kiwi::nested_exceptions_to_string;
using kiwi::current_exception_to_string;
using kiwi::current_exception_to_result;
 
}
}
 
#define ADTF_UCOM_ANNOTATE_RESULT(_result) adtf::ucom::kiwi::detail::annotate_result(_result, __FILE__, __LINE__, __FUNC__)
 
#define ADTF_UCOM_COMPOSED_RESULT(_result, ...) adtf::ucom::kiwi::detail::annotate_result(_result, __FILE__, __LINE__, __FUNC__, adtf::util::cString::Format(__VA_ARGS__).GetPtr())
 
#define THROW_ERROR_DESC(_code, ...) throw DETAILED_RESULT(_code, __VA_ARGS__)
#define THROW_IF_FAILED(s)            { tResult _errcode(s); if ( _errcode.IsFailed() ) { throw ADTF_UCOM_ANNOTATE_RESULT(_errcode); } }
#define THROW_IF_FAILED_DESC(s, ...)  { tResult _errcode(s); if ( _errcode.IsFailed() ) { throw ADTF_UCOM_COMPOSED_RESULT(_errcode, __VA_ARGS__); } }
 
#define RETURN_CURRENT_EXCEPTION() return adtf::ucom::kiwi::detail::current_exception_to_result(__FILE__, __LINE__, __FUNC__)
#define RETURN_CURRENT_EXCEPTION_DESC(...) return ADTF_UCOM_COMPOSED_RESULT(adtf::ucom::kiwi::detail::current_exception_to_result(__FILE__, __LINE__, __FUNC__), __VA_ARGS__)
 
#define RETURN_IF_THROWS(s) { try { (s); } catch(...) { RETURN_CURRENT_EXCEPTION(); } }
#define RETURN_IF_THROWS_DESC(s, ...) { try { (s); } catch(...) { RETURN_CURRENT_EXCEPTION_DESC(__VA_ARGS__); } }
 
// redefine RETURN_IF_FAILED macros in order to catch exceptions and retain the previous error description(s)
#ifdef RETURN_IF_FAILED
    #undef RETURN_IF_FAILED
#endif
#define RETURN_IF_FAILED(s)  { try { tResult _errcode(s); if ( _errcode.IsFailed() ) { return ADTF_UCOM_ANNOTATE_RESULT(_errcode); } } catch (...) { RETURN_CURRENT_EXCEPTION(); } }
 
#ifdef RETURN_IF_FAILED_DESC
    #undef RETURN_IF_FAILED_DESC
#endif
#define RETURN_IF_FAILED_DESC(s, ...)  { try { tResult _errcode(s); if ( _errcode.IsFailed() ) { return ADTF_UCOM_COMPOSED_RESULT(_errcode, __VA_ARGS__); } } catch (...) { RETURN_CURRENT_EXCEPTION_DESC(__VA_ARGS__); } }