error.hh

Go to the documentation of this file.

#ifndef __OPERATOR_ERROR_HH_
#define __OPERATOR_ERROR_HH_

#include <json.hpp>

#include <functional>
#include <map>
#include <string>

namespace Operator {
  namespace Error {
    class Error {
    protected:
      Error() {};
    public:
      virtual ~Error() {};
      virtual std::string to_string() const = 0;
    };

    class InvalidData : public Error {
    public:
      InvalidData(const std::string &_description)
        : description(_description)
        {}
      std::string to_string() const { return description; };
    private:
      std::string description;
    };

    class MatrixError : public Error {
    public:
      virtual const std::string &getErrorCode() const = 0;
      const std::string &getError() const { return error; }
      unsigned short getStatusCode() const { return status_code; }
      const std::map<std::string,nlohmann::json> &getData() const { return other_data; }

      static Error * newError(unsigned short status_code, const nlohmann::json &data) throw ();

      std::string to_string() const { return getErrorCode() + " (" + std::to_string(getStatusCode()) + "): " + getError(); }

      static const char M_FORBIDDEN[];
      static const char M_UNKNOWN_TOKEN[];
      static const char M_BAD_JSON[];
      static const char M_NOT_JSON[];
      static const char M_NOT_FOUND[];
      static const char M_LIMIT_EXCEEDED[];
      static const char M_USER_IN_USE[];
      static const char M_INVALID_USERNAME[];
      static const char M_ROOM_IN_USE[];
      static const char M_BAD_PAGINATION[];
      static const char M_THREEPID_IN_USE[];
      static const char M_THREEPID_NOT_FOUND[];
      static const char M_SERVER_NOT_TRUSTED[];
      static const char M_WEAK_PASSWORD[];
      static const char M_UNKNOWN[];
      static const char M_EXCLUSIVE[];
      static const char M_MISSING_PARAM[];

      typedef std::function<MatrixError *(unsigned short, const std::string &, const std::string &, std::map<std::string,nlohmann::json> &)> error_builder_t;
      static void registerErrorClass(const std::string &error_code, error_builder_t);
      template<typename T> static MatrixError *_new_helper(unsigned short _status_code, const std::string &, const std::string &_error, std::map<std::string,nlohmann::json> &_other_data) {
        return new T(_status_code, _error, _other_data);
      }
    private:
      unsigned short status_code;
      std::string error;
      std::map<std::string,nlohmann::json> other_data;
    protected:
      MatrixError(unsigned short _status_code, const std::string &_error, std::map<std::string,nlohmann::json> &_other_data)
        : status_code(_status_code),
          error(_error),
          other_data(std::move(_other_data))
        {}
    };

    template<const char *c> class _MatrixErr : public MatrixError {
    public:
      _MatrixErr(unsigned short _status_code, std::string _error, std::map<std::string,nlohmann::json> &_other_data)
        : MatrixError(_status_code, _error, _other_data) {}

      const std::string &getErrorCode() const { return ERROR_CODE; }
      static const std::string ERROR_CODE;
    };

    using MatrixForbidden = _MatrixErr<MatrixError::M_FORBIDDEN>;
    using MatrixUnknownToken = _MatrixErr<MatrixError::M_UNKNOWN_TOKEN>;
    using MatrixBadJson = _MatrixErr<MatrixError::M_BAD_JSON>;
    using MatrixNotJson = _MatrixErr<MatrixError::M_NOT_JSON>;
    using MatrixNotFound = _MatrixErr<MatrixError::M_NOT_FOUND>;
    using MatrixLimitExceeded = _MatrixErr<MatrixError::M_LIMIT_EXCEEDED>;
    using MatrixUserInUse = _MatrixErr<MatrixError::M_USER_IN_USE>;
    using MatrixInvalidUsername = _MatrixErr<MatrixError::M_INVALID_USERNAME>;
    using MatrixRoomInUse = _MatrixErr<MatrixError::M_ROOM_IN_USE>;
    using MatrixBadPagination = _MatrixErr<MatrixError::M_BAD_PAGINATION>;
    using MatrixThreepidInUse = _MatrixErr<MatrixError::M_THREEPID_IN_USE>;
    using MatrixThreepidNotFound = _MatrixErr<MatrixError::M_THREEPID_NOT_FOUND>;
    using MatrixServerNotTrusted = _MatrixErr<MatrixError::M_SERVER_NOT_TRUSTED>;
    using MatrixWeakPassword = _MatrixErr<MatrixError::M_WEAK_PASSWORD>;
    using MatrixUnknown = _MatrixErr<MatrixError::M_UNKNOWN>;
    using MatrixExclusive = _MatrixErr<MatrixError::M_EXCLUSIVE>;
    using MatrixMissingParam = _MatrixErr<MatrixError::M_MISSING_PARAM>;

    class OtherMatrixError : public MatrixError {
    public:
      OtherMatrixError(unsigned short _status_code, const std::string &_error_code, const std::string &_error, std::map<std::string,nlohmann::json> &_other_data)
        : MatrixError(_status_code, _error, _other_data),
          error_code(_error_code)
        {}
      const std::string &getErrorCode() const { return error_code; }
    private:
      const std::string error_code;
    };
  }
}

#endif // __OPERATOR_ERROR_HH_