couchbase 4.1.2 → 4.1.3

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

@@ -1,93 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#include <couchbase/protocol/cmd_increment.hxx>
-
-#include <couchbase/protocol/frame_info_utils.hxx>
-#include <couchbase/utils/byteswap.hxx>
-#include <couchbase/utils/unsigned_leb128.hxx>
-
-#include <cstring>
-#include <gsl/assert>
-
-namespace couchbase::protocol
-{
-bool
-increment_response_body::parse(protocol::status status,
-                               const header_buffer& header,
-                               std::uint8_t framing_extras_size,
-                               std::uint16_t key_size,
-                               std::uint8_t extras_size,
-                               const std::vector<std::byte>& body,
-                               const cmd_info& /* info */)
-{
-    Expects(header[1] == static_cast<std::byte>(opcode));
-    if (status == protocol::status::success) {
-        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));
-            token_.partition_uuid = utils::byte_swap(token_.partition_uuid);
-            offset += 8;
-
-            memcpy(&token_.sequence_number, body.data() + offset, sizeof(token_.sequence_number));
-            token_.sequence_number = utils::byte_swap(token_.sequence_number);
-            offset += 8;
-        }
-        offset += key_size;
-        memcpy(&content_, body.data() + offset, sizeof(content_));
-        content_ = utils::byte_swap(content_);
-        return true;
-    }
-    return false;
-}
-
-void
-increment_request_body::id(const document_id& id)
-{
-    key_ = make_protocol_key(id);
-}
-
-void
-increment_request_body::durability(protocol::durability_level level, std::optional<std::uint16_t> timeout)
-{
-    if (level == protocol::durability_level::none) {
-        return;
-    }
-
-    add_durability_frame_info(framing_extras_, level, timeout);
-}
-
-void
-increment_request_body::fill_extras()
-{
-    extras_.resize(sizeof(delta_) + sizeof(initial_value_) + sizeof(expiry_));
-    using offset_type = std::vector<std::byte>::difference_type;
-    offset_type offset = 0;
-
-    std::uint64_t num = utils::byte_swap(delta_);
-    memcpy(extras_.data() + offset, &num, sizeof(num));
-    offset += static_cast<offset_type>(sizeof(delta_));
-
-    num = utils::byte_swap(initial_value_);
-    memcpy(extras_.data() + offset, &num, sizeof(num));
-    offset += static_cast<offset_type>(sizeof(delta_));
-
-    std::uint32_t ttl = utils::byte_swap(expiry_);
-    memcpy(extras_.data() + offset, &ttl, sizeof(ttl));
-}
-} // namespace couchbase::protocol

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

@@ -1,129 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#pragma once
-
-#include <couchbase/document_id.hxx>
-#include <couchbase/io/mcbp_message.hxx>
-#include <couchbase/mutation_token.hxx>
-#include <couchbase/protocol/client_opcode.hxx>
-#include <couchbase/protocol/cmd_info.hxx>
-#include <couchbase/protocol/durability_level.hxx>
-#include <couchbase/protocol/status.hxx>
-
-namespace couchbase::protocol
-{
-
-class increment_response_body
-{
-  public:
-    static const inline client_opcode opcode = client_opcode::increment;
-
-  private:
-    mutation_token token_{};
-    std::uint64_t content_;
-
-  public:
-    [[nodiscard]] std::uint64_t content() const
-    {
-        return content_;
-    }
-
-    [[nodiscard]] const mutation_token& token() const
-    {
-        return token_;
-    }
-
-    bool parse(protocol::status status,
-               const header_buffer& header,
-               std::uint8_t framing_extras_size,
-               std::uint16_t key_size,
-               std::uint8_t extras_size,
-               const std::vector<std::byte>& body,
-               const cmd_info& info);
-};
-
-class increment_request_body
-{
-  public:
-    using response_body_type = increment_response_body;
-    static const inline client_opcode opcode = client_opcode::increment;
-
-  private:
-    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::byte> extras_{};
-
-  public:
-    void id(const document_id& id);
-
-    void delta(std::uint64_t value)
-    {
-        delta_ = value;
-    }
-
-    void initial_value(std::uint64_t value)
-    {
-        initial_value_ = value;
-    }
-
-    void expiry(std::uint32_t value)
-    {
-        expiry_ = value;
-    }
-
-    void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
-
-    [[nodiscard]] const auto& key() const
-    {
-        return key_;
-    }
-
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return framing_extras_;
-    }
-
-    [[nodiscard]] const auto& extras()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return extras_;
-    }
-
-    [[nodiscard]] const auto& value() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] std::size_t size()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return extras_.size() + framing_extras_.size() + key_.size();
-    }
-
-  private:
-    void fill_extras();
-};
-
-} // namespace couchbase::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_info.hxx

@@ -1,29 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#pragma once
-
-#include <string_view>
-
-namespace couchbase::protocol
-{
-struct cmd_info {
-    std::string_view endpoint_address{};
-    uint16_t endpoint_port{};
-    double server_duration_us{ 0 };
-};
-} // namespace couchbase::protocol

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

@@ -1,78 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#include <couchbase/protocol/cmd_insert.hxx>
-
-#include <couchbase/protocol/frame_info_utils.hxx>
-#include <couchbase/utils/byteswap.hxx>
-#include <couchbase/utils/unsigned_leb128.hxx>
-
-#include <cstring>
-#include <gsl/assert>
-
-namespace couchbase::protocol
-{
-bool
-insert_response_body::parse(protocol::status status,
-                            const header_buffer& header,
-                            std::uint8_t framing_extras_size,
-                            std::uint16_t /* key_size */,
-                            std::uint8_t extras_size,
-                            const std::vector<std::byte>& body,
-                            const cmd_info& /* info */)
-{
-    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) {
-            memcpy(&token_.partition_uuid, body.data() + offset, sizeof(token_.partition_uuid));
-            token_.partition_uuid = utils::byte_swap(token_.partition_uuid);
-            offset += 8;
-
-            memcpy(&token_.sequence_number, body.data() + offset, sizeof(token_.sequence_number));
-            token_.sequence_number = utils::byte_swap(token_.sequence_number);
-            return true;
-        }
-    }
-    return false;
-}
-void
-insert_request_body::id(const document_id& id)
-{
-    key_ = make_protocol_key(id);
-}
-void
-insert_request_body::durability(protocol::durability_level level, std::optional<std::uint16_t> timeout)
-{
-    if (level == protocol::durability_level::none) {
-        return;
-    }
-
-    add_durability_frame_info(framing_extras_, level, timeout);
-}
-void
-insert_request_body::fill_extras()
-{
-    extras_.resize(sizeof(flags_) + sizeof(expiry_));
-
-    uint32_t field = utils::byte_swap(flags_);
-    memcpy(extras_.data(), &field, sizeof(field));
-
-    field = utils::byte_swap(expiry_);
-    memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
-}
-} // namespace couchbase::protocol

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

@@ -1,123 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#pragma once
-
-#include <couchbase/document_id.hxx>
-#include <couchbase/io/mcbp_message.hxx>
-#include <couchbase/mutation_token.hxx>
-#include <couchbase/protocol/client_opcode.hxx>
-#include <couchbase/protocol/cmd_info.hxx>
-#include <couchbase/protocol/durability_level.hxx>
-#include <couchbase/protocol/status.hxx>
-
-namespace couchbase::protocol
-{
-
-class insert_response_body
-{
-  public:
-    static const inline client_opcode opcode = client_opcode::insert;
-
-  private:
-    mutation_token token_;
-
-  public:
-    [[nodiscard]] const mutation_token& token() const
-    {
-        return token_;
-    }
-
-    bool parse(protocol::status status,
-               const header_buffer& header,
-               std::uint8_t framing_extras_size,
-               std::uint16_t key_size,
-               std::uint8_t extras_size,
-               const std::vector<std::byte>& body,
-               const cmd_info& info);
-};
-
-class insert_request_body
-{
-  public:
-    using response_body_type = insert_response_body;
-    static const inline client_opcode opcode = client_opcode::insert;
-
-  private:
-    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::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::vector<std::byte>& content)
-    {
-        content_ = { content.begin(), content.end() };
-    }
-
-    void flags(uint32_t flags)
-    {
-        flags_ = flags;
-    }
-
-    void expiry(uint32_t value)
-    {
-        expiry_ = value;
-    }
-
-    [[nodiscard]] const auto& key() const
-    {
-        return key_;
-    }
-
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return framing_extras_;
-    }
-
-    [[nodiscard]] const auto& extras()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return extras_;
-    }
-
-    [[nodiscard]] const auto& value() const
-    {
-        return content_;
-    }
-
-    [[nodiscard]] std::size_t size()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return framing_extras_.size() + extras_.size() + key_.size() + content_.size();
-    }
-
-  private:
-    void fill_extras();
-};
-
-} // namespace couchbase::protocol

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

@@ -1,109 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#include <couchbase/protocol/cmd_lookup_in.hxx>
-
-#include <couchbase/utils/byteswap.hxx>
-#include <couchbase/utils/unsigned_leb128.hxx>
-
-#include "couchbase/logger/logger.hxx"
-#include <cstring>
-#include <gsl/assert>
-
-namespace couchbase::protocol
-{
-bool
-lookup_in_response_body::parse(protocol::status status,
-                               const header_buffer& header,
-                               std::uint8_t framing_extras_size,
-                               std::uint16_t key_size,
-                               std::uint8_t extras_size,
-                               const std::vector<std::byte>& body,
-                               const cmd_info& /* info */)
-{
-    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<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()) {
-            lookup_in_field field;
-
-            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 = static_cast<protocol::status>(entry_status);
-            offset += static_cast<offset_type>(sizeof(entry_status));
-
-            std::uint32_t entry_size = 0;
-            memcpy(&entry_size, body.data() + offset, sizeof(entry_size));
-            entry_size = utils::byte_swap(entry_size);
-            Expects(entry_size < 20 * 1024 * 1024);
-            offset += static_cast<offset_type>(sizeof(entry_size));
-
-            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);
-        }
-        return true;
-    }
-    return false;
-}
-
-void
-lookup_in_request_body::id(const document_id& id)
-{
-    key_ = make_protocol_key(id);
-}
-
-void
-lookup_in_request_body::fill_extras()
-{
-    if (flags_ != 0) {
-        extras_.resize(sizeof(flags_));
-        extras_[0] = std::byte{ flags_ };
-    }
-}
-
-void
-lookup_in_request_body::fill_value()
-{
-    size_t value_size = 0;
-    for (const auto& spec : specs_.entries) {
-        value_size += sizeof(spec.opcode) + sizeof(spec.flags) + sizeof(std::uint16_t) + spec.path.size();
-    }
-    Expects(value_size > 0);
-    value_.resize(value_size);
-    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);
-        std::memcpy(value_.data() + offset, spec.path.data(), spec.path.size());
-        offset += spec.path.size();
-    }
-}
-} // namespace couchbase::protocol