couchbase 4.1.1 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/duration_parser.cxx

@@ -0,0 +1,193 @@
+/* -*- 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 "duration_parser.hxx"
+
+namespace couchbase::core::utils
+{
+/**
+ * leading_int consumes the leading [0-9]* from s.
+ */
+static bool
+leading_int(std::string& s, std::int64_t& v)
+{
+    v = 0;
+    std::size_t i = 0;
+    for (; i < s.size(); ++i) {
+        auto c = s[i];
+
+        if (c < '0' || c > '9') {
+            break;
+        }
+
+        if (v > std::int64_t((1LLU << 63U) - 1LLU) / 10) {
+            return false;
+        }
+
+        v = v * 10 + std::int64_t(c) - '0';
+
+        if (v < 0) {
+            return false;
+        }
+    }
+    s = s.substr(i);
+    return true;
+}
+
+/**
+ * leading_fraction consumes the leading [0-9]* from s.
+ *
+ * It is used only for fractions, so does not return an error on overflow,
+ * it just stops accumulating precision.
+ */
+
+static void
+leading_fraction(std::string& s, std::int64_t& x, std::uint32_t& scale)
+{
+    std::size_t i = 0;
+    scale = 1;
+
+    bool overflow = false;
+
+    for (; i < s.size(); ++i) {
+        auto c = s[i];
+
+        if (c < '0' || c > '9') {
+            break;
+        }
+
+        if (overflow) {
+            continue;
+        }
+
+        if (x > std::int64_t((1LLU << 63LLU) - 1LLU) / 10) {
+            // It's possible for overflow to give a positive number, so take care.
+            overflow = true;
+            continue;
+        }
+
+        auto y = x * 10 + std::int64_t(c) - '0';
+        if (y < 0) {
+            overflow = true;
+            continue;
+        }
+
+        x = y;
+        scale *= 10;
+    }
+
+    s = s.substr(i);
+}
+
+std::chrono::nanoseconds
+parse_duration(const std::string& text)
+{
+    // [-+]?([0-9]*(\.[0-9]*)?[a-z]+)+
+    std::string s = text;
+    std::chrono::nanoseconds d{ 0 };
+    bool neg{ false };
+
+    // Consume [-+]?
+    if (!s.empty()) {
+        auto c = s[0];
+
+        if (c == '-' || c == '+') {
+            neg = c == '-';
+            s = s.substr(1);
+        }
+    }
+    if (neg) {
+        throw duration_parse_error("negative durations are not supported: " + text);
+    }
+
+    // Special case: if all that is left is "0", this is zero.
+    if (s == "0") {
+        return std::chrono::nanoseconds::zero();
+    }
+
+    if (s.empty()) {
+        throw duration_parse_error("invalid duration: " + text);
+    }
+
+    while (!s.empty()) {
+        // The next character must be [0-9.]
+        if (!(s[0] == '.' || ('0' <= s[0] && s[0] <= '9'))) {
+            throw duration_parse_error("invalid duration: " + text);
+        }
+
+        // Consume [0-9]*
+        auto pl = s.size();
+
+        std::int64_t v{ 0 }; // integer before decimal point
+        if (!leading_int(s, v)) {
+            throw duration_parse_error("invalid duration (leading_int overflow): " + text);
+        }
+
+        bool pre = pl != s.size(); // whether we consumed anything before a period
+
+        std::int64_t f{ 0 };      // integer after decimal point
+        std::uint32_t scale{ 1 }; // value = v + f/scale
+
+        // Consume (\.[0-9]*)?
+        bool post = false;
+        if (!s.empty() && s[0] == '.') {
+            s = s.substr(1);
+            pl = s.size();
+            leading_fraction(s, f, scale);
+            post = pl != s.size();
+        }
+
+        if (!pre && !post) {
+            // no digits (e.g. ".s" or "-.s")
+            throw duration_parse_error("invalid duration: " + text);
+        }
+
+        // Consume unit.
+        std::size_t i = 0;
+        for (; i < s.size(); ++i) {
+            auto c = s[i];
+            if (c == '.' || ('0' <= c && c <= '9')) {
+                break;
+            }
+        }
+        if (i == 0) {
+            throw duration_parse_error("missing unit in duration: " + text);
+        }
+
+        auto u = s.substr(0, i);
+        s = s.substr(i);
+
+        if (u == "ns") {
+            d += std::chrono::nanoseconds(v); /* no sub-nanoseconds, ignore 'f' */
+        } else if (u == "us" || u == "µs" /* U+00B5 = micro symbol */ || u == "μs" /* U+03BC = Greek letter mu */) {
+            d += std::chrono::microseconds(v) + std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::microseconds(f)) / scale;
+        } else if (u == "ms") {
+            d += std::chrono::milliseconds(v) + std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(f)) / scale;
+        } else if (u == "s") {
+            d += std::chrono::seconds(v) + std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(f)) / scale;
+        } else if (u == "m") {
+            d += std::chrono::minutes(v) + std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(f)) / scale;
+        } else if (u == "h") {
+            d += std::chrono::hours(v) + std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::hours(f)) / scale;
+        } else {
+            throw duration_parse_error(std::string("unknown unit ").append(u).append(" in duration ").append(text));
+        }
+    }
+
+    return d;
+}
+} // namespace couchbase::core::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/duration_parser.hxx

@@ -0,0 +1,45 @@
+/* -*- 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 <chrono>
+#include <stdexcept>
+#include <string>
+
+namespace couchbase::core::utils
+{
+class duration_parse_error : public std::runtime_error
+{
+  public:
+    explicit duration_parse_error(const std::string& msg)
+      : std::runtime_error(msg)
+    {
+    }
+};
+
+/**
+ * Parses a duration string.
+ *
+ * A duration string is a possibly signed sequence of decimal numbers, each with optional fraction and a unit suffix,
+ * such as "300ms", "-1.5h" or "2h45m".
+ *
+ * Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
+ */
+std::chrono::nanoseconds
+parse_duration(const std::string& text);
+} // namespace couchbase::core::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/join_strings.hxx

@@ -0,0 +1,65 @@
+/* -*- 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 <fmt/core.h>
+#include <sstream>
+
+namespace couchbase::core::utils
+{
+/**
+ * Joins a list of strings together.
+ */
+template<typename Range>
+std::string
+join_strings(const Range& values, const std::string& sep)
+{
+    std::stringstream stream;
+    auto sentinel = std::end(values);
+    if (auto it = std::begin(values); it != sentinel) {
+        stream << *it;
+        ++it;
+        while (it != sentinel) {
+            stream << sep << *it;
+            ++it;
+        }
+    }
+    return stream.str();
+}
+
+/**
+ * Joins a list of objects together using fmt:: for formatting.
+ */
+template<typename Range>
+std::string
+join_strings_fmt(const std::string& item_fmt, const Range& values, const std::string& sep)
+{
+    std::stringstream stream;
+    auto sentinel = std::end(values);
+    if (auto it = std::begin(values); it != sentinel) {
+        stream << fmt::format(item_fmt, *it);
+        ++it;
+        while (it != sentinel) {
+            stream << sep << fmt::format(item_fmt, *it);
+            ++it;
+        }
+    }
+    return stream.str();
+}
+
+} // namespace couchbase::core::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/json.cxx

@@ -0,0 +1,286 @@
+/* -*- 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 "json.hxx"
+
+#include <tao/json.hpp>
+#include <tao/json/contrib/traits.hpp>
+
+namespace couchbase::core::utils::json
+{
+/**
+ *
+ * This transformer is necessary to handle invalid JSON sent by the server.
+ *
+ * 1) For some reason "projector" field gets duplicated in the configuration JSON
+ *
+ * 2) CXXCBC-13, ns_server sends response to list buckets request with duplicated keys.
+ */
+template<typename Consumer>
+struct last_key_wins : Consumer {
+    using Consumer::Consumer;
+
+    using Consumer::keys_;
+    using Consumer::stack_;
+    using Consumer::value;
+
+    void member()
+    {
+        Consumer::stack_.back().prepare_object()[Consumer::keys_.back()] = std::move(Consumer::value);
+        Consumer::keys_.pop_back();
+    }
+};
+
+tao::json::value
+parse(std::string_view input)
+{
+    return tao::json::from_string<utils::json::last_key_wins>(input);
+}
+
+tao::json::value
+parse(const json_string& input)
+{
+    return parse(input.str());
+}
+
+tao::json::value
+parse(const char* input, std::size_t size)
+{
+    return tao::json::from_string<utils::json::last_key_wins>(input, size);
+}
+
+tao::json::value
+parse_binary(const std::vector<std::byte>& input)
+{
+    return tao::json::from_string<utils::json::last_key_wins>(reinterpret_cast<const char*>(input.data()), input.size());
+}
+
+std::string
+generate(const tao::json::value& object)
+{
+    return tao::json::to_string(object);
+}
+
+class to_byte_vector
+{
+  private:
+    std::vector<std::byte>& buffer_;
+    bool first_{ true };
+
+    void next()
+    {
+        if (!first_) {
+            buffer_.emplace_back(std::byte{ ',' });
+        }
+    }
+
+    void write(tao::binary_view data)
+    {
+        buffer_.reserve(buffer_.size() + data.size());
+        std::copy(data.begin(), data.end(), std::back_inserter(buffer_));
+    }
+
+    void write(std::string_view data)
+    {
+        buffer_.reserve(buffer_.size() + data.size());
+        std::transform(data.begin(), data.end(), std::back_inserter(buffer_), [](auto ch) { return static_cast<std::byte>(ch); });
+    }
+
+    inline void escape(const std::string_view s)
+    {
+        static std::array h{
+            std::byte{ '0' }, std::byte{ '1' }, std::byte{ '2' }, std::byte{ '3' }, std::byte{ '4' }, std::byte{ '5' },
+            std::byte{ '6' }, std::byte{ '7' }, std::byte{ '8' }, std::byte{ '9' }, std::byte{ 'a' }, std::byte{ 'b' },
+            std::byte{ 'c' }, std::byte{ 'd' }, std::byte{ 'e' }, std::byte{ 'f' },
+        };
+
+        const char* p = s.data();
+        const char* l = p;
+        const char* const e = p + s.size();
+        while (p != e) {
+            const char c = *p;
+            if (c == '\\' || c == '"') {
+                write({ l, static_cast<std::size_t>(p - l) });
+                l = ++p;
+                buffer_.emplace_back(std::byte{ '\\' });
+                buffer_.emplace_back(static_cast<std::byte>(c));
+            } else if (static_cast<std::uint8_t>(c) < 32 || c == 127) {
+                write({ l, static_cast<std::size_t>(p - l) });
+                l = ++p;
+                switch (c) {
+                    case '\b':
+                        write("\\b");
+                        break;
+                    case '\f':
+                        write("\\f");
+                        break;
+                    case '\n':
+                        write("\\n");
+                        break;
+                    case '\r':
+                        write("\\r");
+                        break;
+                    case '\t':
+                        write("\\t");
+                        break;
+                    default:
+                        write(std::array{
+                          std::byte{ '\\' },
+                          std::byte{ 'u' },
+                          std::byte{ '0' },
+                          std::byte{ '0' },
+                          std::byte{ h[(c & 0xf0) >> 4] },
+                          std::byte{ h[c & 0x0f] },
+                        });
+                }
+            } else {
+                ++p;
+            }
+        }
+        write({ l, static_cast<std::size_t>(p - l) });
+    }
+
+  public:
+    explicit to_byte_vector(std::vector<std::byte>& output) noexcept
+      : buffer_(output)
+    {
+    }
+
+    void null()
+    {
+        next();
+        static std::array literal_null{
+            std::byte{ 'n' },
+            std::byte{ 'u' },
+            std::byte{ 'l' },
+            std::byte{ 'l' },
+        };
+        write(literal_null);
+    }
+
+    void boolean(const bool v)
+    {
+        next();
+        if (v) {
+            static std::array literal_true{
+                std::byte{ 't' },
+                std::byte{ 'r' },
+                std::byte{ 'u' },
+                std::byte{ 'e' },
+            };
+            write(literal_true);
+        } else {
+            static std::array literal_false{
+                std::byte{ 'f' }, std::byte{ 'a' }, std::byte{ 'l' }, std::byte{ 's' }, std::byte{ 'e' },
+            };
+            write(literal_false);
+        }
+    }
+
+    void number(const std::int64_t v)
+    {
+        next();
+        char b[24]{};
+        const char* s = tao::json::itoa::i64toa(v, b);
+        write({ b, static_cast<std::size_t>(s - b) });
+    }
+
+    void number(const std::uint64_t v)
+    {
+        next();
+        char b[24]{};
+        const char* s = tao::json::itoa::u64toa(v, b);
+        write({ b, static_cast<std::size_t>(s - b) });
+    }
+
+    void number(const double v)
+    {
+        next();
+        if (!std::isfinite(v)) {
+            // if this throws, consider using non_finite_to_* transformers
+            throw std::runtime_error("non-finite double value invalid for JSON string representation");
+        }
+        char b[28];
+        const auto s = tao::json::ryu::d2s_finite(v, b);
+        write({ b, s });
+    }
+
+    void string(const std::string_view v)
+    {
+        next();
+        buffer_.emplace_back(std::byte{ '"' });
+        escape(v);
+        buffer_.emplace_back(std::byte{ '"' });
+    }
+
+    void binary(const tao::binary_view /*unused*/) // NOLINT(readability-convert-member-functions-to-static)
+    {
+        // if this throws, consider using binary_to_* transformers
+        throw std::runtime_error("binary data invalid for JSON string representation");
+    }
+
+    void begin_array(const std::size_t /*unused*/ = 0)
+    {
+        next();
+        buffer_.emplace_back(std::byte{ '[' });
+        first_ = true;
+    }
+
+    void element() noexcept
+    {
+        first_ = false;
+    }
+
+    void end_array(const std::size_t /*unused*/ = 0)
+    {
+        buffer_.emplace_back(std::byte{ ']' });
+    }
+
+    void begin_object(const std::size_t /*unused*/ = 0)
+    {
+        next();
+        buffer_.emplace_back(std::byte{ '{' });
+        first_ = true;
+    }
+
+    void key(const std::string_view v)
+    {
+        string(v);
+        buffer_.emplace_back(std::byte{ ':' });
+        first_ = true;
+    }
+
+    void member() noexcept
+    {
+        first_ = false;
+    }
+
+    void end_object(const std::size_t /*unused*/ = 0)
+    {
+        buffer_.emplace_back(std::byte{ '}' });
+    }
+};
+
+std::vector<std::byte>
+generate_binary(const tao::json::value& object)
+{
+    std::vector<std::byte> out;
+    tao::json::events::transformer<to_byte_vector> consumer(out);
+    tao::json::events::from_value(consumer, object);
+    return out;
+}
+} // namespace couchbase::core::utils::json

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/json.hxx

@@ -0,0 +1,43 @@
+/* -*- 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 "core/json_string.hxx"
+
+#include <tao/json/value.hpp>
+
+namespace couchbase::core::utils::json
+{
+tao::json::value
+parse(std::string_view input);
+
+tao::json::value
+parse(const json_string& input);
+
+tao::json::value
+parse(const char* input, std::size_t size);
+
+std::string
+generate(const tao::json::value& object);
+
+tao::json::value
+parse_binary(const std::vector<std::byte>& input);
+
+std::vector<std::byte>
+generate_binary(const tao::json::value& object);
+} // namespace couchbase::core::utils::json

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/json_stream_control.hxx

@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2022 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
+
+namespace couchbase::core::utils::json
+{
+enum class stream_control {
+    /**
+     * continue streaming rows
+     */
+    next_row,
+    /**
+     * stop streaming rows, but wait for complete meta
+     */
+    stop,
+};
+} // namespace couchbase::core::utils::json