exceptions.hpp

Go to the documentation of this file.

#ifndef RAD_EXCEPTIONS_HPP
#define RAD_EXCEPTIONS_HPP

#include <rad/helper.hpp>
#include <rad/logger.hpp>

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

#include <list>
#include <sstream>
#include <stdexcept>
#include <string>
#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:
    explicit 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 noexcept {
        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:
    explicit 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:
    explicit 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