exceptions.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_EXCEPTIONS_HPP
#define RTCTK_COMPONENTFRAMEWORK_EXCEPTIONS_HPP
 
#include <exception>
#include <string>
#include <vector>
#include <ostream>
#include <chrono>
#include <thread>
#include <type_traits>
 
#include <boost/stacktrace.hpp>
#include <boost/filesystem.hpp>
#include <boost/core/demangle.hpp>
 
namespace elt {
namespace error {
 
class CiiException : public std::exception {
 public:
  typedef std::chrono::system_clock clock_t;
 
  explicit CiiException(const std::string& message);
 
  template<typename ... Args>
  explicit CiiException(const std::string& formatter, Args ... args)
      : CiiException(BuildFormattedString(formatter, args...)) {
  }
 
  virtual ~CiiException() = default;
 
  virtual std::string getCiiType() const {
    return m_attribs->ciiType;
  }
 
  virtual std::string getCiiMethodName() const {
    return m_attribs->ciiMethodName;
  }
 
  virtual std::string getCiiClassName() const {
    return m_attribs->ciiClassName;
  }
 
  virtual std::string getCiiFileName() const {
    return m_attribs->ciiFileName;
  }
 
  virtual std::string getCiiHostName() const {
    return m_attribs->ciiHostName;
  }
 
  virtual std::string getCiiStackTrace() const;
 
  virtual std::vector<std::string> getCiiExceptionStack() const {
    return m_attribs->ciiExceptionStack;
  }
 
  virtual std::string getCiiMessage() const {
    return m_attribs->ciiMessage;
  }
 
  virtual std::string getCiiDetails() const {
    return m_attribs->ciiDetails;
  }
 
  virtual int64_t getCiiCreationDate() const {
    return m_attribs->ciiCreationDate;
  }
 
  const std::string GetCiiStackTrace() const noexcept {
    return getCiiStackTrace();
  }
 
  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;
 
  const std::string& GetHostName() const;
 
 
  std::string GetTypeName() const;
 
  void SetLineNumber(uint32_t lineNumber);
 
  uint32_t GetLineNumber() const;
 
  void SetFunctionName(const std::string& functionName);
 
  const std::string& GetFunctionName() const;
 
  void SetFileName(const std::string& fileName);
 
  const std::string& GetFileName() const;
 
  void SetDetails(const std::string& details);
 
  std::string GetDetails() const;
 
  void SetClassName(const std::string& className);
 
  std::string Dump() const;
 
  std::string GetSeverity() const;
 
  std::string DumpWithNested() const;
 
  const char* what() const noexcept override;
 
  const char* What() const noexcept {
    return what();
  }
 
  void SetCiiExceptionStack(const std::vector<std::string>& nested_exceptions);
 
 private:
  template<typename ... Args>
  static std::string BuildFormattedString(const std::string& formatter,
                                          Args ... args) {
    int finalStringSize = std::snprintf(nullptr, 0, formatter.c_str(), args...);
    std::vector<char> buffer((size_t) finalStringSize + 1);
    std::snprintf(buffer.data(), buffer.size(), formatter.c_str(), args...);
    return std::string(buffer.data(), (size_t) finalStringSize);
  }
 
  const std::string AdditionalDetails() const;
 
  struct Attributes {
    Attributes();
 
    std::string ciiType;
    std::string ciiMethodName;
    std::string ciiClassName;
    std::string ciiFileName;
    std::string ciiHostName;
    std::string ciiStackTrace;
    std::vector<std::string> ciiExceptionStack;
    std::string ciiMessage;
    std::string ciiDetails;
    int64_t ciiCreationDate;
 
    const boost::stacktrace::stacktrace m_stack_trace;
    const std::chrono::time_point<clock_t> m_date_time;
    const std::thread::id m_thread_id;
    const int m_process_id;
    const std::string m_host_name;
 
    uint32_t m_line_number;
    std::string m_function_name;
    std::string m_file_name;
    std::string m_details;
    std::string m_severity;
    bool m_detail_set_by_user;
  };
 
  std::shared_ptr<Attributes> m_attribs;
};
 
 
class CiiBaseException : public CiiException {
 public:
  using CiiException::CiiException;
 
  std::string GetSeverity() const{
    return "Exception";
  }
};
 
 
class CiiError: public CiiException {
 public:
  using CiiException::CiiException;
 
  std::string GetSeverity() const{
    return "Error";
  }
};
 
 
} // namespace error
} // namespace elt
 
std::ostream& operator<<(std::ostream& os, const elt::error::CiiException& e);
 
namespace {
 
// Constructs an exception object that takes a string message as the first argument.
// The file name, line number and function name will be appended to the message.
template <typename T, typename... Args>
T CreateExceptionWithMessage(const char* file, int line, const char* function,
                             const std::string& msg, Args&&... args) {
    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, std::forward<Args>(args)...);
}
 
// Constructs an exception object. Depending on the type of the exception, additional context
// information is added to the object if supported.
// This function is used to implement the CII_THROW and CII_THROW_WITH_NESTED macros.
template <typename T, typename N, typename... Args>
T CreateExceptionObject(const N& nested_exception, const char* file, int line, const char* function,
                        Args&&... args) {
    if constexpr (std::is_base_of_v<elt::error::CiiException, T>) {
        T throwing_exception = T(std::forward<Args>(args)...);
        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<elt::error::CiiException, N>) {
            std::vector<std::string> nested_stack = nested_exception.getCiiExceptionStack();
            this_stack.insert(this_stack.end(), nested_stack.begin(), nested_stack.end());
        }
        throwing_exception.SetCiiExceptionStack(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, std::forward<Args>(args)...);
    } else {
        return T(std::forward<Args>(args)...);
    }
}
 
} // namespace anonymous
 
#define CII_THROW(exceptionType_t, ...) { \
        throw CreateExceptionObject<exceptionType_t>(0, __FILE__, __LINE__, __FUNCTION__, \
                                                     __VA_ARGS__); \
    }
 
#define CII_THROW_WITH_NESTED(exceptionType_t, nested_exception, ...) { \
        exceptionType_t throwing_exception = CreateExceptionObject<exceptionType_t>( \
                                nested_exception, __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__); \
        std::throw_with_nested(throwing_exception); \
    }
 
#endif // RTCTK_COMPONENTFRAMEWORK_EXCEPTIONS_HPP