Exception.h

Go to the documentation of this file.

 
#ifndef ELEMENTSKERNEL_ELEMENTSKERNEL_EXCEPTION_H_
#define ELEMENTSKERNEL_ELEMENTSKERNEL_EXCEPTION_H_
 
#include <cstddef>  // for size_t
#include <cstdio>
#include <exception>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
 
#include "ElementsKernel/Exit.h"
#include "ElementsKernel/Export.h"  // for ELEMENTS_API
 
namespace Elements {
 
class ELEMENTS_API Exception : public std::exception {
public:
  explicit Exception(ExitCode e = ExitCode::NOT_OK) : m_exit_code{e} {}
 
  explicit Exception(const char* message, ExitCode e = ExitCode::NOT_OK) : m_error_msg(message), m_exit_code{e} {}
 
  explicit Exception(const std::string& message, ExitCode e = ExitCode::NOT_OK)
      : m_error_msg(message), m_exit_code{e} {}
 
  template <typename... Args>
  explicit Exception(const char* stringFormat, Args&&... args) : m_exit_code{ExitCodeHelper<Args...>{args...}.code} {
    std::size_t len     = snprintf(nullptr, 0, stringFormat, std::forward<Args>(args)...) + 1;
    char*       message = new char[len];
    snprintf(message, len, stringFormat, std::forward<Args>(args)...);
    m_error_msg = std::string(message);
    delete[] message;
  }
 
  virtual ~Exception() noexcept = default;
 
  const char* what() const noexcept override {
    return m_error_msg.c_str();
  }
 
  ExitCode exitCode() const noexcept {
    return m_exit_code;
  }
 
  template <typename T>
  void appendMessage(const T& message) {
    std::stringstream new_message;
    new_message << m_error_msg << message;
    m_error_msg = new_message.str();
  }
 
protected:
  std::string    m_error_msg{};
  const ExitCode m_exit_code{ExitCode::NOT_OK};
 
private:
  template <typename... Args>
  struct ExitCodeHelper {};
 
  // Specialisation which handles the last argument
  template <typename Last>
  struct ExitCodeHelper<Last> {
    explicit ExitCodeHelper(const Last& last) : code{getCode(last)} {}
    ExitCode code;
 
  private:
    // This method is used if the T is an ExitCode object
    template <typename T, typename std::enable_if<std::is_same<T, ExitCode>::value>::type* = nullptr>
    ExitCode getCode(const T& t) {
      return t;
    }
    // This method is used when the T is not an ExitCode object
    template <typename T, typename std::enable_if<not std::is_same<T, ExitCode>::value>::type* = nullptr>
    ExitCode getCode(const T&) {
      return ExitCode::NOT_OK;
    }
  };
 
  // Specialization which handles two or more arguments
  template <typename First, typename... Rest>
  struct ExitCodeHelper<First, Rest...> : ExitCodeHelper<Rest...> {
    ExitCodeHelper(const First&, const Rest&... rest) : ExitCodeHelper<Rest...>(rest...) {}
  };
};
 
template <typename Ex, typename T,
          typename = typename std::enable_if<
              std::is_base_of<Exception, typename std::remove_reference<Ex>::type>::value>::type>
auto operator<<(Ex&& ex, const T& message) -> decltype(std::forward<Ex>(ex)) {
  ex.appendMessage(message);
  return std::forward<Ex>(ex);
}
 
}  // namespace Elements
 
#endif  // ELEMENTSKERNEL_ELEMENTSKERNEL_EXCEPTION_H_