couchbase 3.5.2 → 3.5.4

data/ext/cache/asio/b710bc0ca14b231d20e983b02d27485125c7860e/asio/asio/include/asio/readable_pipe.hpp

@@ -0,0 +1,35 @@
+//
+// readable_pipe.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_READABLE_PIPE_HPP
+#define ASIO_READABLE_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_PIPE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include "asio/basic_readable_pipe.hpp"
+
+namespace asio {
+
+/// Typedef for the typical usage of a readable pipe.
+typedef basic_readable_pipe<> readable_pipe;
+
+} // namespace asio
+
+#endif // defined(ASIO_HAS_PIPE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // ASIO_READABLE_PIPE_HPP

data/ext/cache/asio/b710bc0ca14b231d20e983b02d27485125c7860e/asio/asio/include/asio/recycling_allocator.hpp

@@ -0,0 +1,138 @@
+//
+// recycling_allocator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_RECYCLING_ALLOCATOR_HPP
+#define ASIO_RECYCLING_ALLOCATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/recycling_allocator.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// An allocator that caches memory blocks in thread-local storage for reuse.
+/**
+ * The @recycling_allocator uses a simple strategy where a limited number of
+ * small memory blocks are cached in thread-local storage, if the current
+ * thread is running an @c io_context or is part of a @c thread_pool.
+ */
+template <typename T>
+class recycling_allocator
+{
+public:
+  /// The type of object allocated by the recycling allocator.
+  typedef T value_type;
+
+  /// Rebind the allocator to another value_type.
+  template <typename U>
+  struct rebind
+  {
+    /// The rebound @c allocator type.
+    typedef recycling_allocator<U> other;
+  };
+
+  /// Default constructor.
+  constexpr recycling_allocator() noexcept
+  {
+  }
+
+  /// Converting constructor.
+  template <typename U>
+  constexpr recycling_allocator(
+      const recycling_allocator<U>&) noexcept
+  {
+  }
+
+  /// Equality operator. Always returns true.
+  constexpr bool operator==(
+      const recycling_allocator&) const noexcept
+  {
+    return true;
+  }
+
+  /// Inequality operator. Always returns false.
+  constexpr bool operator!=(
+      const recycling_allocator&) const noexcept
+  {
+    return false;
+  }
+
+  /// Allocate memory for the specified number of values.
+  T* allocate(std::size_t n)
+  {
+    return detail::recycling_allocator<T>().allocate(n);
+  }
+
+  /// Deallocate memory for the specified number of values.
+  void deallocate(T* p, std::size_t n)
+  {
+    detail::recycling_allocator<T>().deallocate(p, n);
+  }
+};
+
+/// A proto-allocator that caches memory blocks in thread-local storage for
+/// reuse.
+/**
+ * The @recycling_allocator uses a simple strategy where a limited number of
+ * small memory blocks are cached in thread-local storage, if the current
+ * thread is running an @c io_context or is part of a @c thread_pool.
+ */
+template <>
+class recycling_allocator<void>
+{
+public:
+  /// No values are allocated by a proto-allocator.
+  typedef void value_type;
+
+  /// Rebind the allocator to another value_type.
+  template <typename U>
+  struct rebind
+  {
+    /// The rebound @c allocator type.
+    typedef recycling_allocator<U> other;
+  };
+
+  /// Default constructor.
+  constexpr recycling_allocator() noexcept
+  {
+  }
+
+  /// Converting constructor.
+  template <typename U>
+  constexpr recycling_allocator(
+      const recycling_allocator<U>&) noexcept
+  {
+  }
+
+  /// Equality operator. Always returns true.
+  constexpr bool operator==(
+      const recycling_allocator&) const noexcept
+  {
+    return true;
+  }
+
+  /// Inequality operator. Always returns false.
+  constexpr bool operator!=(
+      const recycling_allocator&) const noexcept
+  {
+    return false;
+  }
+};
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_RECYCLING_ALLOCATOR_HPP

data/ext/cache/asio/b710bc0ca14b231d20e983b02d27485125c7860e/asio/asio/include/asio/redirect_error.hpp

@@ -0,0 +1,104 @@
+//
+// redirect_error.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_REDIRECT_ERROR_HPP
+#define ASIO_REDIRECT_ERROR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/error_code.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// A @ref completion_token adapter used to specify that an error produced by an
+/// asynchronous operation is captured to an error_code variable.
+/**
+ * The redirect_error_t class is used to indicate that any error_code produced
+ * by an asynchronous operation is captured to a specified variable.
+ */
+template <typename CompletionToken>
+class redirect_error_t
+{
+public:
+  /// Constructor.
+  template <typename T>
+  redirect_error_t(T&& completion_token, asio::error_code& ec)
+    : token_(static_cast<T&&>(completion_token)),
+      ec_(ec)
+  {
+  }
+
+//private:
+  CompletionToken token_;
+  asio::error_code& ec_;
+};
+
+/// A function object type that adapts a @ref completion_token to capture
+/// error_code values to a variable.
+/**
+ * May also be used directly as a completion token, in which case it adapts the
+ * asynchronous operation's default completion token (or asio::deferred
+ * if no default is available).
+ */
+class partial_redirect_error
+{
+public:
+  /// Constructor that specifies the variable used to capture error_code values.
+  explicit partial_redirect_error(asio::error_code& ec)
+    : ec_(ec)
+  {
+  }
+
+  /// Adapt a @ref completion_token to specify that the completion handler
+  /// should capture error_code values to a variable.
+  template <typename CompletionToken>
+  ASIO_NODISCARD inline
+  constexpr redirect_error_t<decay_t<CompletionToken>>
+  operator()(CompletionToken&& completion_token) const
+  {
+    return redirect_error_t<decay_t<CompletionToken>>(
+        static_cast<CompletionToken&&>(completion_token), ec_);
+  }
+
+//private:
+  asio::error_code& ec_;
+};
+
+/// Create a partial completion token adapter that captures error_code values
+/// to a variable.
+ASIO_NODISCARD inline partial_redirect_error
+redirect_error(asio::error_code& ec)
+{
+  return partial_redirect_error(ec);
+}
+
+/// Adapt a @ref completion_token to capture error_code values to a variable.
+template <typename CompletionToken>
+ASIO_NODISCARD inline redirect_error_t<decay_t<CompletionToken>>
+redirect_error(CompletionToken&& completion_token,
+    asio::error_code& ec)
+{
+  return redirect_error_t<decay_t<CompletionToken>>(
+      static_cast<CompletionToken&&>(completion_token), ec);
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/redirect_error.hpp"
+
+#endif // ASIO_REDIRECT_ERROR_HPP

data/ext/cache/asio/b710bc0ca14b231d20e983b02d27485125c7860e/asio/asio/include/asio/registered_buffer.hpp

@@ -0,0 +1,344 @@
+//
+// registered_buffer.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_REGISTERED_BUFFER_HPP
+#define ASIO_REGISTERED_BUFFER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/buffer.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+class buffer_registration_base;
+
+} // namespace detail
+
+class const_registered_buffer;
+
+/// Type used to identify a registered buffer.
+class registered_buffer_id
+{
+public:
+  /// The native buffer identifier type.
+  typedef int native_handle_type;
+
+  /// Default constructor creates an invalid registered buffer identifier.
+  registered_buffer_id() noexcept
+    : scope_(0),
+      index_(-1)
+  {
+  }
+
+  /// Get the native buffer identifier type.
+  native_handle_type native_handle() const noexcept
+  {
+    return index_;
+  }
+
+  /// Compare two IDs for equality.
+  friend bool operator==(const registered_buffer_id& lhs,
+      const registered_buffer_id& rhs) noexcept
+  {
+    return lhs.scope_ == rhs.scope_ && lhs.index_ == rhs.index_;
+  }
+
+  /// Compare two IDs for equality.
+  friend bool operator!=(const registered_buffer_id& lhs,
+      const registered_buffer_id& rhs) noexcept
+  {
+    return lhs.scope_ != rhs.scope_ || lhs.index_ != rhs.index_;
+  }
+
+private:
+  friend class detail::buffer_registration_base;
+
+  // Hidden constructor used by buffer registration.
+  registered_buffer_id(const void* scope, int index) noexcept
+    : scope_(scope),
+      index_(index)
+  {
+  }
+
+  const void* scope_;
+  int index_;
+};
+
+/// Holds a registered buffer over modifiable data.
+/**
+ * Satisfies the @c MutableBufferSequence type requirements.
+ */
+class mutable_registered_buffer
+{
+public:
+  /// Default constructor creates an invalid registered buffer.
+  mutable_registered_buffer() noexcept
+    : buffer_(),
+      id_()
+  {
+  }
+
+  /// Get the underlying mutable buffer.
+  const mutable_buffer& buffer() const noexcept
+  {
+    return buffer_;
+  }
+
+  /// Get a pointer to the beginning of the memory range.
+  /**
+   * @returns <tt>buffer().data()</tt>.
+   */
+  void* data() const noexcept
+  {
+    return buffer_.data();
+  }
+
+  /// Get the size of the memory range.
+  /**
+   * @returns <tt>buffer().size()</tt>.
+   */
+  std::size_t size() const noexcept
+  {
+    return buffer_.size();
+  }
+
+  /// Get the registered buffer identifier.
+  const registered_buffer_id& id() const noexcept
+  {
+    return id_;
+  }
+
+  /// Move the start of the buffer by the specified number of bytes.
+  mutable_registered_buffer& operator+=(std::size_t n) noexcept
+  {
+    buffer_ += n;
+    return *this;
+  }
+
+private:
+  friend class detail::buffer_registration_base;
+
+  // Hidden constructor used by buffer registration and operators.
+  mutable_registered_buffer(const mutable_buffer& b,
+      const registered_buffer_id& i) noexcept
+    : buffer_(b),
+      id_(i)
+  {
+  }
+
+#if !defined(GENERATING_DOCUMENTATION)
+  friend mutable_registered_buffer buffer(
+      const mutable_registered_buffer& b, std::size_t n) noexcept;
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  mutable_buffer buffer_;
+  registered_buffer_id id_;
+};
+
+/// Holds a registered buffer over non-modifiable data.
+/**
+ * Satisfies the @c ConstBufferSequence type requirements.
+ */
+class const_registered_buffer
+{
+public:
+  /// Default constructor creates an invalid registered buffer.
+  const_registered_buffer() noexcept
+    : buffer_(),
+      id_()
+  {
+  }
+
+  /// Construct a non-modifiable buffer from a modifiable one.
+  const_registered_buffer(
+      const mutable_registered_buffer& b) noexcept
+    : buffer_(b.buffer()),
+      id_(b.id())
+  {
+  }
+
+  /// Get the underlying constant buffer.
+  const const_buffer& buffer() const noexcept
+  {
+    return buffer_;
+  }
+
+  /// Get a pointer to the beginning of the memory range.
+  /**
+   * @returns <tt>buffer().data()</tt>.
+   */
+  const void* data() const noexcept
+  {
+    return buffer_.data();
+  }
+
+  /// Get the size of the memory range.
+  /**
+   * @returns <tt>buffer().size()</tt>.
+   */
+  std::size_t size() const noexcept
+  {
+    return buffer_.size();
+  }
+
+  /// Get the registered buffer identifier.
+  const registered_buffer_id& id() const noexcept
+  {
+    return id_;
+  }
+
+  /// Move the start of the buffer by the specified number of bytes.
+  const_registered_buffer& operator+=(std::size_t n) noexcept
+  {
+    buffer_ += n;
+    return *this;
+  }
+
+private:
+  // Hidden constructor used by operators.
+  const_registered_buffer(const const_buffer& b,
+      const registered_buffer_id& i) noexcept
+    : buffer_(b),
+      id_(i)
+  {
+  }
+
+#if !defined(GENERATING_DOCUMENTATION)
+  friend const_registered_buffer buffer(
+      const const_registered_buffer& b, std::size_t n) noexcept;
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+  const_buffer buffer_;
+  registered_buffer_id id_;
+};
+
+/** @addtogroup buffer_sequence_begin */
+
+/// Get an iterator to the first element in a buffer sequence.
+inline const mutable_buffer* buffer_sequence_begin(
+    const mutable_registered_buffer& b) noexcept
+{
+  return &b.buffer();
+}
+
+/// Get an iterator to the first element in a buffer sequence.
+inline const const_buffer* buffer_sequence_begin(
+    const const_registered_buffer& b) noexcept
+{
+  return &b.buffer();
+}
+
+/** @} */
+/** @addtogroup buffer_sequence_end */
+
+/// Get an iterator to one past the end element in a buffer sequence.
+inline const mutable_buffer* buffer_sequence_end(
+    const mutable_registered_buffer& b) noexcept
+{
+  return &b.buffer() + 1;
+}
+
+/// Get an iterator to one past the end element in a buffer sequence.
+inline const const_buffer* buffer_sequence_end(
+    const const_registered_buffer& b) noexcept
+{
+  return &b.buffer() + 1;
+}
+
+/** @} */
+/** @addtogroup buffer */
+
+/// Obtain a buffer representing the entire registered buffer.
+inline mutable_registered_buffer buffer(
+    const mutable_registered_buffer& b) noexcept
+{
+  return b;
+}
+
+/// Obtain a buffer representing the entire registered buffer.
+inline const_registered_buffer buffer(
+    const const_registered_buffer& b) noexcept
+{
+  return b;
+}
+
+/// Obtain a buffer representing part of a registered buffer.
+inline mutable_registered_buffer buffer(
+    const mutable_registered_buffer& b, std::size_t n) noexcept
+{
+  return mutable_registered_buffer(buffer(b.buffer_, n), b.id_);
+}
+
+/// Obtain a buffer representing part of a registered buffer.
+inline const_registered_buffer buffer(
+    const const_registered_buffer& b, std::size_t n) noexcept
+{
+  return const_registered_buffer(buffer(b.buffer_, n), b.id_);
+}
+
+/** @} */
+
+/// Create a new modifiable registered buffer that is offset from the start of
+/// another.
+/**
+ * @relates mutable_registered_buffer
+ */
+inline mutable_registered_buffer operator+(
+    const mutable_registered_buffer& b, std::size_t n) noexcept
+{
+  mutable_registered_buffer tmp(b);
+  tmp += n;
+  return tmp;
+}
+
+/// Create a new modifiable buffer that is offset from the start of another.
+/**
+ * @relates mutable_registered_buffer
+ */
+inline mutable_registered_buffer operator+(std::size_t n,
+    const mutable_registered_buffer& b) noexcept
+{
+  return b + n;
+}
+
+/// Create a new non-modifiable registered buffer that is offset from the start
+/// of another.
+/**
+ * @relates const_registered_buffer
+ */
+inline const_registered_buffer operator+(const const_registered_buffer& b,
+    std::size_t n) noexcept
+{
+  const_registered_buffer tmp(b);
+  tmp += n;
+  return tmp;
+}
+
+/// Create a new non-modifiable buffer that is offset from the start of another.
+/**
+ * @relates const_registered_buffer
+ */
+inline const_registered_buffer operator+(std::size_t n,
+    const const_registered_buffer& b) noexcept
+{
+  return b + n;
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_REGISTERED_BUFFER_HPP