Add enum for specified error types (Closes #17)

cinemast · cinemast · commit 4099778b97b5 · 2021-03-13T10:25:41.000+01:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -30,7 +30,7 @@ if (COMPILE_TESTS)
         target_compile_options(coverage_config INTERFACE -O0 -g --coverage)
         target_link_libraries(coverage_config INTERFACE --coverage)
     endif ()
-    add_executable(jsonrpccpp-test test/main.cpp test/client.cpp test/typemapper.cpp test/dispatcher.cpp test/server.cpp test/batchclient.cpp test/testclientconnector.hpp examples/warehouse/warehouseapp.cpp test/warehouseapp.cpp)
+    add_executable(jsonrpccpp-test test/main.cpp test/client.cpp test/typemapper.cpp test/dispatcher.cpp test/server.cpp test/batchclient.cpp test/testclientconnector.hpp examples/warehouse/warehouseapp.cpp test/warehouseapp.cpp test/common.cpp)
     target_compile_options(jsonrpccpp-test PUBLIC "${_warning_opts}")
     target_include_directories(jsonrpccpp-test PRIVATE vendor examples)
     target_link_libraries(jsonrpccpp-test coverage_config json-rpc-cxx)
diff --git a/include/jsonrpccxx/batchclient.hpp b/include/jsonrpccxx/batchclient.hpp
@@ -64,12 +64,12 @@ namespace jsonrpccxx {
         try {
           return response[results[id]]["result"].get<T>();
         } catch (json::type_error &e) {
-          throw JsonRpcException(-32700, "invalid return type: " + std::string(e.what()));
+          throw JsonRpcException(parse_error, "invalid return type: " + std::string(e.what()));
         }
       } else if (errors.find(id) != errors.end()) {
         throw JsonRpcException::fromJson(response[errors[id]]["error"]);
       }
-      throw JsonRpcException(-32700, std::string("no result found for id ") + id.dump());
+      throw JsonRpcException(parse_error, std::string("no result found for id ") + id.dump());
     }
 
     bool HasErrors() { return !errors.empty() || !nullIds.empty(); }
@@ -90,11 +90,11 @@ namespace jsonrpccxx {
       try {
         json response = json::parse(connector.Send(request.Build().dump()));
         if (!response.is_array()) {
-          throw JsonRpcException(-32700, std::string("invalid JSON response from server: expected array"));
+          throw JsonRpcException(parse_error, std::string("invalid JSON response from server: expected array"));
         }
         return BatchResponse(std::move(response));
       } catch (json::parse_error &e) {
-        throw JsonRpcException(-32700, std::string("invalid JSON response from server: ") + e.what());
+        throw JsonRpcException(parse_error, std::string("invalid JSON response from server: ") + e.what());
       }
     }
   };
diff --git a/include/jsonrpccxx/client.hpp b/include/jsonrpccxx/client.hpp
@@ -60,17 +60,17 @@ namespace jsonrpccxx {
         if (has_key_type(response, "error", json::value_t::object)) {
           throw JsonRpcException::fromJson(response["error"]);
         } else if (has_key_type(response, "error", json::value_t::string)) {
-          throw JsonRpcException(-32603, response["error"]);
+          throw JsonRpcException(internal_error, response["error"]);
         }
         if (has_key(response, "result") && has_key(response, "id")) {
           if (response["id"].type() == json::value_t::string)
             return JsonRpcResponse{response["id"].get<std::string>(), response["result"].get<json>()};
           else
             return JsonRpcResponse{response["id"].get<int>(), response["result"].get<json>()};
         }
-        throw JsonRpcException(-32603, R"(invalid server response: neither "result" nor "error" fields found)");
+        throw JsonRpcException(internal_error, R"(invalid server response: neither "result" nor "error" fields found)");
       } catch (json::parse_error &e) {
-        throw JsonRpcException(-32700, std::string("invalid JSON response from server: ") + e.what());
+        throw JsonRpcException(parse_error, std::string("invalid JSON response from server: ") + e.what());
       }
     }
 
diff --git a/include/jsonrpccxx/common.hpp b/include/jsonrpccxx/common.hpp
@@ -13,12 +13,32 @@ namespace jsonrpccxx {
   }
   static inline bool valid_id_not_null(const json &request) { return has_key(request, "id") && (request["id"].is_number() || request["id"].is_string()); }
 
+  enum error_type {
+    parse_error = -32700,
+    invalid_request = -32600,
+    method_not_found = -32601,
+    invalid_params = -32602,
+    internal_error = -32603,
+    server_error,
+    invalid
+  };
+
   class JsonRpcException : public std::exception {
   public:
     JsonRpcException(int code, const std::string &message) noexcept : code(code), message(message), data(nullptr), err(std::to_string(code) + ": " + message) {}
     JsonRpcException(int code, const std::string &message, const json &data) noexcept
         : code(code), message(message), data(data), err(std::to_string(code) + ": " + message + ", data: " + data.dump()) {}
 
+    error_type Type() const {
+      if (code >= -32603 && code <= -32600)
+        return static_cast<error_type>(code);
+      if (code >= -32099 && code <= -32000)
+        return server_error;
+      if (code == -32700)
+        return parse_error;
+      return invalid;
+    }
+
     int Code() const { return code; }
     const std::string &Message() const { return message; }
     const json &Data() const { return data; }
@@ -36,7 +56,7 @@ namespace jsonrpccxx {
           return JsonRpcException(value["code"], value["message"]);
         }
       }
-      return JsonRpcException(-32603, R"(invalid error response: "code" (negative number) and "message" (string) are required)");
+      return JsonRpcException(internal_error, R"(invalid error response: "code" (negative number) and "message" (string) are required)");
     }
 
   private:
diff --git a/include/jsonrpccxx/dispatcher.hpp b/include/jsonrpccxx/dispatcher.hpp
@@ -53,12 +53,12 @@ namespace jsonrpccxx {
     json InvokeMethod(const std::string &name, const json &params) {
       auto method = methods.find(name);
       if (method == methods.end()) {
-        throw JsonRpcException(-32601, "method not found: " + name);
+        throw JsonRpcException(method_not_found, "method not found: " + name);
       }
       try {
         return method->second(normalize_parameter(name, params));
       } catch (json::type_error &e) {
-        throw JsonRpcException(-32602, "invalid parameter: " + std::string(e.what()));
+        throw JsonRpcException(invalid_params, "invalid parameter: " + std::string(e.what()));
       } catch (JsonRpcException &e) {
         throw process_type_error(name, e);
       }
@@ -67,12 +67,12 @@ namespace jsonrpccxx {
     void InvokeNotification(const std::string &name, const json &params) {
       auto notification = notifications.find(name);
       if (notification == notifications.end()) {
-        throw JsonRpcException(-32601, "notification not found: " + name);
+        throw JsonRpcException(method_not_found, "notification not found: " + name);
       }
       try {
         notification->second(normalize_parameter(name, params));
       } catch (json::type_error &e) {
-        throw JsonRpcException(-32602, "invalid parameter: " + std::string(e.what()));
+        throw JsonRpcException(invalid_params, "invalid parameter: " + std::string(e.what()));
       } catch (JsonRpcException &e) {
         throw process_type_error(name, e);
       }
@@ -89,18 +89,18 @@ namespace jsonrpccxx {
         return params;
       } else if (params.type() == json::value_t::object) {
         if (mapping.find(name) == mapping.end()) {
-          throw JsonRpcException(-32602, "invalid parameter: procedure doesn't support named parameter");
+          throw JsonRpcException(invalid_params, "invalid parameter: procedure doesn't support named parameter");
         }
         json result;
         for (auto const &p : mapping[name]) {
           if (params.find(p) == params.end()) {
-            throw JsonRpcException(-32602, "invalid parameter: missing named parameter \"" + p + "\"");
+            throw JsonRpcException(invalid_params, "invalid parameter: missing named parameter \"" + p + "\"");
           }
           result.push_back(params[p]);
         }
         return result;
       }
-      throw JsonRpcException(-32600, "invalid request: params field must be an array, object");
+      throw JsonRpcException(invalid_request, "invalid request: params field must be an array, object");
     }
   };
 } // namespace jsonrpccxx
diff --git a/include/jsonrpccxx/server.hpp b/include/jsonrpccxx/server.hpp
@@ -51,10 +51,10 @@ namespace jsonrpccxx {
             return "";
           }
         } else {
-          return json{{"id", nullptr}, {"error", {{"code", -32600}, {"message", "invalid request: expected array or object"}}}, {"jsonrpc", "2.0"}}.dump();
+          return json{{"id", nullptr}, {"error", {{"code", invalid_request}, {"message", "invalid request: expected array or object"}}}, {"jsonrpc", "2.0"}}.dump();
         }
       } catch (json::parse_error &e) {
-        return json{{"id", nullptr}, {"error", {{"code", -32700}, {"message", std::string("parse error: ") + e.what()}}}, {"jsonrpc", "2.0"}}.dump();
+        return json{{"id", nullptr}, {"error", {{"code", parse_error}, {"message", std::string("parse error: ") + e.what()}}}, {"jsonrpc", "2.0"}}.dump();
       }
     }
 
@@ -73,24 +73,24 @@ namespace jsonrpccxx {
         }
         return json{{"id", id}, {"error", error}, {"jsonrpc", "2.0"}};
       } catch (std::exception &e) {
-        return json{{"id", id}, {"error", {{"code", -32603}, {"message", std::string("internal server error: ") + e.what()}}}, {"jsonrpc", "2.0"}};
+        return json{{"id", id}, {"error", {{"code", internal_error}, {"message", std::string("internal server error: ") + e.what()}}}, {"jsonrpc", "2.0"}};
       } catch (...) {
-        return json{{"id", id}, {"error", {{"code", -32603}, {"message", std::string("internal server error")}}}, {"jsonrpc", "2.0"}};
+        return json{{"id", id}, {"error", {{"code", internal_error}, {"message", std::string("internal server error")}}}, {"jsonrpc", "2.0"}};
       }
     }
 
     json ProcessSingleRequest(json &request) {
       if (!has_key_type(request, "jsonrpc", json::value_t::string) || request["jsonrpc"] != "2.0") {
-        throw JsonRpcException(-32600, R"(invalid request: missing jsonrpc field set to "2.0")");
+        throw JsonRpcException(invalid_request, R"(invalid request: missing jsonrpc field set to "2.0")");
       }
       if (!has_key_type(request, "method", json::value_t::string)) {
-        throw JsonRpcException(-32600, "invalid request: method field must be a string");
+        throw JsonRpcException(invalid_request, "invalid request: method field must be a string");
       }
       if (has_key(request, "id") && !valid_id(request)) {
-        throw JsonRpcException(-32600, "invalid request: id field must be a number, string or null");
+        throw JsonRpcException(invalid_request, "invalid request: id field must be a number, string or null");
       }
       if (has_key(request, "params") && !(request["params"].is_array() || request["params"].is_object() || request["params"].is_null())) {
-        throw JsonRpcException(-32600, "invalid request: params field must be an array, object or null");
+        throw JsonRpcException(invalid_request, "invalid request: params field must be an array, object or null");
       }
       if (!has_key(request, "params") || has_key_type(request, "params", json::value_t::null)) {
         request["params"] = json::array();
@@ -99,7 +99,7 @@ namespace jsonrpccxx {
         try {
           dispatcher.InvokeNotification(request["method"], request["params"]);
           return json();
-        } catch (std::exception &e) {
+        } catch (std::exception &) {
           return json();
         }
       } else {
diff --git a/include/jsonrpccxx/typemapper.hpp b/include/jsonrpccxx/typemapper.hpp
@@ -67,25 +67,25 @@ namespace jsonrpccxx {
   inline void check_param_type(size_t index, const json &x, json::value_t expectedType, typename std::enable_if<std::is_arithmetic<T>::value>::type * = 0) {
     if (expectedType == json::value_t::number_unsigned && x.type() == json::value_t::number_integer) {
       if (x.get<long long int>() < 0)
-        throw JsonRpcException(-32602, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);
+        throw JsonRpcException(invalid_params, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);
     } else if (x.type() == json::value_t::number_unsigned && expectedType == json::value_t::number_integer) {
       if (x.get<long long unsigned>() > std::numeric_limits<T>::max()) {
-        throw JsonRpcException(-32602, "invalid parameter: exceeds value range of " + type_name(expectedType), index);
+        throw JsonRpcException(invalid_params, "invalid parameter: exceeds value range of " + type_name(expectedType), index);
       }
     }
     else if ((x.type() == json::value_t::number_unsigned || x.type() == json::value_t::number_integer) && expectedType == json::value_t::number_float) {
       if (static_cast<long long int>(x.get<double>()) != x.get<long long int>()) {
-        throw JsonRpcException(-32602, "invalid parameter: exceeds value range of " + type_name(expectedType), index);
+        throw JsonRpcException(invalid_params, "invalid parameter: exceeds value range of " + type_name(expectedType), index);
       }
     } else if (x.type() != expectedType) {
-      throw JsonRpcException(-32602, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);
+      throw JsonRpcException(invalid_params, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);
     }
   }
 
   template <typename T>
   inline void check_param_type(size_t index, const json &x, json::value_t expectedType, typename std::enable_if<!std::is_arithmetic<T>::value>::type * = 0) {
     if (x.type() != expectedType) {
-      throw JsonRpcException(-32602, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);
+      throw JsonRpcException(invalid_params, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);
     }
   }
 
@@ -99,7 +99,7 @@ namespace jsonrpccxx {
       size_t formalSize = sizeof...(ParamTypes);
       // TODO: add lenient mode for backwards compatible additional params
       if (actualSize != formalSize) {
-        throw JsonRpcException(-32602, "invalid parameter: expected " + std::to_string(formalSize) + " argument(s), but found " + std::to_string(actualSize));
+        throw JsonRpcException(invalid_params, "invalid parameter: expected " + std::to_string(formalSize) + " argument(s), but found " + std::to_string(actualSize));
       }
       (check_param_type<typename std::decay<ParamTypes>::type>(index, params[index], GetType(type<typename std::decay<ParamTypes>::type>())), ...);
       return method(params[index].get<typename std::decay<ParamTypes>::type>()...);
@@ -133,7 +133,7 @@ namespace jsonrpccxx {
       // TODO: add lenient mode for backwards compatible additional params
       // if ((!allow_unkown_params && actualSize != formalSize) || (allow_unkown_params && actualSize < formalSize)) {
       if (actualSize != formalSize) {
-        throw JsonRpcException(-32602, "invalid parameter: expected " + std::to_string(formalSize) + " argument(s), but found " + std::to_string(actualSize));
+        throw JsonRpcException(invalid_params, "invalid parameter: expected " + std::to_string(formalSize) + " argument(s), but found " + std::to_string(actualSize));
       }
       (check_param_type<typename std::decay<ParamTypes>::type>(index, params[index], GetType(type<typename std::decay<ParamTypes>::type>())), ...);
       method(params[index].get<typename std::decay<ParamTypes>::type>()...);
diff --git a/test/common.cpp b/test/common.cpp
@@ -0,0 +1,24 @@
+#include "catch/catch.hpp"
+#include <iostream>
+#include <jsonrpccxx/common.hpp>
+
+#define TEST_MODULE "[common]"
+
+using namespace std;
+using namespace jsonrpccxx;
+using namespace Catch::Matchers;
+
+TEST_CASE("exception error type", TEST_MODULE) {
+  CHECK(JsonRpcException(-32700, "").Type() == parse_error);
+  CHECK(JsonRpcException(-32600, "").Type() == invalid_request);
+  CHECK(JsonRpcException(-32601, "").Type() == method_not_found);
+  CHECK(JsonRpcException(-32602, "").Type() == invalid_params);
+  CHECK(JsonRpcException(-32603, "").Type() == internal_error);
+
+  for(int c = -32000; c >= -32099; c--)
+    CHECK(JsonRpcException(c, "").Type() == server_error);
+
+  CHECK(JsonRpcException(0, "").Type() == invalid);
+  CHECK(JsonRpcException(32700, "").Type() == invalid);
+  CHECK(JsonRpcException(33000, "").Type() == invalid);
+}

Original file line number	Diff line number	Diff line change
`@@ -64,12 +64,12 @@ namespace jsonrpccxx {`
`64`	`64`	`try {`
`65`	`65`	`return response[results[id]]["result"].get<T>();`
`66`	`66`	`} catch (json::type_error &e) {`
`67`		`- throw JsonRpcException(-32700, "invalid return type: " + std::string(e.what()));`
	`67`	`+ throw JsonRpcException(parse_error, "invalid return type: " + std::string(e.what()));`
`68`	`68`	`}`
`69`	`69`	`} else if (errors.find(id) != errors.end()) {`
`70`	`70`	`throw JsonRpcException::fromJson(response[errors[id]]["error"]);`
`71`	`71`	`}`
`72`		`- throw JsonRpcException(-32700, std::string("no result found for id ") + id.dump());`
	`72`	`+ throw JsonRpcException(parse_error, std::string("no result found for id ") + id.dump());`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`bool HasErrors() { return !errors.empty() \|\| !nullIds.empty(); }`
`@@ -90,11 +90,11 @@ namespace jsonrpccxx {`
`90`	`90`	`try {`
`91`	`91`	`json response = json::parse(connector.Send(request.Build().dump()));`
`92`	`92`	`if (!response.is_array()) {`
`93`		`- throw JsonRpcException(-32700, std::string("invalid JSON response from server: expected array"));`
	`93`	`+ throw JsonRpcException(parse_error, std::string("invalid JSON response from server: expected array"));`
`94`	`94`	`}`
`95`	`95`	`return BatchResponse(std::move(response));`
`96`	`96`	`} catch (json::parse_error &e) {`
`97`		`- throw JsonRpcException(-32700, std::string("invalid JSON response from server: ") + e.what());`
	`97`	`+ throw JsonRpcException(parse_error, std::string("invalid JSON response from server: ") + e.what());`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`	`};`
Original file line number	Diff line number	Diff line change
`@@ -60,17 +60,17 @@ namespace jsonrpccxx {`
`60`	`60`	`if (has_key_type(response, "error", json::value_t::object)) {`
`61`	`61`	`throw JsonRpcException::fromJson(response["error"]);`
`62`	`62`	`} else if (has_key_type(response, "error", json::value_t::string)) {`
`63`		`- throw JsonRpcException(-32603, response["error"]);`
	`63`	`+ throw JsonRpcException(internal_error, response["error"]);`
`64`	`64`	`}`
`65`	`65`	`if (has_key(response, "result") && has_key(response, "id")) {`
`66`	`66`	`if (response["id"].type() == json::value_t::string)`
`67`	`67`	`return JsonRpcResponse{response["id"].get<std::string>(), response["result"].get<json>()};`
`68`	`68`	`else`
`69`	`69`	`return JsonRpcResponse{response["id"].get<int>(), response["result"].get<json>()};`
`70`	`70`	`}`
`71`		`- throw JsonRpcException(-32603, R"(invalid server response: neither "result" nor "error" fields found)");`
	`71`	`+ throw JsonRpcException(internal_error, R"(invalid server response: neither "result" nor "error" fields found)");`
`72`	`72`	`} catch (json::parse_error &e) {`
`73`		`- throw JsonRpcException(-32700, std::string("invalid JSON response from server: ") + e.what());`
	`73`	`+ throw JsonRpcException(parse_error, std::string("invalid JSON response from server: ") + e.what());`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
Original file line number	Diff line number	Diff line change
`@@ -51,10 +51,10 @@ namespace jsonrpccxx {`
`51`	`51`	`return "";`
`52`	`52`	`}`
`53`	`53`	`} else {`
`54`		`- return json{{"id", nullptr}, {"error", {{"code", -32600}, {"message", "invalid request: expected array or object"}}}, {"jsonrpc", "2.0"}}.dump();`
	`54`	`+ return json{{"id", nullptr}, {"error", {{"code", invalid_request}, {"message", "invalid request: expected array or object"}}}, {"jsonrpc", "2.0"}}.dump();`
`55`	`55`	`}`
`56`	`56`	`} catch (json::parse_error &e) {`
`57`		`- return json{{"id", nullptr}, {"error", {{"code", -32700}, {"message", std::string("parse error: ") + e.what()}}}, {"jsonrpc", "2.0"}}.dump();`
	`57`	`+ return json{{"id", nullptr}, {"error", {{"code", parse_error}, {"message", std::string("parse error: ") + e.what()}}}, {"jsonrpc", "2.0"}}.dump();`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`@@ -73,24 +73,24 @@ namespace jsonrpccxx {`
`73`	`73`	`}`
`74`	`74`	`return json{{"id", id}, {"error", error}, {"jsonrpc", "2.0"}};`
`75`	`75`	`} catch (std::exception &e) {`
`76`		`- return json{{"id", id}, {"error", {{"code", -32603}, {"message", std::string("internal server error: ") + e.what()}}}, {"jsonrpc", "2.0"}};`
	`76`	`+ return json{{"id", id}, {"error", {{"code", internal_error}, {"message", std::string("internal server error: ") + e.what()}}}, {"jsonrpc", "2.0"}};`
`77`	`77`	`} catch (...) {`
`78`		`- return json{{"id", id}, {"error", {{"code", -32603}, {"message", std::string("internal server error")}}}, {"jsonrpc", "2.0"}};`
	`78`	`+ return json{{"id", id}, {"error", {{"code", internal_error}, {"message", std::string("internal server error")}}}, {"jsonrpc", "2.0"}};`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`json ProcessSingleRequest(json &request) {`
`83`	`83`	`if (!has_key_type(request, "jsonrpc", json::value_t::string) \|\| request["jsonrpc"] != "2.0") {`
`84`		`- throw JsonRpcException(-32600, R"(invalid request: missing jsonrpc field set to "2.0")");`
	`84`	`+ throw JsonRpcException(invalid_request, R"(invalid request: missing jsonrpc field set to "2.0")");`
`85`	`85`	`}`
`86`	`86`	`if (!has_key_type(request, "method", json::value_t::string)) {`
`87`		`- throw JsonRpcException(-32600, "invalid request: method field must be a string");`
	`87`	`+ throw JsonRpcException(invalid_request, "invalid request: method field must be a string");`
`88`	`88`	`}`
`89`	`89`	`if (has_key(request, "id") && !valid_id(request)) {`
`90`		`- throw JsonRpcException(-32600, "invalid request: id field must be a number, string or null");`
	`90`	`+ throw JsonRpcException(invalid_request, "invalid request: id field must be a number, string or null");`
`91`	`91`	`}`
`92`	`92`	`if (has_key(request, "params") && !(request["params"].is_array() \|\| request["params"].is_object() \|\| request["params"].is_null())) {`
`93`		`- throw JsonRpcException(-32600, "invalid request: params field must be an array, object or null");`
	`93`	`+ throw JsonRpcException(invalid_request, "invalid request: params field must be an array, object or null");`
`94`	`94`	`}`
`95`	`95`	`if (!has_key(request, "params") \|\| has_key_type(request, "params", json::value_t::null)) {`
`96`	`96`	`request["params"] = json::array();`
`@@ -99,7 +99,7 @@ namespace jsonrpccxx {`
`99`	`99`	`try {`
`100`	`100`	`dispatcher.InvokeNotification(request["method"], request["params"]);`
`101`	`101`	`return json();`
`102`		`- } catch (std::exception &e) {`
	`102`	`+ } catch (std::exception &) {`
`103`	`103`	`return json();`
`104`	`104`	`}`
`105`	`105`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -67,25 +67,25 @@ namespace jsonrpccxx {`
`67`	`67`	`inline void check_param_type(size_t index, const json &x, json::value_t expectedType, typename std::enable_if<std::is_arithmetic<T>::value>::type * = 0) {`
`68`	`68`	`if (expectedType == json::value_t::number_unsigned && x.type() == json::value_t::number_integer) {`
`69`	`69`	`if (x.get<long long int>() < 0)`
`70`		`- throw JsonRpcException(-32602, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);`
	`70`	`+ throw JsonRpcException(invalid_params, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);`
`71`	`71`	`} else if (x.type() == json::value_t::number_unsigned && expectedType == json::value_t::number_integer) {`
`72`	`72`	`if (x.get<long long unsigned>() > std::numeric_limits<T>::max()) {`
`73`		`- throw JsonRpcException(-32602, "invalid parameter: exceeds value range of " + type_name(expectedType), index);`
	`73`	`+ throw JsonRpcException(invalid_params, "invalid parameter: exceeds value range of " + type_name(expectedType), index);`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`	`else if ((x.type() == json::value_t::number_unsigned \|\| x.type() == json::value_t::number_integer) && expectedType == json::value_t::number_float) {`
`77`	`77`	`if (static_cast<long long int>(x.get<double>()) != x.get<long long int>()) {`
`78`		`- throw JsonRpcException(-32602, "invalid parameter: exceeds value range of " + type_name(expectedType), index);`
	`78`	`+ throw JsonRpcException(invalid_params, "invalid parameter: exceeds value range of " + type_name(expectedType), index);`
`79`	`79`	`}`
`80`	`80`	`} else if (x.type() != expectedType) {`
`81`		`- throw JsonRpcException(-32602, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);`
	`81`	`+ throw JsonRpcException(invalid_params, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`template <typename T>`
`86`	`86`	`inline void check_param_type(size_t index, const json &x, json::value_t expectedType, typename std::enable_if<!std::is_arithmetic<T>::value>::type * = 0) {`
`87`	`87`	`if (x.type() != expectedType) {`
`88`		`- throw JsonRpcException(-32602, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);`
	`88`	`+ throw JsonRpcException(invalid_params, "invalid parameter: must be " + type_name(expectedType) + ", but is " + type_name(x.type()), index);`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`
`@@ -99,7 +99,7 @@ namespace jsonrpccxx {`
`99`	`99`	`size_t formalSize = sizeof...(ParamTypes);`
`100`	`100`	`// TODO: add lenient mode for backwards compatible additional params`
`101`	`101`	`if (actualSize != formalSize) {`
`102`		`- throw JsonRpcException(-32602, "invalid parameter: expected " + std::to_string(formalSize) + " argument(s), but found " + std::to_string(actualSize));`
	`102`	`+ throw JsonRpcException(invalid_params, "invalid parameter: expected " + std::to_string(formalSize) + " argument(s), but found " + std::to_string(actualSize));`
`103`	`103`	`}`
`104`	`104`	`(check_param_type<typename std::decay<ParamTypes>::type>(index, params[index], GetType(type<typename std::decay<ParamTypes>::type>())), ...);`
`105`	`105`	`return method(params[index].get<typename std::decay<ParamTypes>::type>()...);`
`@@ -133,7 +133,7 @@ namespace jsonrpccxx {`
`133`	`133`	`// TODO: add lenient mode for backwards compatible additional params`
`134`	`134`	`// if ((!allow_unkown_params && actualSize != formalSize) \|\| (allow_unkown_params && actualSize < formalSize)) {`
`135`	`135`	`if (actualSize != formalSize) {`
`136`		`- throw JsonRpcException(-32602, "invalid parameter: expected " + std::to_string(formalSize) + " argument(s), but found " + std::to_string(actualSize));`
	`136`	`+ throw JsonRpcException(invalid_params, "invalid parameter: expected " + std::to_string(formalSize) + " argument(s), but found " + std::to_string(actualSize));`
`137`	`137`	`}`
`138`	`138`	`(check_param_type<typename std::decay<ParamTypes>::type>(index, params[index], GetType(type<typename std::decay<ParamTypes>::type>())), ...);`
`139`	`139`	`method(params[index].get<typename std::decay<ParamTypes>::type>()...);`