exception.h

#pragma once
 
#include <stdexcept>
#include <string>
 
namespace delpi {

class DelpiException : public std::runtime_error {
 public:
  explicit DelpiException(const char* const message) : std::runtime_error{message} {}
  explicit DelpiException(const std::string& message) : std::runtime_error{message} {}
};

class DelpiNotImplementedException final : public DelpiException {
 public:
  DelpiNotImplementedException() : DelpiException("Not yet implemented") {}
  explicit DelpiNotImplementedException(const char* const message) : DelpiException{message} {}
  explicit DelpiNotImplementedException(const std::string& message) : DelpiException{message} {}
};

class DelpiNotSupportedException final : public DelpiException {
 public:
  DelpiNotSupportedException() : DelpiException("Not supported") {}
  explicit DelpiNotSupportedException(const char* const message) : DelpiException{message} {}
  explicit DelpiNotSupportedException(const std::string& message) : DelpiException{message} {}
};

class DelpiInvalidArgumentException final : public DelpiException, private std::invalid_argument {
 public:
  DelpiInvalidArgumentException() : DelpiException("Invalid argument"), std::invalid_argument{""} {}
  explicit DelpiInvalidArgumentException(const char* const message)
      : DelpiException{message}, std::invalid_argument{message} {}
  explicit DelpiInvalidArgumentException(const std::string& message)
      : DelpiException{message}, std::invalid_argument{message} {}
};

class DelpiAssertionException final : public DelpiException {
 public:
  explicit DelpiAssertionException(const char* const message) : DelpiException{message} {}
  explicit DelpiAssertionException(const std::string& message) : DelpiException{message} {}
};

class DelpiLpSolverException final : public DelpiException {
 public:
  explicit DelpiLpSolverException(const char* const message) : DelpiException{message} {}
  explicit DelpiLpSolverException(const std::string& message) : DelpiException{message} {}
};

class DelpiParserException final : public DelpiException {
 public:
  explicit DelpiParserException(const char* const message) : DelpiException{message} {}
  explicit DelpiParserException(const std::string& message) : DelpiException{message} {}
};

class DelpiOutOfRangeException final : public DelpiException, private std::out_of_range {
 public:
  explicit DelpiOutOfRangeException(const char* const message) : DelpiException{message}, std::out_of_range{message} {}
  explicit DelpiOutOfRangeException(const std::string& message) : DelpiException{message}, std::out_of_range{message} {}
};

class DelpiUnreachableException final : public DelpiException {
 public:
  DelpiUnreachableException() : DelpiException("Unreachable code") {}
  explicit DelpiUnreachableException(const char* const message) : DelpiException{message} {}
  explicit DelpiUnreachableException(const std::string& message) : DelpiException{message} {}
};
 
}  // namespace delpi