exception_utils.h

Go to the documentation of this file.

/*******************************************************************\
 
Module: Exception helper utilities
 
Author: Fotis Koutoulakis, fotis.koutoulakis@diffblue.com
 
\*******************************************************************/
 
#ifndef CPROVER_UTIL_EXCEPTION_UTILS_H
#define CPROVER_UTIL_EXCEPTION_UTILS_H
 
#include "invariant.h"
#include "source_location.h"
 
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>

class cprover_exception_baset
{
public:
  virtual std::string what() const;
  virtual ~cprover_exception_baset() = default;
 
  cprover_exception_baset() = default;
 
  cprover_exception_baset(cprover_exception_baset &&) = default;
 
  // std::ostringstream does not have a copy constructor
  cprover_exception_baset(const cprover_exception_baset &src)
  {
    _reason << src.reason();
  }
 
  std::string reason() const
  {
    return _reason.str();
  }
 
protected:
  explicit cprover_exception_baset(std::string reason)
  {
    // ostringstream does not have an appropriate constructor
    _reason << reason;
  }

  std::ostringstream _reason;
 
  // to provide access to the _reason field
  template <typename E, typename T>
  friend std::enable_if_t<
    std::is_base_of<cprover_exception_baset, std::decay_t<E>>::value,
    E &&>
  operator<<(E &&, const T &);
};

template <typename E, typename T>
std::enable_if_t<
  std::is_base_of<cprover_exception_baset, std::decay_t<E>>::value,
  E &&>
operator<<(E &&e, const T &message)
{
  e._reason << message;
  return std::forward<E>(e);
}

class invalid_command_line_argument_exceptiont : public cprover_exception_baset
{
  std::string option;
  std::string correct_input;
 
public:
  invalid_command_line_argument_exceptiont(
    std::string reason,
    std::string option,
    std::string correct_input = "");
 
  std::string what() const override;
};

class system_exceptiont : public cprover_exception_baset
{
public:
  explicit system_exceptiont(std::string message);
};

class deserialization_exceptiont : public cprover_exception_baset
{
public:
  explicit deserialization_exceptiont(std::string message);
};

class incorrect_goto_program_exceptiont : public cprover_exception_baset
{
public:
  explicit incorrect_goto_program_exceptiont(std::string message);
 
  template <typename Diagnostic, typename... Diagnostics>
  incorrect_goto_program_exceptiont(
    std::string message,
    Diagnostic &&diagnostic,
    Diagnostics &&... diagnostics);
 
  template <typename... Diagnostics>
  incorrect_goto_program_exceptiont(
    std::string message,
    source_locationt source_location,
    Diagnostics &&... diagnostics);
 
  std::string what() const override;
 
private:
  source_locationt source_location;
 
  std::string diagnostics;
};
 
template <typename Diagnostic, typename... Diagnostics>
incorrect_goto_program_exceptiont::incorrect_goto_program_exceptiont(
  std::string message,
  Diagnostic &&diagnostic,
  Diagnostics &&... diagnostics)
  : cprover_exception_baset(std::move(message)),
    source_location(source_locationt::nil()),
    diagnostics(detail::assemble_diagnostics(
      std::forward<Diagnostic>(diagnostic),
      std::forward<Diagnostics>(diagnostics)...))
{
}
 
template <typename... Diagnostics>
incorrect_goto_program_exceptiont::incorrect_goto_program_exceptiont(
  std::string message,
  source_locationt source_location,
  Diagnostics &&... diagnostics)
  : cprover_exception_baset(std::move(message)),
    source_location(std::move(source_location)),
    diagnostics(
      detail::assemble_diagnostics(std::forward<Diagnostics>(diagnostics)...))
{
}

class unsupported_operation_exceptiont : public cprover_exception_baset
{
public:
  explicit unsupported_operation_exceptiont(std::string message);
};

class analysis_exceptiont : public cprover_exception_baset
{
public:
  explicit analysis_exceptiont(std::string reason);
};

class invalid_input_exceptiont : public cprover_exception_baset
{
public:
  explicit invalid_input_exceptiont(std::string reason);
};

class invalid_source_file_exceptiont : public invalid_input_exceptiont
{
public:
  invalid_source_file_exceptiont(
    std::string reason,
    source_locationt source_location);
  std::string what() const override;
 
  // This method will go away, in favor of cprover_exception_baset::reason
  std::string get_reason() const
  {
    return reason();
  }
 
  const source_locationt &get_source_location() const
  {
    return source_location;
  }
 
private:
  source_locationt source_location;
};
 
#endif // CPROVER_UTIL_EXCEPTION_UTILS_H