Exception.hpp

Go to the documentation of this file.

#pragma once
#include <cpr/status_codes.h>
#include <stdexcept>
#include <string>
 
namespace tgbotxx {
  enum class ErrorCode : std::int32_t {
    OTHER = 0,
 
    SEE_OTHER = cpr::status::HTTP_SEE_OTHER,
 
    BAD_REQUEST = cpr::status::HTTP_BAD_REQUEST,
 
    UNAUTHORIZED = cpr::status::HTTP_UNAUTHORIZED,
 
    FORBIDDEN = cpr::status::HTTP_FORBIDDEN,
 
    NOT_FOUND = cpr::status::HTTP_NOT_FOUND,
 
    NOT_ACCEPTABLE = cpr::status::HTTP_NOT_ACCEPTABLE,
 
    FLOOD = 420,
 
    CONFLICT = cpr::status::HTTP_CONFLICT,
 
    TOO_MANY_REQUESTS = cpr::status::HTTP_TOO_MANY_REQUESTS,
 
    BAD_GATEWAY = cpr::status::HTTP_BAD_GATEWAY,
 
    REQUEST_CANCELLED = 499,
 
    INTERNAL = cpr::status::HTTP_INTERNAL_SERVER_ERROR
  };
  static std::ostream& operator<<(std::ostream& os, const ErrorCode& errorCode) noexcept {
     switch (errorCode) {
       case ErrorCode::OTHER: return os << "OTHER";
       case ErrorCode::SEE_OTHER: return os << "SEE_OTHER";
       case ErrorCode::BAD_REQUEST: return os << "BAD_REQUEST";
       case ErrorCode::UNAUTHORIZED: return os << "UNAUTHORIZED";
       case ErrorCode::FORBIDDEN: return os << "FORBIDDEN";
       case ErrorCode::NOT_FOUND: return os << "NOT_FOUND";
       case ErrorCode::NOT_ACCEPTABLE: return os << "NOT_ACCEPTABLE";
       case ErrorCode::FLOOD: return os << "FLOOD";
       case ErrorCode::CONFLICT: return os << "CONFLICT";
       case ErrorCode::TOO_MANY_REQUESTS: return os << "TOO_MANY_REQUESTS";
       case ErrorCode::BAD_GATEWAY: return os << "BAD_GATEWAY";
       case ErrorCode::REQUEST_CANCELLED: return os << "REQUEST_CANCELLED";
       case ErrorCode::INTERNAL: return os << "INTERNAL";
       default: return os << "Unknown ErrorCode (" << static_cast<std::int32_t>(errorCode) << ')';
     }
  }
 
  static bool isErrorCode(const std::int32_t c) noexcept {
    switch (c) {
      case static_cast<std::int32_t>(ErrorCode::OTHER):
      case static_cast<std::int32_t>(ErrorCode::SEE_OTHER):
      case static_cast<std::int32_t>(ErrorCode::BAD_REQUEST):
      case static_cast<std::int32_t>(ErrorCode::UNAUTHORIZED):
      case static_cast<std::int32_t>(ErrorCode::FORBIDDEN):
      case static_cast<std::int32_t>(ErrorCode::NOT_FOUND):
      case static_cast<std::int32_t>(ErrorCode::NOT_ACCEPTABLE):
      case static_cast<std::int32_t>(ErrorCode::FLOOD):
      case static_cast<std::int32_t>(ErrorCode::CONFLICT):
      case static_cast<std::int32_t>(ErrorCode::TOO_MANY_REQUESTS):
      case static_cast<std::int32_t>(ErrorCode::BAD_GATEWAY):
      case static_cast<std::int32_t>(ErrorCode::REQUEST_CANCELLED):
      case static_cast<std::int32_t>(ErrorCode::INTERNAL):
        return true;
      default:
        return false;
    }
  }
 
  class Exception : public std::runtime_error {
      const ErrorCode m_errorCode; 
 
    public:
      explicit Exception(const std::string& errMessage) : std::runtime_error(errMessage), m_errorCode(ErrorCode::OTHER) {}
      explicit Exception(const std::string& errMessage, ErrorCode errCode) : std::runtime_error(errMessage), m_errorCode(errCode) {}
 
      [[nodiscard]] ErrorCode errorCode() const noexcept {
        return m_errorCode;
      }
  };
}