SpartaException.hpp

Go to the documentation of this file.

// <SpartaException.hpp> -*- C++ -*-
 
#pragma once
 
#include <exception>
#include <sstream>
#include <string>
#include <memory>
 
#define THROW_IF_NOT_UNWINDING(exclass, msg_construct) \
    if(std::uncaught_exceptions() > 0){                     \
        std::cerr << msg_construct << std::endl;       \
    }else{                                             \
        throw exclass() << msg_construct;              \
    }
 
#define DO_PRAGMA(x) _Pragma(#x)
#define TERMINATING_THROW(exclass, msg_construct)      \
    DO_PRAGMA(GCC diagnostic push)                     \
    DO_PRAGMA(GCC diagnostic ignored "-Wterminate")    \
    throw exclass() << msg_construct;                  \
    DO_PRAGMA(GCC diagnostic pop)
 
namespace sparta
{
    namespace app
    {
        class BacktraceData;
    }
 
    class SpartaException : public std::exception
    {
    public:
 
        SpartaException();
 
        SpartaException(const std::string & reason);
 
        SpartaException(const SpartaException & orig);
 
        virtual ~SpartaException() noexcept;
 
        const char* what() const noexcept {
            reason_str_ = reason_.str();
            return reason_str_.c_str();
        }
 
        std::string backtrace() const noexcept;
 
        std::string rawReason() const {
            return raw_reason_;
        }
 
        template<class T>
        SpartaException & operator<<(const T & msg) {
            reason_ << msg;
            return *this;
        }
 
    private:
        // The raw reason without file/line information
        std::string raw_reason_;
 
        // The reason/explanation for the exception
        std::stringstream reason_;
 
        // Backtrace at the time of the exception
        std::unique_ptr<app::BacktraceData> bt_;
 
        // Need to keep a local copy of the string formed in the
        // string stream for the 'what' call
        mutable std::string reason_str_;
    };
 
 
    class SpartaCriticalError : public SpartaException
    {
    public:
 
        SpartaCriticalError() :
            SpartaException()
        { }
 
        SpartaCriticalError(const std::string & reason) :
            SpartaException(reason)
        { }
    };
 
    class SpartaFatalError : public SpartaException
    {
    public:
 
        SpartaFatalError() :
            SpartaException()
        { }
 
        SpartaFatalError(const std::string & reason) :
            SpartaException(reason)
        { }
    };
 
}