RubyGems - couchbase - Versions diffs - 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19 - Mend

couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1318) hide show

data/ext/third_party/asio/asio/include/asio/detail/handler_work.hpp DELETED

@@ -1,438 +0,0 @@
-//
-// detail/handler_work.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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_DETAIL_HANDLER_WORK_HPP
-#define ASIO_DETAIL_HANDLER_WORK_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include "asio/detail/config.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/allocator.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/execute.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution/outstanding_work.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/prefer.hpp"
-#include "asio/detail/push_options.hpp"
-namespace asio {
-class executor;
-class io_context;
-namespace execution {
-#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
-template <typename...> class any_executor;
-#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
-template <typename, typename, typename, typename, typename,
-    typename, typename, typename, typename> class any_executor;
-#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
-} // namespace execution
-namespace detail {
-template <typename Executor, typename CandidateExecutor = void,
-    typename IoContext = io_context,
-    typename PolymorphicExecutor = executor, typename = void>
-class handler_work_base
-{
-public:
-  explicit handler_work_base(const Executor& ex) ASIO_NOEXCEPT
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-  template <typename OtherExecutor>
-  handler_work_base(const Executor& ex,
-      const OtherExecutor&) ASIO_NOEXCEPT
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-  handler_work_base(const handler_work_base& other) ASIO_NOEXCEPT
-    : executor_(other.executor_)
-  {
-  }
-#if defined(ASIO_HAS_MOVE)
-  handler_work_base(handler_work_base&& other) ASIO_NOEXCEPT
-    : executor_(ASIO_MOVE_CAST(executor_type)(other.executor_))
-  {
-  }
-#endif // defined(ASIO_HAS_MOVE)
-  bool owns_work() const ASIO_NOEXCEPT
-  {
-    return true;
-  }
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    execution::execute(
-        asio::prefer(executor_,
-          execution::blocking.possibly,
-          execution::allocator((get_associated_allocator)(handler))),
-        ASIO_MOVE_CAST(Function)(function));
-  }
-private:
-  typedef typename decay<
-      typename prefer_result<Executor,
-        execution::outstanding_work_t::tracked_t
-      >::type
-    >::type executor_type;
-  executor_type executor_;
-};
-template <typename Executor, typename CandidateExecutor,
-    typename IoContext, typename PolymorphicExecutor>
-class handler_work_base<Executor, CandidateExecutor,
-    IoContext, PolymorphicExecutor,
-    typename enable_if<
-      !execution::is_executor<Executor>::value
-        && (!is_same<Executor, PolymorphicExecutor>::value
-          || !is_same<CandidateExecutor, void>::value)
-    >::type>
-{
-public:
-  explicit handler_work_base(const Executor& ex) ASIO_NOEXCEPT
-    : executor_(ex),
-      owns_work_(true)
-  {
-    executor_.on_work_started();
-  }
-  handler_work_base(const Executor& ex,
-      const Executor& candidate) ASIO_NOEXCEPT
-    : executor_(ex),
-      owns_work_(ex != candidate)
-  {
-    if (owns_work_)
-      executor_.on_work_started();
-  }
-  template <typename OtherExecutor>
-  handler_work_base(const Executor& ex,
-      const OtherExecutor&) ASIO_NOEXCEPT
-    : executor_(ex),
-      owns_work_(true)
-  {
-    executor_.on_work_started();
-  }
-  handler_work_base(const handler_work_base& other) ASIO_NOEXCEPT
-    : executor_(other.executor_),
-      owns_work_(other.owns_work_)
-  {
-    if (owns_work_)
-      executor_.on_work_started();
-  }
-#if defined(ASIO_HAS_MOVE)
-  handler_work_base(handler_work_base&& other) ASIO_NOEXCEPT
-    : executor_(ASIO_MOVE_CAST(Executor)(other.executor_)),
-      owns_work_(other.owns_work_)
-  {
-    other.owns_work_ = false;
-  }
-#endif // defined(ASIO_HAS_MOVE)
-  ~handler_work_base()
-  {
-    if (owns_work_)
-      executor_.on_work_finished();
-  }
-  bool owns_work() const ASIO_NOEXCEPT
-  {
-    return owns_work_;
-  }
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    executor_.dispatch(ASIO_MOVE_CAST(Function)(function),
-        asio::get_associated_allocator(handler));
-  }
-private:
-  Executor executor_;
-  bool owns_work_;
-};
-template <typename Executor, typename IoContext, typename PolymorphicExecutor>
-class handler_work_base<Executor, void, IoContext, PolymorphicExecutor,
-    typename enable_if<
-      is_same<
-        Executor,
-        typename IoContext::executor_type
-      >::value
-    >::type>
-{
-public:
-  explicit handler_work_base(const Executor&)
-  {
-  }
-  bool owns_work() const ASIO_NOEXCEPT
-  {
-    return false;
-  }
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    // When using a native implementation, I/O completion handlers are
-    // already dispatched according to the execution context's executor's
-    // rules. We can call the function directly.
-    asio_handler_invoke_helpers::invoke(function, handler);
-  }
-};
-template <typename Executor, typename IoContext>
-class handler_work_base<Executor, void, IoContext, Executor>
-{
-public:
-  explicit handler_work_base(const Executor& ex) ASIO_NOEXCEPT
-#if !defined(ASIO_NO_TYPEID)
-    : executor_(
-        ex.target_type() == typeid(typename IoContext::executor_type)
-          ? Executor() : ex)
-#else // !defined(ASIO_NO_TYPEID)
-    : executor_(ex)
-#endif // !defined(ASIO_NO_TYPEID)
-  {
-    if (executor_)
-      executor_.on_work_started();
-  }
-  handler_work_base(const Executor& ex,
-      const Executor& candidate) ASIO_NOEXCEPT
-    : executor_(ex != candidate ? ex : Executor())
-  {
-    if (executor_)
-      executor_.on_work_started();
-  }
-  template <typename OtherExecutor>
-  handler_work_base(const Executor& ex,
-      const OtherExecutor&) ASIO_NOEXCEPT
-    : executor_(ex)
-  {
-    executor_.on_work_started();
-  }
-  handler_work_base(const handler_work_base& other) ASIO_NOEXCEPT
-    : executor_(other.executor_)
-  {
-    if (executor_)
-      executor_.on_work_started();
-  }
-#if defined(ASIO_HAS_MOVE)
-  handler_work_base(handler_work_base&& other) ASIO_NOEXCEPT
-    : executor_(ASIO_MOVE_CAST(Executor)(other.executor_))
-  {
-  }
-#endif // defined(ASIO_HAS_MOVE)
-  ~handler_work_base()
-  {
-    if (executor_)
-      executor_.on_work_finished();
-  }
-  bool owns_work() const ASIO_NOEXCEPT
-  {
-    return !!executor_;
-  }
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    executor_.dispatch(ASIO_MOVE_CAST(Function)(function),
-        asio::get_associated_allocator(handler));
-  }
-private:
-  Executor executor_;
-};
-template <
-#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
-    typename... SupportableProperties,
-#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
-    typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9,
-#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
-    typename IoContext, typename PolymorphicExecutor>
-class handler_work_base<
-#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
-    execution::any_executor<SupportableProperties...>,
-#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
-    execution::any_executor<T1, T2, T3, T4, T5, T6, T7, T8, T9>,
-#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
-    void, IoContext, PolymorphicExecutor>
-{
-public:
-  typedef
-#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
-    execution::any_executor<SupportableProperties...>
-#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
-    execution::any_executor<T1, T2, T3, T4, T5, T6, T7, T8, T9>
-#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
-    executor_type;
-  explicit handler_work_base(const executor_type& ex) ASIO_NOEXCEPT
-#if !defined(ASIO_NO_TYPEID)
-    : executor_(
-        ex.target_type() == typeid(typename IoContext::executor_type)
-          ? executor_type()
-          : asio::prefer(ex, execution::outstanding_work.tracked))
-#else // !defined(ASIO_NO_TYPEID)
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-#endif // !defined(ASIO_NO_TYPEID)
-  {
-  }
-  handler_work_base(const executor_type& ex,
-      const executor_type& candidate) ASIO_NOEXCEPT
-    : executor_(ex != candidate ? ex : executor_type())
-  {
-  }
-  template <typename OtherExecutor>
-  handler_work_base(const executor_type& ex,
-      const OtherExecutor&) ASIO_NOEXCEPT
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-  handler_work_base(const handler_work_base& other) ASIO_NOEXCEPT
-    : executor_(other.executor_)
-  {
-  }
-#if defined(ASIO_HAS_MOVE)
-  handler_work_base(handler_work_base&& other) ASIO_NOEXCEPT
-    : executor_(ASIO_MOVE_CAST(executor_type)(other.executor_))
-  {
-  }
-#endif // defined(ASIO_HAS_MOVE)
-  bool owns_work() const ASIO_NOEXCEPT
-  {
-    return !!executor_;
-  }
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    execution::execute(
-        asio::prefer(executor_,
-          execution::blocking.possibly,
-          execution::allocator((get_associated_allocator)(handler))),
-        ASIO_MOVE_CAST(Function)(function));
-  }
-private:
-  executor_type executor_;
-};
-template <typename Handler, typename IoExecutor, typename = void>
-class handler_work :
-  handler_work_base<IoExecutor>,
-  handler_work_base<typename associated_executor<
-      Handler, IoExecutor>::type, IoExecutor>
-{
-public:
-  typedef handler_work_base<IoExecutor> base1_type;
-  typedef handler_work_base<typename associated_executor<
-    Handler, IoExecutor>::type, IoExecutor> base2_type;
-  handler_work(Handler& handler, const IoExecutor& io_ex) ASIO_NOEXCEPT
-    : base1_type(io_ex),
-      base2_type(asio::get_associated_executor(handler, io_ex), io_ex)
-  {
-  }
-  template <typename Function>
-  void complete(Function& function, Handler& handler)
-  {
-    if (!base1_type::owns_work() && !base2_type::owns_work())
-    {
-      // When using a native implementation, I/O completion handlers are
-      // already dispatched according to the execution context's executor's
-      // rules. We can call the function directly.
-      asio_handler_invoke_helpers::invoke(function, handler);
-    }
-    else
-    {
-      base2_type::dispatch(function, handler);
-    }
-  }
-};
-template <typename Handler, typename IoExecutor>
-class handler_work<
-    Handler, IoExecutor,
-    typename enable_if<
-      is_same<
-        typename associated_executor<Handler,
-          IoExecutor>::asio_associated_executor_is_unspecialised,
-        void
-      >::value
-    >::type> : handler_work_base<IoExecutor>
-{
-public:
-  typedef handler_work_base<IoExecutor> base1_type;
-  handler_work(Handler&, const IoExecutor& io_ex) ASIO_NOEXCEPT
-    : base1_type(io_ex)
-  {
-  }
-  template <typename Function>
-  void complete(Function& function, Handler& handler)
-  {
-    if (!base1_type::owns_work())
-    {
-      // When using a native implementation, I/O completion handlers are
-      // already dispatched according to the execution context's executor's
-      // rules. We can call the function directly.
-      asio_handler_invoke_helpers::invoke(function, handler);
-    }
-    else
-    {
-      base1_type::dispatch(function, handler);
-    }
-  }
-};
-} // namespace detail
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#endif // ASIO_DETAIL_HANDLER_WORK_HPP

data/ext/third_party/asio/asio/include/asio/detail/hash_map.hpp DELETED

@@ -1,331 +0,0 @@
-//
-// detail/hash_map.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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_DETAIL_HASH_MAP_HPP
-#define ASIO_DETAIL_HASH_MAP_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include "asio/detail/config.hpp"
-#include <list>
-#include <utility>
-#include "asio/detail/assert.hpp"
-#include "asio/detail/noncopyable.hpp"
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# include "asio/detail/socket_types.hpp"
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#include "asio/detail/push_options.hpp"
-namespace asio {
-namespace detail {
-inline std::size_t calculate_hash_value(int i)
-{
-  return static_cast<std::size_t>(i);
-}
-inline std::size_t calculate_hash_value(void* p)
-{
-  return reinterpret_cast<std::size_t>(p)
-    + (reinterpret_cast<std::size_t>(p) >> 3);
-}
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-inline std::size_t calculate_hash_value(SOCKET s)
-{
-  return static_cast<std::size_t>(s);
-}
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-// Note: assumes K and V are POD types.
-template <typename K, typename V>
-class hash_map
-  : private noncopyable
-{
-public:
-  // The type of a value in the map.
-  typedef std::pair<K, V> value_type;
-  // The type of a non-const iterator over the hash map.
-  typedef typename std::list<value_type>::iterator iterator;
-  // The type of a const iterator over the hash map.
-  typedef typename std::list<value_type>::const_iterator const_iterator;
-  // Constructor.
-  hash_map()
-    : size_(0),
-      buckets_(0),
-      num_buckets_(0)
-  {
-  }
-  // Destructor.
-  ~hash_map()
-  {
-    delete[] buckets_;
-  }
-  // Get an iterator for the beginning of the map.
-  iterator begin()
-  {
-    return values_.begin();
-  }
-  // Get an iterator for the beginning of the map.
-  const_iterator begin() const
-  {
-    return values_.begin();
-  }
-  // Get an iterator for the end of the map.
-  iterator end()
-  {
-    return values_.end();
-  }
-  // Get an iterator for the end of the map.
-  const_iterator end() const
-  {
-    return values_.end();
-  }
-  // Check whether the map is empty.
-  bool empty() const
-  {
-    return values_.empty();
-  }
-  // Find an entry in the map.
-  iterator find(const K& k)
-  {
-    if (num_buckets_)
-    {
-      size_t bucket = calculate_hash_value(k) % num_buckets_;
-      iterator it = buckets_[bucket].first;
-      if (it == values_.end())
-        return values_.end();
-      iterator end_it = buckets_[bucket].last;
-      ++end_it;
-      while (it != end_it)
-      {
-        if (it->first == k)
-          return it;
-        ++it;
-      }
-    }
-    return values_.end();
-  }
-  // Find an entry in the map.
-  const_iterator find(const K& k) const
-  {
-    if (num_buckets_)
-    {
-      size_t bucket = calculate_hash_value(k) % num_buckets_;
-      const_iterator it = buckets_[bucket].first;
-      if (it == values_.end())
-        return it;
-      const_iterator end_it = buckets_[bucket].last;
-      ++end_it;
-      while (it != end_it)
-      {
-        if (it->first == k)
-          return it;
-        ++it;
-      }
-    }
-    return values_.end();
-  }
-  // Insert a new entry into the map.
-  std::pair<iterator, bool> insert(const value_type& v)
-  {
-    if (size_ + 1 >= num_buckets_)
-      rehash(hash_size(size_ + 1));
-    size_t bucket = calculate_hash_value(v.first) % num_buckets_;
-    iterator it = buckets_[bucket].first;
-    if (it == values_.end())
-    {
-      buckets_[bucket].first = buckets_[bucket].last =
-        values_insert(values_.end(), v);
-      ++size_;
-      return std::pair<iterator, bool>(buckets_[bucket].last, true);
-    }
-    iterator end_it = buckets_[bucket].last;
-    ++end_it;
-    while (it != end_it)
-    {
-      if (it->first == v.first)
-        return std::pair<iterator, bool>(it, false);
-      ++it;
-    }
-    buckets_[bucket].last = values_insert(end_it, v);
-    ++size_;
-    return std::pair<iterator, bool>(buckets_[bucket].last, true);
-  }
-  // Erase an entry from the map.
-  void erase(iterator it)
-  {
-    ASIO_ASSERT(it != values_.end());
-    ASIO_ASSERT(num_buckets_ != 0);
-    size_t bucket = calculate_hash_value(it->first) % num_buckets_;
-    bool is_first = (it == buckets_[bucket].first);
-    bool is_last = (it == buckets_[bucket].last);
-    if (is_first && is_last)
-      buckets_[bucket].first = buckets_[bucket].last = values_.end();
-    else if (is_first)
-      ++buckets_[bucket].first;
-    else if (is_last)
-      --buckets_[bucket].last;
-    values_erase(it);
-    --size_;
-  }
-  // Erase a key from the map.
-  void erase(const K& k)
-  {
-    iterator it = find(k);
-    if (it != values_.end())
-      erase(it);
-  }
-  // Remove all entries from the map.
-  void clear()
-  {
-    // Clear the values.
-    values_.clear();
-    size_ = 0;
-    // Initialise all buckets to empty.
-    iterator end_it = values_.end();
-    for (size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end_it;
-  }
-private:
-  // Calculate the hash size for the specified number of elements.
-  static std::size_t hash_size(std::size_t num_elems)
-  {
-    static std::size_t sizes[] =
-    {
-#if defined(ASIO_HASH_MAP_BUCKETS)
-      ASIO_HASH_MAP_BUCKETS
-#else // ASIO_HASH_MAP_BUCKETS
-      3, 13, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
-      49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
-      12582917, 25165843
-#endif // ASIO_HASH_MAP_BUCKETS
-    };
-    const std::size_t nth_size = sizeof(sizes) / sizeof(std::size_t) - 1;
-    for (std::size_t i = 0; i < nth_size; ++i)
-      if (num_elems < sizes[i])
-        return sizes[i];
-    return sizes[nth_size];
-  }
-  // Re-initialise the hash from the values already contained in the list.
-  void rehash(std::size_t num_buckets)
-  {
-    if (num_buckets == num_buckets_)
-      return;
-    ASIO_ASSERT(num_buckets != 0);
-    iterator end_iter = values_.end();
-    // Update number of buckets and initialise all buckets to empty.
-    bucket_type* tmp = new bucket_type[num_buckets];
-    delete[] buckets_;
-    buckets_ = tmp;
-    num_buckets_ = num_buckets;
-    for (std::size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end_iter;
-    // Put all values back into the hash.
-    iterator iter = values_.begin();
-    while (iter != end_iter)
-    {
-      std::size_t bucket = calculate_hash_value(iter->first) % num_buckets_;
-      if (buckets_[bucket].last == end_iter)
-      {
-        buckets_[bucket].first = buckets_[bucket].last = iter++;
-      }
-      else if (++buckets_[bucket].last == iter)
-      {
-        ++iter;
-      }
-      else
-      {
-        values_.splice(buckets_[bucket].last, values_, iter++);
-        --buckets_[bucket].last;
-      }
-    }
-  }
-  // Insert an element into the values list by splicing from the spares list,
-  // if a spare is available, and otherwise by inserting a new element.
-  iterator values_insert(iterator it, const value_type& v)
-  {
-    if (spares_.empty())
-    {
-      return values_.insert(it, v);
-    }
-    else
-    {
-      spares_.front() = v;
-      values_.splice(it, spares_, spares_.begin());
-      return --it;
-    }
-  }
-  // Erase an element from the values list by splicing it to the spares list.
-  void values_erase(iterator it)
-  {
-    *it = value_type();
-    spares_.splice(spares_.begin(), values_, it);
-  }
-  // The number of elements in the hash.
-  std::size_t size_;
-  // The list of all values in the hash map.
-  std::list<value_type> values_;
-  // The list of spare nodes waiting to be recycled. Assumes that POD types only
-  // are stored in the hash map.
-  std::list<value_type> spares_;
-  // The type for a bucket in the hash table.
-  struct bucket_type
-  {
-    iterator first;
-    iterator last;
-  };
-  // The buckets in the hash.
-  bucket_type* buckets_;
-  // The number of buckets in the hash.
-  std::size_t num_buckets_;
-};
-} // namespace detail
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#endif // ASIO_DETAIL_HASH_MAP_HPP