couchbase 3.1.1 → 3.2.0

data/ext/couchbase/operations/role_get_all.hxx

@@ -42,7 +42,7 @@ struct role_get_all_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "GET";
         encoded.path = "/settings/rbac/roles";
@@ -52,23 +52,23 @@ struct role_get_all_request {
 };
 
 role_get_all_response
-make_response(error_context::http&& ctx, role_get_all_request&, role_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const role_get_all_request& /* request */, role_get_all_request::encoded_response_type&& encoded)
 {
-    role_get_all_response response{ ctx };
+    role_get_all_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             for (const auto& entry : payload.get_array()) {
                 response.roles.emplace_back(entry.as<rbac::role_and_description>());
             }
         } else {
-            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            response.ctx.ec = error::common_errc::internal_server_failure;
         }
     }
     return response;

data/ext/couchbase/operations/scope_create.hxx

@@ -46,7 +46,7 @@ struct scope_create_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}/scopes", bucket_name);
@@ -57,36 +57,36 @@ struct scope_create_request {
 };
 
 scope_create_response
-make_response(error_context::http&& ctx, scope_create_request& /* request */, scope_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const scope_create_request& /* request */, scope_create_request::encoded_response_type&& encoded)
 {
-    scope_create_response response{ ctx };
+    scope_create_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400: {
                 std::regex scope_exists("Scope with name .+ already exists");
                 if (std::regex_search(encoded.body, scope_exists)) {
-                    response.ctx.ec = std::make_error_code(error::management_errc::scope_exists);
+                    response.ctx.ec = error::management_errc::scope_exists;
                 } else if (encoded.body.find("Not allowed on this version of cluster") != std::string::npos) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::feature_not_available);
+                    response.ctx.ec = error::common_errc::feature_not_available;
                 } else {
-                    response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+                    response.ctx.ec = error::common_errc::invalid_argument;
                 }
             } break;
             case 404:
-                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = error::common_errc::bucket_not_found;
                 break;
             case 200: {
                 tao::json::value payload{};
                 try {
                     payload = tao::json::from_string(encoded.body);
-                } catch (tao::json::pegtl::parse_error& e) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                } catch (const tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
                 response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
             } break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/scope_drop.hxx

@@ -46,7 +46,7 @@ struct scope_drop_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "DELETE";
         encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}", bucket_name, scope_name);
@@ -55,34 +55,34 @@ struct scope_drop_request {
 };
 
 scope_drop_response
-make_response(error_context::http&& ctx, scope_drop_request& /* request */, scope_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const scope_drop_request& /* request */, scope_drop_request::encoded_response_type&& encoded)
 {
-    scope_drop_response response{ ctx };
+    scope_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
-                response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                response.ctx.ec = error::common_errc::unsupported_operation;
                 break;
             case 404: {
                 std::regex scope_not_found("Scope with name .+ is not found");
                 if (std::regex_search(encoded.body, scope_not_found)) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
+                    response.ctx.ec = error::common_errc::scope_not_found;
                 } else {
-                    response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                    response.ctx.ec = error::common_errc::bucket_not_found;
                 }
             } break;
             case 200: {
                 tao::json::value payload{};
                 try {
                     payload = tao::json::from_string(encoded.body);
-                } catch (tao::json::pegtl::parse_error& e) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                } catch (const tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
                 response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
             } break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/scope_get_all.hxx

@@ -43,7 +43,7 @@ struct scope_get_all_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "GET";
         encoded.path = fmt::format("/pools/default/buckets/{}/scopes", bucket_name);
@@ -52,27 +52,27 @@ struct scope_get_all_request {
 };
 
 scope_get_all_response
-make_response(error_context::http&& ctx, scope_get_all_request&, scope_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const scope_get_all_request& /* request */, scope_get_all_request::encoded_response_type&& encoded)
 {
-    scope_get_all_response response{ ctx };
+    scope_get_all_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
-                response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                response.ctx.ec = error::common_errc::unsupported_operation;
                 break;
             case 404:
-                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = error::common_errc::bucket_not_found;
                 break;
             case 200:
                 try {
                     response.manifest = tao::json::from_string(encoded.body).as<collections_manifest>();
-                } catch (tao::json::pegtl::parse_error& e) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                } catch (const tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
                 break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/search_get_stats.hxx

@@ -39,7 +39,7 @@ struct search_index_stats_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "GET";
         encoded.path = "/api/nsstats";
@@ -48,9 +48,11 @@ struct search_index_stats_request {
 };
 
 search_index_stats_response
-make_response(error_context::http&& ctx, search_index_stats_request&, search_index_stats_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const search_index_stats_request& /* request */,
+              search_index_stats_request::encoded_response_type&& encoded)
 {
-    search_index_stats_response response{ ctx };
+    search_index_stats_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.stats = encoded.body;
     }

data/ext/couchbase/operations/search_index.hxx

@@ -46,11 +46,8 @@ struct traits<couchbase::operations::search_index> {
         result.uuid = v.at("uuid").get_string();
         result.name = v.at("name").get_string();
         result.type = v.at("type").get_string();
-        {
-            const auto* params = v.find("params");
-            if (params != nullptr && params->is_object()) {
-                result.params_json = tao::json::to_string(*params);
-            }
+        if (const auto* params = v.find("params"); params != nullptr && params->is_object()) {
+            result.params_json = tao::json::to_string(*params);
         }
         if (v.find("sourceUUID") != nullptr) {
             result.source_uuid = v.at("sourceUUID").get_string();
@@ -61,17 +58,11 @@ struct traits<couchbase::operations::search_index> {
         if (v.find("sourceType") != nullptr) {
             result.source_type = v.at("sourceType").get_string();
         }
-        {
-            const auto* params = v.find("sourceParams");
-            if (params != nullptr && params->is_object()) {
-                result.source_params_json = tao::json::to_string(*params);
-            }
+        if (const auto* params = v.find("sourceParams"); params != nullptr && params->is_object()) {
+            result.source_params_json = tao::json::to_string(*params);
         }
-        {
-            const auto* params = v.find("planParams");
-            if (params != nullptr && params->is_object()) {
-                result.plan_params_json = tao::json::to_string(*params);
-            }
+        if (const auto* params = v.find("planParams"); params != nullptr && params->is_object()) {
+            result.plan_params_json = tao::json::to_string(*params);
         }
         return result;
     }

data/ext/couchbase/operations/search_index_analyze_document.hxx

@@ -44,7 +44,7 @@ struct search_index_analyze_document_request {
     std::string index_name;
     std::string encoded_document;
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.headers["cache-control"] = "no-cache";
@@ -57,17 +57,17 @@ struct search_index_analyze_document_request {
 
 search_index_analyze_document_response
 make_response(error_context::http&& ctx,
-              search_index_analyze_document_request&,
+              const search_index_analyze_document_request& /* request */,
               search_index_analyze_document_request::encoded_response_type&& encoded)
 {
-    search_index_analyze_document_response response{ ctx };
+    search_index_analyze_document_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             response.status = payload.at("status").get_string();
@@ -77,27 +77,27 @@ make_response(error_context::http&& ctx,
             }
         } else if (encoded.status_code == 400) {
             if (encoded.body.find("no indexName:") != std::string::npos) {
-                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = error::common_errc::index_not_found;
                 return response;
             }
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             response.status = payload.at("status").get_string();
             response.error = payload.at("error").get_string();
             if (response.error.find("index not found") != std::string::npos) {
-                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = error::common_errc::index_not_found;
                 return response;
             } else if (response.error.find("index with the same name already exists") != std::string::npos) {
-                response.ctx.ec = std::make_error_code(error::common_errc::index_exists);
+                response.ctx.ec = error::common_errc::index_exists;
                 return response;
             }
         }
-        response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        response.ctx.ec = error::common_errc::internal_server_failure;
     }
     return response;
 }

data/ext/couchbase/operations/search_index_control_ingest.hxx

@@ -43,7 +43,7 @@ struct search_index_control_ingest_request {
     std::string index_name;
     bool pause;
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/api/index/{}/ingestControl/{}", index_name, pause ? "pause" : "resume");
@@ -53,17 +53,17 @@ struct search_index_control_ingest_request {
 
 search_index_control_ingest_response
 make_response(error_context::http&& ctx,
-              search_index_control_ingest_request&,
+              const search_index_control_ingest_request& /* request */,
               search_index_control_ingest_request::encoded_response_type&& encoded)
 {
-    search_index_control_ingest_response response{ ctx };
+    search_index_control_ingest_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             response.status = payload.at("status").get_string();
@@ -74,18 +74,18 @@ make_response(error_context::http&& ctx,
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             response.status = payload.at("status").get_string();
             response.error = payload.at("error").get_string();
             if (response.error.find("index not found") != std::string::npos) {
-                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = error::common_errc::index_not_found;
                 return response;
             }
         }
-        response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        response.ctx.ec = error::common_errc::internal_server_failure;
     }
     return response;
 }

data/ext/couchbase/operations/search_index_control_plan_freeze.hxx

@@ -43,7 +43,7 @@ struct search_index_control_plan_freeze_request {
     std::string index_name;
     bool freeze;
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/api/index/{}/planFreezeControl/{}", index_name, freeze ? "freeze" : "unfreeze");
@@ -53,17 +53,17 @@ struct search_index_control_plan_freeze_request {
 
 search_index_control_plan_freeze_response
 make_response(error_context::http&& ctx,
-              search_index_control_plan_freeze_request&,
+              const search_index_control_plan_freeze_request& /* request */,
               search_index_control_plan_freeze_request::encoded_response_type&& encoded)
 {
-    search_index_control_plan_freeze_response response{ ctx };
+    search_index_control_plan_freeze_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             response.status = payload.at("status").get_string();
@@ -74,18 +74,18 @@ make_response(error_context::http&& ctx,
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             response.status = payload.at("status").get_string();
             response.error = payload.at("error").get_string();
             if (response.error.find("index not found") != std::string::npos) {
-                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = error::common_errc::index_not_found;
                 return response;
             }
         }
-        response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        response.ctx.ec = error::common_errc::internal_server_failure;
     }
     return response;
 }

data/ext/couchbase/operations/search_index_control_query.hxx

@@ -43,7 +43,7 @@ struct search_index_control_query_request {
     std::string index_name;
     bool allow;
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/api/index/{}/queryControl/{}", index_name, allow ? "allow" : "disallow");
@@ -53,17 +53,17 @@ struct search_index_control_query_request {
 
 search_index_control_query_response
 make_response(error_context::http&& ctx,
-              search_index_control_query_request&,
+              const search_index_control_query_request& /* request */,
               search_index_control_query_request::encoded_response_type&& encoded)
 {
-    search_index_control_query_response response{ ctx };
+    search_index_control_query_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             response.status = payload.at("status").get_string();
@@ -74,18 +74,18 @@ make_response(error_context::http&& ctx,
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             response.status = payload.at("status").get_string();
             response.error = payload.at("error").get_string();
             if (response.error.find("index not found") != std::string::npos) {
-                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = error::common_errc::index_not_found;
                 return response;
             }
         }
-        response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        response.ctx.ec = error::common_errc::internal_server_failure;
     }
     return response;
 }