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

data/ext/couchbase/protocol/cmd_get_cluster_config.hxx

@@ -60,12 +60,12 @@ class get_cluster_config_response_body
     static const inline client_opcode opcode = client_opcode::get_cluster_config;
 
   private:
-    configuration config_;
+    configuration config_{};
 
   public:
-    [[nodiscard]] configuration config()
+    [[nodiscard]] configuration&& config()
     {
-        return config_;
+        return std::move(config_);
     }
 
     bool parse(protocol::status status,
@@ -74,7 +74,7 @@ class get_cluster_config_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
@@ -92,32 +92,27 @@ class get_cluster_config_request_body
     using response_body_type = get_cluster_config_response_body;
     static const inline client_opcode opcode = client_opcode::get_cluster_config;
 
-  public:
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
-        static std::string empty;
-        return empty;
+        return empty_string;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size() const
     {
         return 0;
     }

data/ext/couchbase/protocol/cmd_get_collection_id.hxx

@@ -36,12 +36,12 @@ class get_collection_id_response_body
     std::uint32_t collection_uid_;
 
   public:
-    [[nodiscard]] std::uint64_t manifest_uid()
+    [[nodiscard]] std::uint64_t manifest_uid() const
     {
         return manifest_uid_;
     }
 
-    [[nodiscard]] std::uint32_t collection_uid()
+    [[nodiscard]] std::uint32_t collection_uid() const
     {
         return collection_uid_;
     }
@@ -52,7 +52,7 @@ class get_collection_id_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success && extras_size == 12) {
@@ -80,35 +80,32 @@ class get_collection_id_request_body
     std::vector<std::uint8_t> value_{};
 
   public:
-    void collection_path(const std::string& path)
+    void collection_path(const std::string_view& path)
     {
         value_.assign(path.begin(), path.end());
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
-        static std::string empty;
-        return empty;
+        return empty_string;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value() const
     {
         return value_;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size() const
     {
         return value_.size();
     }

data/ext/couchbase/protocol/cmd_get_collections_manifest.hxx

@@ -20,8 +20,8 @@
 #include <gsl/gsl_assert>
 
 #include <protocol/client_opcode.hxx>
-#include <protocol/status.hxx>
 #include <protocol/cmd_info.hxx>
+#include <protocol/status.hxx>
 
 #include <collections_manifest.hxx>
 
@@ -37,7 +37,7 @@ class get_collections_manifest_response_body
     collections_manifest manifest_;
 
   public:
-    [[nodiscard]] couchbase::collections_manifest manifest()
+    [[nodiscard]] const couchbase::collections_manifest& manifest() const
     {
         return manifest_;
     }
@@ -48,7 +48,7 @@ class get_collections_manifest_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
@@ -66,31 +66,27 @@ class get_collections_manifest_request_body
     using response_body_type = get_collections_manifest_response_body;
     static const inline client_opcode opcode = client_opcode::get_collections_manifest;
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
-        static std::string empty;
-        return empty;
+        return empty_string;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size() const
     {
         return 0;
     }

data/ext/couchbase/protocol/cmd_get_error_map.hxx

@@ -20,8 +20,8 @@
 #include <gsl/gsl_assert>
 
 #include <protocol/client_opcode.hxx>
-#include <protocol/status.hxx>
 #include <protocol/cmd_info.hxx>
+#include <protocol/status.hxx>
 
 #include <error_map.hxx>
 
@@ -34,10 +34,10 @@ class get_error_map_response_body
     static const inline client_opcode opcode = client_opcode::get_error_map;
 
   private:
-    error_map errmap_;
+    error_map errmap_{};
 
   public:
-    [[nodiscard]] couchbase::error_map errmap()
+    [[nodiscard]] const couchbase::error_map& errmap() const
     {
         return errmap_;
     }
@@ -48,15 +48,15 @@ class get_error_map_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
             try {
                 std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
                 errmap_ = tao::json::from_string(std::string(body.begin() + offset, body.end())).as<error_map>();
-            } catch (tao::json::pegtl::parse_error& e) {
-                spdlog::critical("unable to parse JSON: {}", std::string(body.begin(), body.end()));
+            } catch (const tao::json::pegtl::parse_error& e) {
+                spdlog::critical("unable to parse JSON: {}, {}", e.message(), std::string(body.begin(), body.end()));
             }
             return true;
         }
@@ -80,25 +80,22 @@ class get_error_map_request_body
         version_ = version;
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
-        static std::string empty;
-        return empty;
+        return empty_string;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value()
     {
         if (value_.empty()) {
             fill_body();
@@ -106,7 +103,7 @@ class get_error_map_request_body
         return value_;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size()
     {
         if (value_.empty()) {
             fill_body();

data/ext/couchbase/protocol/cmd_hello.hxx

@@ -42,7 +42,7 @@ class hello_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
@@ -123,24 +123,22 @@ class hello_request_body
         return features_;
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
         return key_;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value()
     {
         if (value_.empty()) {
             fill_body();
@@ -148,7 +146,7 @@ class hello_request_body
         return value_;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size()
     {
         if (value_.empty()) {
             fill_body();

data/ext/couchbase/protocol/cmd_increment.hxx

@@ -31,16 +31,16 @@ class increment_response_body
     static const inline client_opcode opcode = client_opcode::increment;
 
   private:
-    mutation_token token_;
+    mutation_token token_{};
     std::uint64_t content_;
 
   public:
-    std::uint64_t content()
+    [[nodiscard]] std::uint64_t content() const
     {
         return content_;
     }
 
-    mutation_token& token()
+    [[nodiscard]] const mutation_token& token() const
     {
         return token_;
     }
@@ -51,7 +51,7 @@ class increment_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
@@ -142,17 +142,17 @@ class increment_request_body
         framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
         return key_;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
         return framing_extras_;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -160,10 +160,9 @@ class increment_request_body
         return extras_;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
     [[nodiscard]] std::size_t size()

data/ext/couchbase/protocol/cmd_insert.hxx

@@ -37,7 +37,7 @@ class insert_response_body
     mutation_token token_;
 
   public:
-    mutation_token& token()
+    [[nodiscard]] const mutation_token& token() const
     {
         return token_;
     }
@@ -45,10 +45,10 @@ class insert_response_body
     bool parse(protocol::status status,
                const header_buffer& header,
                std::uint8_t framing_extras_size,
-               std::uint16_t,
+               std::uint16_t /* key_size */,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
@@ -110,7 +110,7 @@ class insert_request_body
         }
     }
 
-    void content(const std::string& content)
+    void content(const std::string_view& content)
     {
         content_ = { content.begin(), content.end() };
     }
@@ -125,17 +125,17 @@ class insert_request_body
         expiry_ = value;
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
         return key_;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
         return framing_extras_;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras()
     {
         if (extras_.empty()) {
             fill_extention();
@@ -143,12 +143,12 @@ class insert_request_body
         return extras_;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value() const
     {
         return content_;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size()
     {
         if (extras_.empty()) {
             fill_extention();