couchbase 4.1.1 → 4.1.2

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_increment.hxx

@@ -53,7 +53,7 @@ class increment_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& info);
 };
 
@@ -64,12 +64,12 @@ class increment_request_body
     static const inline client_opcode opcode = client_opcode::increment;
 
   private:
-    std::string key_;
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> key_;
+    std::vector<std::byte> framing_extras_{};
     std::uint64_t delta_{ 1 };
     std::uint64_t initial_value_{ 0 };
     std::uint32_t expiry_{ 0 };
-    std::vector<std::uint8_t> extras_{};
+    std::vector<std::byte> extras_{};
 
   public:
     void id(const document_id& id);
@@ -91,17 +91,17 @@ class increment_request_body
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return framing_extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -109,7 +109,7 @@ class increment_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return empty_buffer;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_insert.cxx

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_insert.hxx>
 
-#include <couchbase/protocol/frame_info_id.hxx>
+#include <couchbase/protocol/frame_info_utils.hxx>
 #include <couchbase/utils/byteswap.hxx>
 #include <couchbase/utils/unsigned_leb128.hxx>
 
@@ -32,10 +32,10 @@ insert_response_body::parse(protocol::status status,
                             std::uint8_t framing_extras_size,
                             std::uint16_t /* key_size */,
                             std::uint8_t extras_size,
-                            const std::vector<uint8_t>& body,
+                            const std::vector<std::byte>& body,
                             const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     if (status == protocol::status::success) {
         std::vector<uint8_t>::difference_type offset = framing_extras_size;
         if (extras_size == 16) {
@@ -53,11 +53,7 @@ insert_response_body::parse(protocol::status status,
 void
 insert_request_body::id(const document_id& id)
 {
-    key_ = id.key();
-    if (id.is_collection_resolved()) {
-        utils::unsigned_leb128<uint32_t> encoded(id.collection_uid());
-        key_.insert(0, encoded.get());
-    }
+    key_ = make_protocol_key(id);
 }
 void
 insert_request_body::durability(protocol::durability_level level, std::optional<std::uint16_t> timeout)
@@ -65,18 +61,8 @@ insert_request_body::durability(protocol::durability_level level, std::optional<
     if (level == protocol::durability_level::none) {
         return;
     }
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
-    if (timeout) {
-        framing_extras_.resize(4);
-        framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-        framing_extras_[1] = static_cast<std::uint8_t>(level);
-        uint16_t val = utils::byte_swap(*timeout);
-        memcpy(framing_extras_.data() + 2, &val, sizeof(val));
-    } else {
-        framing_extras_.resize(2);
-        framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-        framing_extras_[1] = static_cast<std::uint8_t>(level);
-    }
+
+    add_durability_frame_info(framing_extras_, level, timeout);
 }
 void
 insert_request_body::fill_extras()

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_insert.hxx

@@ -47,7 +47,7 @@ class insert_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& info);
 };
 
@@ -58,19 +58,19 @@ class insert_request_body
     static const inline client_opcode opcode = client_opcode::insert;
 
   private:
-    std::string key_{};
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> content_{};
+    std::vector<std::byte> key_{};
+    std::vector<std::byte> extras_{};
+    std::vector<std::byte> content_{};
     std::uint32_t flags_{};
     std::uint32_t expiry_{};
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> framing_extras_{};
 
   public:
     void id(const document_id& id);
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    void content(const std::string_view& content)
+    void content(const std::vector<std::byte>& content)
     {
         content_ = { content.begin(), content.end() };
     }
@@ -85,17 +85,17 @@ class insert_request_body
         expiry_ = value;
     }
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return framing_extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -103,7 +103,7 @@ class insert_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return content_;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_lookup_in.cxx

@@ -20,6 +20,7 @@
 #include <couchbase/utils/byteswap.hxx>
 #include <couchbase/utils/unsigned_leb128.hxx>
 
+#include "couchbase/logger/logger.hxx"
 #include <cstring>
 #include <gsl/assert>
 
@@ -31,13 +32,13 @@ lookup_in_response_body::parse(protocol::status status,
                                std::uint8_t framing_extras_size,
                                std::uint16_t key_size,
                                std::uint8_t extras_size,
-                               const std::vector<uint8_t>& body,
+                               const std::vector<std::byte>& body,
                                const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     if (status == protocol::status::success || status == protocol::status::subdoc_multi_path_failure ||
         status == protocol::status::subdoc_success_deleted || status == protocol::status::subdoc_multi_path_failure_deleted) {
-        using offset_type = std::vector<uint8_t>::difference_type;
+        using offset_type = std::vector<std::byte>::difference_type;
         offset_type offset = framing_extras_size + key_size + extras_size;
         fields_.reserve(16); /* we won't have more than 16 entries anyway */
         while (static_cast<std::size_t>(offset) < body.size()) {
@@ -47,7 +48,7 @@ lookup_in_response_body::parse(protocol::status status,
             memcpy(&entry_status, body.data() + offset, sizeof(entry_status));
             entry_status = utils::byte_swap(entry_status);
             Expects(is_valid_status(entry_status));
-            field.status = protocol::status(entry_status);
+            field.status = static_cast<protocol::status>(entry_status);
             offset += static_cast<offset_type>(sizeof(entry_status));
 
             std::uint32_t entry_size = 0;
@@ -59,6 +60,7 @@ lookup_in_response_body::parse(protocol::status status,
             field.value.resize(entry_size);
             memcpy(field.value.data(), body.data() + offset, entry_size);
             offset += static_cast<offset_type>(entry_size);
+            LOG_CRITICAL("field.value ({}): {}", entry_size, field.value);
 
             fields_.emplace_back(field);
         }
@@ -70,11 +72,7 @@ lookup_in_response_body::parse(protocol::status status,
 void
 lookup_in_request_body::id(const document_id& id)
 {
-    key_ = id.key();
-    if (id.is_collection_resolved()) {
-        utils::unsigned_leb128<uint32_t> encoded(id.collection_uid());
-        key_.insert(0, encoded.get());
-    }
+    key_ = make_protocol_key(id);
 }
 
 void
@@ -82,7 +80,7 @@ lookup_in_request_body::fill_extras()
 {
     if (flags_ != 0) {
         extras_.resize(sizeof(flags_));
-        extras_[0] = flags_;
+        extras_[0] = std::byte{ flags_ };
     }
 }
 
@@ -95,10 +93,12 @@ lookup_in_request_body::fill_value()
     }
     Expects(value_size > 0);
     value_.resize(value_size);
-    std::vector<std::uint8_t>::size_type offset = 0;
-    for (auto& spec : specs_.entries) {
-        value_[offset++] = spec.opcode;
-        value_[offset++] = spec.flags;
+    std::vector<std::byte>::size_type offset = 0;
+    for (const auto& spec : specs_.entries) {
+        value_[offset] = std::byte{ spec.opcode };
+        ++offset;
+        value_[offset] = std::byte{ spec.flags };
+        ++offset;
         std::uint16_t path_size = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(spec.path.size()));
         std::memcpy(value_.data() + offset, &path_size, sizeof(path_size));
         offset += sizeof(path_size);

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_lookup_in.hxx

@@ -52,7 +52,7 @@ class lookup_in_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& info);
 };
 
@@ -95,9 +95,9 @@ class lookup_in_request_body
     };
 
   private:
-    std::string key_;
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> value_{};
+    std::vector<std::byte> key_;
+    std::vector<std::byte> extras_{};
+    std::vector<std::byte> value_{};
 
     std::uint8_t flags_{ 0 };
     lookup_in_specs specs_;
@@ -119,17 +119,17 @@ class lookup_in_request_body
         specs_ = specs;
     }
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -137,7 +137,7 @@ class lookup_in_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const auto& value()
     {
         if (value_.empty()) {
             fill_value();

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_mutate_in.cxx

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_mutate_in.hxx>
 
-#include <couchbase/protocol/frame_info_id.hxx>
+#include <couchbase/protocol/frame_info_utils.hxx>
 #include <couchbase/utils/byteswap.hxx>
 #include <couchbase/utils/unsigned_leb128.hxx>
 
@@ -32,12 +32,12 @@ mutate_in_response_body::parse(protocol::status status,
                                std::uint8_t framing_extras_size,
                                std::uint16_t key_size,
                                std::uint8_t extras_size,
-                               const std::vector<uint8_t>& body,
-                               const cmd_info&)
+                               const std::vector<std::byte>& body,
+                               const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     if (status == protocol::status::success || status == protocol::status::subdoc_multi_path_failure) {
-        using offset_type = std::vector<uint8_t>::difference_type;
+        using offset_type = std::vector<std::byte>::difference_type;
         offset_type offset = framing_extras_size;
         if (extras_size == 16) {
             memcpy(&token_.partition_uuid, body.data() + offset, sizeof(token_.partition_uuid));
@@ -55,14 +55,14 @@ mutate_in_response_body::parse(protocol::status status,
         while (static_cast<std::size_t>(offset) < body.size()) {
             mutate_in_field field;
 
-            field.index = body[static_cast<std::size_t>(offset)];
+            field.index = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);
             offset++;
 
             std::uint16_t entry_status = 0;
             memcpy(&entry_status, body.data() + offset, sizeof(entry_status));
             entry_status = utils::byte_swap(entry_status);
             Expects(is_valid_status(entry_status));
-            field.status = protocol::status(entry_status);
+            field.status = static_cast<protocol::status>(entry_status);
             offset += static_cast<offset_type>(sizeof(entry_status));
 
             if (field.status == protocol::status::success) {
@@ -87,11 +87,7 @@ mutate_in_response_body::parse(protocol::status status,
 void
 mutate_in_request_body::id(const document_id& id)
 {
-    key_ = id.key();
-    if (id.is_collection_resolved()) {
-        utils::unsigned_leb128<uint32_t> encoded(id.collection_uid());
-        key_.insert(0, encoded.get());
-    }
+    key_ = make_protocol_key(id);
 }
 
 void
@@ -100,28 +96,14 @@ mutate_in_request_body::durability(protocol::durability_level level, std::option
     if (level == protocol::durability_level::none) {
         return;
     }
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
-    auto extras_size = framing_extras_.size();
-    if (timeout) {
-        framing_extras_.resize(extras_size + 4);
-        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-        framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
-        uint16_t val = utils::byte_swap(*timeout);
-        memcpy(framing_extras_.data() + extras_size + 2, &val, sizeof(val));
-    } else {
-        framing_extras_.resize(extras_size + 2);
-        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-        framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
-    }
+
+    add_durability_frame_info(framing_extras_, level, timeout);
 }
 
 void
 mutate_in_request_body::preserve_expiry()
 {
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
-    auto extras_size = framing_extras_.size();
-    framing_extras_.resize(extras_size + 1);
-    framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
+    add_preserve_expiry_frame_info(framing_extras_);
 }
 
 void
@@ -135,7 +117,7 @@ mutate_in_request_body::fill_extras()
     if (flags_ != 0) {
         std::size_t offset = extras_.size();
         extras_.resize(offset + sizeof(flags_));
-        extras_[offset] = flags_;
+        extras_[offset] = std::byte{ flags_ };
     }
 }
 
@@ -149,10 +131,12 @@ mutate_in_request_body::fill_value()
     }
     Expects(value_size > 0);
     value_.resize(value_size);
-    std::vector<std::uint8_t>::size_type offset = 0;
+    std::vector<std::byte>::size_type offset = 0;
     for (auto& spec : specs_.entries) {
-        value_[offset++] = spec.opcode;
-        value_[offset++] = spec.flags;
+        value_[offset] = std::byte{ spec.opcode };
+        ++offset;
+        value_[offset] = std::byte{ spec.flags };
+        ++offset;
 
         std::uint16_t path_size = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(spec.path.size()));
         std::memcpy(value_.data() + offset, &path_size, sizeof(path_size));
@@ -165,7 +149,7 @@ mutate_in_request_body::fill_value()
         std::memcpy(value_.data() + offset, spec.path.data(), spec.path.size());
         offset += spec.path.size();
 
-        if (param_size != 0u) {
+        if (param_size != 0U) {
             std::memcpy(value_.data() + offset, spec.param.data(), spec.param.size());
             offset += spec.param.size();
         }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_mutate_in.hxx

@@ -61,7 +61,7 @@ class mutate_in_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& /* info */);
 };
 
@@ -205,14 +205,14 @@ class mutate_in_request_body
     };
 
   private:
-    std::string key_;
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> value_{};
+    std::vector<std::byte> key_;
+    std::vector<std::byte> extras_{};
+    std::vector<std::byte> value_{};
 
     std::uint32_t expiry_{ 0 };
     std::uint8_t flags_{ 0 };
     mutate_in_specs specs_;
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> framing_extras_{};
 
   public:
     void id(const document_id& id);
@@ -265,17 +265,17 @@ class mutate_in_request_body
 
     void preserve_expiry();
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return framing_extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -283,7 +283,7 @@ class mutate_in_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const auto& value()
     {
         if (value_.empty()) {
             fill_value();

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_noop.cxx

@@ -27,10 +27,10 @@ mcbp_noop_response_body::parse(protocol::status /* status */,
                                std::uint8_t /* framing_extras_size */,
                                std::uint16_t /* key_size */,
                                std::uint8_t /* extras_size */,
-                               const std::vector<uint8_t>& /* body */,
+                               const std::vector<std::byte>& /* body */,
                                const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     return false;
 }
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_noop.hxx

@@ -36,7 +36,7 @@ class mcbp_noop_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& info);
 };
 
@@ -51,17 +51,17 @@ class mcbp_noop_request_body
         return empty_string;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
+    [[nodiscard]] const auto& extras() const
     {
         return empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return empty_buffer;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_prepend.cxx

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_prepend.hxx>
 
-#include <couchbase/protocol/frame_info_id.hxx>
+#include <couchbase/protocol/frame_info_utils.hxx>
 #include <couchbase/utils/byteswap.hxx>
 #include <couchbase/utils/unsigned_leb128.hxx>
 
@@ -31,10 +31,10 @@ prepend_response_body::parse(protocol::status status,
                              std::uint8_t framing_extras_size,
                              std::uint16_t /* key_size */,
                              std::uint8_t extras_size,
-                             const std::vector<uint8_t>& body,
+                             const std::vector<std::byte>& body,
                              const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     if (status == protocol::status::success) {
         std::vector<uint8_t>::difference_type offset = framing_extras_size;
         if (extras_size == 16) {
@@ -53,11 +53,7 @@ prepend_response_body::parse(protocol::status status,
 void
 prepend_request_body::id(const document_id& id)
 {
-    key_ = id.key();
-    if (id.is_collection_resolved()) {
-        utils::unsigned_leb128<uint32_t> encoded(id.collection_uid());
-        key_.insert(0, encoded.get());
-    }
+    key_ = make_protocol_key(id);
 }
 
 void
@@ -66,17 +62,7 @@ prepend_request_body::durability(protocol::durability_level level, std::optional
     if (level == protocol::durability_level::none) {
         return;
     }
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
-    if (timeout) {
-        framing_extras_.resize(4);
-        framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-        framing_extras_[1] = static_cast<std::uint8_t>(level);
-        uint16_t val = utils::byte_swap(*timeout);
-        memcpy(framing_extras_.data() + 2, &val, sizeof(val));
-    } else {
-        framing_extras_.resize(2);
-        framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-        framing_extras_[1] = static_cast<std::uint8_t>(level);
-    }
+
+    add_durability_frame_info(framing_extras_, level, timeout);
 }
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_prepend.hxx

@@ -47,7 +47,7 @@ class prepend_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& info);
 };
 
@@ -58,37 +58,37 @@ class prepend_request_body
     static const inline client_opcode opcode = client_opcode::prepend;
 
   private:
-    std::string key_{};
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> content_{};
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> key_{};
+    std::vector<std::byte> extras_{};
+    std::vector<std::byte> content_{};
+    std::vector<std::byte> framing_extras_{};
 
   public:
     void id(const document_id& id);
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    void content(const std::string_view& content)
+    void content(const std::vector<std::byte>& content)
     {
         content_ = { content.begin(), content.end() };
     }
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return framing_extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
+    [[nodiscard]] const auto& extras() const
     {
         return empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return content_;
     }