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 <boost/core/demangle.hpp>
 
#include <exception>
#include <string>
#include <vector>
#include <memory>
#include <ostream>
#include <chrono>
#include <thread>
#include <type_traits>
 
 
namespace rad {
 
class Exception : public std::exception {
 public:
  typedef std::chrono::system_clock clock_t;
 
  explicit Exception(const std::string& message);
 
  explicit Exception(const std::string& message, const std::string& info);
 
  virtual ~Exception() = default;
 
  const boost::stacktrace::stacktrace& GetStackTrace() const;
 
  const boost::stacktrace::stacktrace& GetOriginalStackTrace() const;
 
  std::string GetStackTraceAsString() const;
 
  std::string GetOriginalStackTraceAsString() const;
 
  std::string GetFullStackTraceAsString() const;
 
  std::chrono::time_point<clock_t> GetTimePoint() const;
 
  int64_t GetCreationDate() const;
 
  std::thread::id GetThreadId() const;
 
  int GetProcessId() const;
 
  std::string GetHostName() const;
 
 
  std::string GetTypeName() const;
 
  void SetLineNumber(uint32_t line_number);
 
  uint32_t GetLineNumber() const;
 
  void SetFunctionName(const std::string& function_name);
 
  const std::string& GetFunctionName() const;
 
  void SetFileName(const std::string& file_name);
 
  const std::string& GetFileName() const;
 
  void SetDetails(const std::string& details);
 
  std::string GetDetails() const;
 
  void SetClassName(const std::string& class_name);
 
  void SetExceptionStack(const std::vector<std::string>& nested_exceptions);
 
  std::vector<std::string> GetExceptionStack() const;
 
  std::string Dump() const;
 
  std::string DumpWithNested() const;
 
  virtual const char* what() const noexcept override;
 
 private:
  const std::string AdditionalDetails() const;
 
  /*
   * Attributes wrapper
   */
  struct Attrs {
      boost::stacktrace::stacktrace stack_trace;
      std::chrono::time_point<clock_t> date_time;
      std::thread::id thread_id;
      uint32_t line_number;
      std::string function_name;
      std::string file_name;
      std::string details;
      bool detail_set_by_user;
      std::string class_name;
      std::string message;
      std::vector<std::string> exception_stack;
  };
 
  std::shared_ptr<Attrs> m_attrs;
};
 
 
namespace {
 
template <typename T>
T CreateExceptionWithMessage(const char* file, int line, const char* function,
        const std::string& msg) {
    std::string fullmsg = msg;
    fullmsg += "\nSource file: " + std::string(file);
    fullmsg += "\nLine no.: " + std::to_string(line);
    fullmsg += "\nFunction: " + std::string(function);
    return T(fullmsg);
}
 
template <typename T, typename N>
T CreateExceptionObject(const N& nested_exception, const char* file, int line,
        const char* function, const std::string& msg) {
    if constexpr (std::is_base_of_v<Exception, T>) {
        T throwing_exception = T(msg);
        throwing_exception.SetFileName(boost::filesystem::path(file).filename().string());
        throwing_exception.SetFunctionName(function);
        throwing_exception.SetLineNumber(line);
        throwing_exception.SetClassName(boost::core::demangle(typeid(T).name()));
        std::vector<std::string> this_stack;
        this_stack.push_back(throwing_exception.GetTypeName());
        if constexpr (std::is_base_of_v<Exception, N>) {
            //std::vector<std::string> nested_stack = nested_exception.getCiiExceptionStack();
            std::vector<std::string> nested_stack = nested_exception.GetExceptionStack();
            this_stack.insert(this_stack.end(), nested_stack.begin(), nested_stack.end());
        }
        //throwing_exception.SetCiiExceptionStack(this_stack);
        throwing_exception.SetExceptionStack(this_stack);
        return throwing_exception;
    } else if constexpr (std::is_base_of_v<std::runtime_error, T> or
            std::is_base_of_v<std::logic_error, T>) {
        return CreateExceptionWithMessage<T>(file, line, function, msg);
    } else {
        return T(msg);
    }
}
 
}  // namespace anonymous
 
#define RAD_THROW(exceptionType_t, msg) { \
        throw rad::CreateExceptionObject<exceptionType_t>(0, __FILE__, __LINE__, __FUNCTION__, \
        msg); \
}
 
#define RAD_RETHROW(exceptionType_t, nested_exception, msg) { \
        exceptionType_t throwing_exception = rad::CreateExceptionObject<exceptionType_t>( \
                nested_exception, __FILE__, __LINE__, __FUNCTION__, msg); \
        std::throw_with_nested(throwing_exception); \
}
 
#define RAD_LOG_THROW(exceptionType_t, logger, msg) { \
        LOG4CPLUS_ERROR(logger, msg); \
        throw rad::CreateExceptionObject<exceptionType_t>(0, __FILE__, __LINE__, __FUNCTION__, \
                msg); \
}
 
std::ostream& operator<<(std::ostream& os, const rad::Exception& e);
 
}  // namespace rad
 
#endif  // RAD_EXCEPTIONS_HPP