couchbase 3.1.1-universal-darwin-20 → 3.2.0-universal-darwin-20

data/ext/couchbase/operations/search_index_drop.hxx

@@ -42,7 +42,7 @@ struct search_index_drop_request {
 
     std::string index_name;
 
-    [[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("/api/index/{}", index_name);
@@ -51,16 +51,18 @@ struct search_index_drop_request {
 };
 
 search_index_drop_response
-make_response(error_context::http&& ctx, search_index_drop_request&, search_index_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const search_index_drop_request& /* request */,
+              search_index_drop_request::encoded_response_type&& encoded)
 {
-    search_index_drop_response response{ ctx };
+    search_index_drop_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();
@@ -71,18 +73,18 @@ make_response(error_context::http&& ctx, search_index_drop_request&, search_inde
             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_get.hxx

@@ -44,7 +44,7 @@ struct search_index_get_request {
 
     std::string index_name;
 
-    [[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("/api/index/{}", index_name);
@@ -53,16 +53,18 @@ struct search_index_get_request {
 };
 
 search_index_get_response
-make_response(error_context::http&& ctx, search_index_get_request&, search_index_get_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const search_index_get_request& /* request */,
+              search_index_get_request::encoded_response_type&& encoded)
 {
-    search_index_get_response response{ ctx };
+    search_index_get_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 +76,18 @@ make_response(error_context::http&& ctx, search_index_get_request&, search_index
             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_get_all.hxx

@@ -44,7 +44,7 @@ struct search_index_get_all_request {
 
     std::string index_name;
 
-    [[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("/api/index");
@@ -53,29 +53,29 @@ struct search_index_get_all_request {
 };
 
 search_index_get_all_response
-make_response(error_context::http&& ctx, search_index_get_all_request&, search_index_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const search_index_get_all_request& /* request */,
+              search_index_get_all_request::encoded_response_type&& encoded)
 {
-    search_index_get_all_response response{ ctx };
+    search_index_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;
             }
             response.status = payload.at("status").get_string();
             if (response.status == "ok") {
-                const auto* indexDefs = payload.find("indexDefs");
-                if (indexDefs != nullptr && indexDefs->is_object()) {
-                    const auto* impl_ver = indexDefs->find("implVersion");
-                    if (impl_ver != nullptr && impl_ver->is_string()) {
+                if (const auto* indexDefs = payload.find("indexDefs"); indexDefs != nullptr && indexDefs->is_object()) {
+                    if (const auto* impl_ver = indexDefs->find("implVersion"); impl_ver != nullptr && impl_ver->is_string()) {
                         response.impl_version = impl_ver->get_string();
                     }
                     const auto* indexes = indexDefs->find("indexDefs");
-                    for (const auto& entry : indexes->get_object()) {
-                        response.indexes.emplace_back(entry.second.as<search_index>());
+                    for (const auto& [name, index] : indexes->get_object()) {
+                        response.indexes.emplace_back(index.as<search_index>());
                     }
                 }
                 return response;

data/ext/couchbase/operations/search_index_get_documents_count.hxx

@@ -43,7 +43,7 @@ struct search_index_get_documents_count_request {
 
     std::string index_name;
 
-    [[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("/api/index/{}/count", index_name);
@@ -53,18 +53,18 @@ struct search_index_get_documents_count_request {
 
 search_index_get_documents_count_response
 make_response(error_context::http&& ctx,
-              search_index_get_documents_count_request&,
+              const search_index_get_documents_count_request& /* request */,
               search_index_get_documents_count_request::encoded_response_type&& encoded)
 {
-    search_index_get_documents_count_response response{ ctx };
+    search_index_get_documents_count_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             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.status = payload.at("status").get_string();
@@ -78,22 +78,22 @@ 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;
                 } else if (response.error.find("no planPIndexes for indexName") != std::string::npos) {
-                    response.ctx.ec = std::make_error_code(error::search_errc::index_not_ready);
+                    response.ctx.ec = error::search_errc::index_not_ready;
                     return response;
                 }
             } break;
         }
-        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_get_stats.hxx

@@ -43,7 +43,7 @@ struct search_index_get_stats_request {
 
     std::string index_name;
 
-    [[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("/api/stats/index/{}", index_name);
@@ -52,9 +52,11 @@ struct search_index_get_stats_request {
 };
 
 search_index_get_stats_response
-make_response(error_context::http&& ctx, search_index_get_stats_request&, search_index_get_stats_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const search_index_get_stats_request& /* request */,
+              search_index_get_stats_request::encoded_response_type&& encoded)
 {
-    search_index_get_stats_response response{ ctx };
+    search_index_get_stats_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200:
@@ -65,22 +67,22 @@ make_response(error_context::http&& ctx, search_index_get_stats_request&, search
                 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("no planPIndexes for indexName") != std::string::npos) {
-                    response.ctx.ec = std::make_error_code(error::search_errc::index_not_ready);
+                    response.ctx.ec = error::search_errc::index_not_ready;
                     return response;
                 }
             } break;
         }
-        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_upsert.hxx

@@ -42,7 +42,7 @@ struct search_index_upsert_request {
 
     search_index index;
 
-    [[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 = "PUT";
         encoded.headers["cache-control"] = "no-cache";
@@ -77,16 +77,18 @@ struct search_index_upsert_request {
 };
 
 search_index_upsert_response
-make_response(error_context::http&& ctx, search_index_upsert_request&, search_index_upsert_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const search_index_upsert_request& /* request */,
+              search_index_upsert_request::encoded_response_type&& encoded)
 {
-    search_index_upsert_response response{ ctx };
+    search_index_upsert_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();
@@ -97,21 +99,21 @@ make_response(error_context::http&& ctx, search_index_upsert_request&, search_in
             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/user_drop.hxx

@@ -43,7 +43,7 @@ struct user_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("/settings/rbac/users/{}/{}", domain, username);
@@ -52,18 +52,18 @@ struct user_drop_request {
 };
 
 user_drop_response
-make_response(error_context::http&& ctx, user_drop_request&, user_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const user_drop_request& /* request */, user_drop_request::encoded_response_type&& encoded)
 {
-    user_drop_response response{ ctx };
+    user_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200:
                 break;
             case 404:
-                response.ctx.ec = std::make_error_code(error::management_errc::user_not_found);
+                response.ctx.ec = error::management_errc::user_not_found;
                 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/user_get.hxx

@@ -44,7 +44,7 @@ struct user_get_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("/settings/rbac/users/{}/{}", domain, username);
@@ -54,24 +54,24 @@ struct user_get_request {
 };
 
 user_get_response
-make_response(error_context::http&& ctx, user_get_request&, user_get_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const user_get_request& /* request */, user_get_request::encoded_response_type&& encoded)
 {
-    user_get_response response{ ctx };
+    user_get_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200: {
                 try {
                     response.user = tao::json::from_string(encoded.body).as<rbac::user_and_metadata>();
-                } 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;
             case 404:
-                response.ctx.ec = std::make_error_code(error::management_errc::user_not_found);
+                response.ctx.ec = error::management_errc::user_not_found;
                 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/user_get_all.hxx

@@ -43,7 +43,7 @@ struct user_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("/settings/rbac/users/{}", domain);
@@ -53,23 +53,23 @@ struct user_get_all_request {
 };
 
 user_get_all_response
-make_response(error_context::http&& ctx, user_get_all_request&, user_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const user_get_all_request& /* request */, user_get_all_request::encoded_response_type&& encoded)
 {
-    user_get_all_response response{ ctx };
+    user_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.users.emplace_back(entry.as<rbac::user_and_metadata>());
             }
         } 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/user_upsert.hxx

@@ -48,7 +48,7 @@ struct user_upsert_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 = "PUT";
         encoded.path = fmt::format("/settings/rbac/users/{}/{}", domain, user.username);
@@ -98,9 +98,9 @@ struct user_upsert_request {
 };
 
 user_upsert_response
-make_response(error_context::http&& ctx, user_upsert_request&, user_upsert_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const user_upsert_request& /* request */, user_upsert_request::encoded_response_type&& encoded)
 {
-    user_upsert_response response{ ctx };
+    user_upsert_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200:
@@ -109,20 +109,20 @@ make_response(error_context::http&& ctx, user_upsert_request&, user_upsert_reque
                 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&) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
-                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+                response.ctx.ec = error::common_errc::invalid_argument;
                 const auto* errors = payload.find("errors");
                 if (errors != nullptr && errors->is_object()) {
-                    for (const auto& entry : errors->get_object()) {
-                        response.errors.emplace_back(fmt::format("{}: {}", entry.first, entry.second.get_string()));
+                    for (const auto& [code, message] : errors->get_object()) {
+                        response.errors.emplace_back(fmt::format("{}: {}", code, message.get_string()));
                     }
                 }
             } 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;
         }
     }