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

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