Exceptions.hpp

Go to the documentation of this file.

#ifndef RAD_EXCEPTIONS_HPP
#define RAD_EXCEPTIONS_HPP

#include <rad/Helper.hpp>

//#include <boost/stacktrace.hpp>
#include <boost/filesystem.hpp>

#include <stdexcept>
#include <string>
#include <list>
#include <sstream>
#include <thread>

namespace rad {

namespace ErrorMsg {

const char* const DB_API_NULL       = "DB API returned NULL";
const char* const DB_REPLY_ERR      = "Received error reply from DB";
const char* const DB_CONTEXT_ERR    = "DB Context error";
const char* const MSG_CONTEXT_ERR   = "Error creating msg context";
const char* const MSG_SOCKET_ERR    = "Error creating socket";
const char* const MSG_CONNECT_ERR   = "Error connecting socket";
const char* const MSG_BIND_ERR      = "Error binding socket";
const char* const MSG_CONFIG_ERR    = "Error configuring socket";
const char* const CFG_LOAD          = "Loading configuration file";
const char* const OPT_INVALID       = "Invalid command line option";

}  // namespace ErrorMsg

class Exception : public std::exception /*std::runtime_error*/ {

public:
    Exception(const std::string& msg)
    : m_message(msg) {}

    Exception(const std::string& msg, const std::string& info)
    : m_message(BuildWhatArg(msg, info)) {}

    Exception(const Exception& e) :
        std::exception(e) {
        m_message = e.m_message;
    }

    virtual ~Exception() noexcept {}

    Exception& operator = (const Exception& e) {
        if (&e == this) return *this;
        std::exception::operator =(e);
        m_message = e.m_message;
        return *this;
    }

    void AddDiagnostic(const std::string& str) {
        m_message = m_message + "\n" + str;
    }

    virtual const char* what() const throw() {
        return m_message.c_str(); //std::runtime_error::what();

    }

private:
    std::string            m_message;
    // boost::stacktrace::stacktrace m_stackTrace;

    static const std::string BuildWhatArg(const std::string& msg, const std::string& info)
    {
        std::stringstream s;
        s << msg;
        if (info.size() > 0) {
            s << " (" << info << ")";
        }
        return s.str();
    }
};

class RuntimeDbException : public Exception {

public:
    RuntimeDbException(const std::string& msg) : Exception(msg) {}
    RuntimeDbException(const std::string& msg, const std::string& info) : Exception(msg, info) {}
    RuntimeDbException(const RuntimeDbException&) = default;
    virtual ~RuntimeDbException() noexcept {}
};

class InvalidOptionException : public Exception {

public:
    InvalidOptionException(const std::string& param) : Exception(ErrorMsg::OPT_INVALID, param) {}
    InvalidOptionException(const InvalidOptionException&) = default;
    virtual ~InvalidOptionException() noexcept {}
};

#define RAD_EXCEPTION_INFO(component, proc_name, version, severity, tag, text)\
                                                                              \
    std::stringstream buf;                                                    \
    buf << rad::GetTimestamp()                                   << " "       \
        << boost::filesystem::path(__FILE__).filename().string() << " "       \
        << __LINE__ << " " << __FUNCTION__  << " " << component  << " "       \
        << rad::Helper::GetHostname() << " " << proc_name        << " "       \
        << std::hex << std::this_thread::get_id() << " " << getpid() << std::dec << " " \
        << version << " " << severity << " " << tag << " " << text;

#define RAD_THROW(msg, component, proc_name, version, severity, tag)     \
                                                                         \
    RAD_EXCEPTION_INFO(component, proc_name, version, severity, tag, "") \
    throw rad::Exception(msg, buf.str());

#define RAD_RETHROW(exception, component, proc_name, version, severity, tag, text) \
                                                                                   \
    RAD_EXCEPTION_INFO(component, proc_name, version, severity, tag, text)         \
    exception.AddDiagnostic(buf.str());                                            \
    throw;

}  // namespace rad

#endif  // RAD_EXCEPTIONS_HPP