npm - couchbase - Versions diffs - 4.2.11 → 4.3.1 - Mend

couchbase 4.2.11 → 4.3.1

Files changed (1441) hide show

package/deps/couchbase-cxx-cache/asio/a1d8afc0fa0ccceae5729647623b3f7fd6859548/asio/asio/include/asio/detail/strand_executor_service.hpp DELETED Viewed

@@ -1,173 +0,0 @@
-//
-// detail/strand_executor_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2023 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_STRAND_EXECUTOR_SERVICE_HPP
-#define ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_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/atomic_count.hpp"
-#include "asio/detail/executor_op.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/scheduler_operation.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/push_options.hpp"
-namespace asio {
-namespace detail {
-// Default service implementation for a strand.
-class strand_executor_service
-  : public execution_context_service_base<strand_executor_service>
-{
-public:
-  // The underlying implementation of a strand.
-  class strand_impl
-  {
-  public:
-    ASIO_DECL ~strand_impl();
-  private:
-    friend class strand_executor_service;
-    // Mutex to protect access to internal data.
-    mutex* mutex_;
-    // Indicates whether the strand is currently "locked" by a handler. This
-    // means that there is a handler upcall in progress, or that the strand
-    // itself has been scheduled in order to invoke some pending handlers.
-    bool locked_;
-    // Indicates that the strand has been shut down and will accept no further
-    // handlers.
-    bool shutdown_;
-    // The handlers that are waiting on the strand but should not be run until
-    // after the next time the strand is scheduled. This queue must only be
-    // modified while the mutex is locked.
-    op_queue<scheduler_operation> waiting_queue_;
-    // The handlers that are ready to be run. Logically speaking, these are the
-    // handlers that hold the strand's lock. The ready queue is only modified
-    // from within the strand and so may be accessed without locking the mutex.
-    op_queue<scheduler_operation> ready_queue_;
-    // Pointers to adjacent handle implementations in linked list.
-    strand_impl* next_;
-    strand_impl* prev_;
-    // The strand service in where the implementation is held.
-    strand_executor_service* service_;
-  };
-  typedef shared_ptr<strand_impl> implementation_type;
-  // Construct a new strand service for the specified context.
-  ASIO_DECL explicit strand_executor_service(execution_context& context);
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-  // Create a new strand_executor implementation.
-  ASIO_DECL implementation_type create_implementation();
-  // Request invocation of the given function.
-  template <typename Executor, typename Function>
-  static void execute(const implementation_type& impl, Executor& ex,
-      ASIO_MOVE_ARG(Function) function,
-      typename enable_if<
-        can_query<Executor, execution::allocator_t<void> >::value
-      >::type* = 0);
-  // Request invocation of the given function.
-  template <typename Executor, typename Function>
-  static void execute(const implementation_type& impl, Executor& ex,
-      ASIO_MOVE_ARG(Function) function,
-      typename enable_if<
-        !can_query<Executor, execution::allocator_t<void> >::value
-      >::type* = 0);
-  // Request invocation of the given function.
-  template <typename Executor, typename Function, typename Allocator>
-  static void dispatch(const implementation_type& impl, Executor& ex,
-      ASIO_MOVE_ARG(Function) function, const Allocator& a);
-  // Request invocation of the given function and return immediately.
-  template <typename Executor, typename Function, typename Allocator>
-  static void post(const implementation_type& impl, Executor& ex,
-      ASIO_MOVE_ARG(Function) function, const Allocator& a);
-  // Request invocation of the given function and return immediately.
-  template <typename Executor, typename Function, typename Allocator>
-  static void defer(const implementation_type& impl, Executor& ex,
-      ASIO_MOVE_ARG(Function) function, const Allocator& a);
-  // Determine whether the strand is running in the current thread.
-  ASIO_DECL static bool running_in_this_thread(
-      const implementation_type& impl);
-private:
-  friend class strand_impl;
-  template <typename F, typename Allocator> class allocator_binder;
-  template <typename Executor, typename = void> class invoker;
-  // Adds a function to the strand. Returns true if it acquires the lock.
-  ASIO_DECL static bool enqueue(const implementation_type& impl,
-      scheduler_operation* op);
-  // Transfers waiting handlers to the ready queue. Returns true if one or more
-  // handlers were transferred.
-  ASIO_DECL static bool push_waiting_to_ready(implementation_type& impl);
-  // Invokes all ready-to-run handlers.
-  ASIO_DECL static void run_ready_handlers(implementation_type& impl);
-  // Helper function to request invocation of the given function.
-  template <typename Executor, typename Function, typename Allocator>
-  static void do_execute(const implementation_type& impl, Executor& ex,
-      ASIO_MOVE_ARG(Function) function, const Allocator& a);
-  // Mutex to protect access to the service-wide state.
-  mutex mutex_;
-  // Number of mutexes shared between all strand objects.
-  enum { num_mutexes = 193 };
-  // Pool of mutexes.
-  scoped_ptr<mutex> mutexes_[num_mutexes];
-  // Extra value used when hashing to prevent recycled memory locations from
-  // getting the same mutex.
-  std::size_t salt_;
-  // The head of a linked list of all implementations.
-  strand_impl* impl_list_;
-};
-} // namespace detail
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#include "asio/detail/impl/strand_executor_service.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/strand_executor_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-#endif // ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_HPP

package/deps/couchbase-cxx-cache/asio/a1d8afc0fa0ccceae5729647623b3f7fd6859548/asio/asio/include/asio/detail/thread.hpp DELETED Viewed

@@ -1,60 +0,0 @@
-//
-// detail/thread.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2023 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_THREAD_HPP
-#define ASIO_DETAIL_THREAD_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_THREADS)
-# include "asio/detail/null_thread.hpp"
-#elif defined(ASIO_HAS_PTHREADS)
-# include "asio/detail/posix_thread.hpp"
-#elif defined(ASIO_WINDOWS)
-# if defined(UNDER_CE)
-#  include "asio/detail/wince_thread.hpp"
-# elif defined(ASIO_WINDOWS_APP)
-#  include "asio/detail/winapp_thread.hpp"
-# else
-#  include "asio/detail/win_thread.hpp"
-# endif
-#elif defined(ASIO_HAS_STD_THREAD)
-# include "asio/detail/std_thread.hpp"
-#else
-# error Only Windows, POSIX and std::thread are supported!
-#endif
-namespace asio {
-namespace detail {
-#if !defined(ASIO_HAS_THREADS)
-typedef null_thread thread;
-#elif defined(ASIO_HAS_PTHREADS)
-typedef posix_thread thread;
-#elif defined(ASIO_WINDOWS)
-# if defined(UNDER_CE)
-typedef wince_thread thread;
-# elif defined(ASIO_WINDOWS_APP)
-typedef winapp_thread thread;
-# else
-typedef win_thread thread;
-# endif
-#elif defined(ASIO_HAS_STD_THREAD)
-typedef std_thread thread;
-#endif
-} // namespace detail
-} // namespace asio
-#endif // ASIO_DETAIL_THREAD_HPP

package/deps/couchbase-cxx-cache/asio/a1d8afc0fa0ccceae5729647623b3f7fd6859548/asio/asio/include/asio/detail/thread_info_base.hpp DELETED Viewed

@@ -1,260 +0,0 @@
-//
-// detail/thread_info_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2023 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_THREAD_INFO_BASE_HPP
-#define ASIO_DETAIL_THREAD_INFO_BASE_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include "asio/detail/config.hpp"
-#include <climits>
-#include <cstddef>
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(ASIO_NO_EXCEPTIONS)
-# include <exception>
-# include "asio/multiple_exceptions.hpp"
-#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
-       // && !defined(ASIO_NO_EXCEPTIONS)
-#include "asio/detail/push_options.hpp"
-namespace asio {
-namespace detail {
-#ifndef ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE
-# define ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE 2
-#endif // ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE
-class thread_info_base
-  : private noncopyable
-{
-public:
-  struct default_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = 0,
-      end_mem_index = cache_size
-    };
-  };
-  struct awaitable_frame_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = default_tag::end_mem_index,
-      end_mem_index = begin_mem_index + cache_size
-    };
-  };
-  struct executor_function_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = awaitable_frame_tag::end_mem_index,
-      end_mem_index = begin_mem_index + cache_size
-    };
-  };
-  struct cancellation_signal_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = executor_function_tag::end_mem_index,
-      end_mem_index = begin_mem_index + cache_size
-    };
-  };
-  struct parallel_group_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = cancellation_signal_tag::end_mem_index,
-      end_mem_index = begin_mem_index + cache_size
-    };
-  };
-  enum { max_mem_index = parallel_group_tag::end_mem_index };
-  thread_info_base()
-#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(ASIO_NO_EXCEPTIONS)
-    : has_pending_exception_(0)
-#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
-       // && !defined(ASIO_NO_EXCEPTIONS)
-  {
-    for (int i = 0; i < max_mem_index; ++i)
-      reusable_memory_[i] = 0;
-  }
-  ~thread_info_base()
-  {
-    for (int i = 0; i < max_mem_index; ++i)
-    {
-      // The following test for non-null pointers is technically redundant, but
-      // it is significantly faster when using a tight io_context::poll() loop
-      // in latency sensitive applications.
-      if (reusable_memory_[i])
-        aligned_delete(reusable_memory_[i]);
-    }
-  }
-  static void* allocate(thread_info_base* this_thread,
-      std::size_t size, std::size_t align = ASIO_DEFAULT_ALIGN)
-  {
-    return allocate(default_tag(), this_thread, size, align);
-  }
-  static void deallocate(thread_info_base* this_thread,
-      void* pointer, std::size_t size)
-  {
-    deallocate(default_tag(), this_thread, pointer, size);
-  }
-  template <typename Purpose>
-  static void* allocate(Purpose, thread_info_base* this_thread,
-      std::size_t size, std::size_t align = ASIO_DEFAULT_ALIGN)
-  {
-    std::size_t chunks = (size + chunk_size - 1) / chunk_size;
-    if (this_thread)
-    {
-      for (int mem_index = Purpose::begin_mem_index;
-          mem_index < Purpose::end_mem_index; ++mem_index)
-      {
-        if (this_thread->reusable_memory_[mem_index])
-        {
-          void* const pointer = this_thread->reusable_memory_[mem_index];
-          unsigned char* const mem = static_cast<unsigned char*>(pointer);
-          if (static_cast<std::size_t>(mem[0]) >= chunks
-              && reinterpret_cast<std::size_t>(pointer) % align == 0)
-          {
-            this_thread->reusable_memory_[mem_index] = 0;
-            mem[size] = mem[0];
-            return pointer;
-          }
-        }
-      }
-      for (int mem_index = Purpose::begin_mem_index;
-          mem_index < Purpose::end_mem_index; ++mem_index)
-      {
-        if (this_thread->reusable_memory_[mem_index])
-        {
-          void* const pointer = this_thread->reusable_memory_[mem_index];
-          this_thread->reusable_memory_[mem_index] = 0;
-          aligned_delete(pointer);
-          break;
-        }
-      }
-    }
-    void* const pointer = aligned_new(align, chunks * chunk_size + 1);
-    unsigned char* const mem = static_cast<unsigned char*>(pointer);
-    mem[size] = (chunks <= UCHAR_MAX) ? static_cast<unsigned char>(chunks) : 0;
-    return pointer;
-  }
-  template <typename Purpose>
-  static void deallocate(Purpose, thread_info_base* this_thread,
-      void* pointer, std::size_t size)
-  {
-    if (size <= chunk_size * UCHAR_MAX)
-    {
-      if (this_thread)
-      {
-        for (int mem_index = Purpose::begin_mem_index;
-            mem_index < Purpose::end_mem_index; ++mem_index)
-        {
-          if (this_thread->reusable_memory_[mem_index] == 0)
-          {
-            unsigned char* const mem = static_cast<unsigned char*>(pointer);
-            mem[0] = mem[size];
-            this_thread->reusable_memory_[mem_index] = pointer;
-            return;
-          }
-        }
-      }
-    }
-    aligned_delete(pointer);
-  }
-  void capture_current_exception()
-  {
-#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(ASIO_NO_EXCEPTIONS)
-    switch (has_pending_exception_)
-    {
-    case 0:
-      has_pending_exception_ = 1;
-      pending_exception_ = std::current_exception();
-      break;
-    case 1:
-      has_pending_exception_ = 2;
-      pending_exception_ =
-        std::make_exception_ptr<multiple_exceptions>(
-            multiple_exceptions(pending_exception_));
-      break;
-    default:
-      break;
-    }
-#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
-       // && !defined(ASIO_NO_EXCEPTIONS)
-  }
-  void rethrow_pending_exception()
-  {
-#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(ASIO_NO_EXCEPTIONS)
-    if (has_pending_exception_ > 0)
-    {
-      has_pending_exception_ = 0;
-      std::exception_ptr ex(
-          ASIO_MOVE_CAST(std::exception_ptr)(
-            pending_exception_));
-      std::rethrow_exception(ex);
-    }
-#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
-       // && !defined(ASIO_NO_EXCEPTIONS)
-  }
-private:
-#if defined(ASIO_HAS_IO_URING)
-  enum { chunk_size = 8 };
-#else // defined(ASIO_HAS_IO_URING)
-  enum { chunk_size = 4 };
-#endif // defined(ASIO_HAS_IO_URING)
-  void* reusable_memory_[max_mem_index];
-#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(ASIO_NO_EXCEPTIONS)
-  int has_pending_exception_;
-  std::exception_ptr pending_exception_;
-#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
-       // && !defined(ASIO_NO_EXCEPTIONS)
-};
-} // namespace detail
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#endif // ASIO_DETAIL_THREAD_INFO_BASE_HPP

package/deps/couchbase-cxx-cache/asio/a1d8afc0fa0ccceae5729647623b3f7fd6859548/asio/asio/include/asio/detail/timer_queue_ptime.hpp DELETED Viewed

@@ -1,103 +0,0 @@
-//
-// detail/timer_queue_ptime.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2023 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_TIMER_QUEUE_PTIME_HPP
-#define ASIO_DETAIL_TIMER_QUEUE_PTIME_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_BOOST_DATE_TIME)
-#include "asio/time_traits.hpp"
-#include "asio/detail/timer_queue.hpp"
-#include "asio/detail/push_options.hpp"
-namespace asio {
-namespace detail {
-struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
-// Template specialisation for the commonly used instantation.
-template <>
-class timer_queue<time_traits<boost::posix_time::ptime> >
-  : public timer_queue_base
-{
-public:
-  // The time type.
-  typedef boost::posix_time::ptime time_type;
-  // The duration type.
-  typedef boost::posix_time::time_duration duration_type;
-  // Per-timer data.
-  typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
-    per_timer_data;
-  // Constructor.
-  ASIO_DECL timer_queue();
-  // Destructor.
-  ASIO_DECL virtual ~timer_queue();
-  // Add a new timer to the queue. Returns true if this is the timer that is
-  // earliest in the queue, in which case the reactor's event demultiplexing
-  // function call may need to be interrupted and restarted.
-  ASIO_DECL bool enqueue_timer(const time_type& time,
-      per_timer_data& timer, wait_op* op);
-  // Whether there are no timers in the queue.
-  ASIO_DECL virtual bool empty() const;
-  // Get the time for the timer that is earliest in the queue.
-  ASIO_DECL virtual long wait_duration_msec(long max_duration) const;
-  // Get the time for the timer that is earliest in the queue.
-  ASIO_DECL virtual long wait_duration_usec(long max_duration) const;
-  // Dequeue all timers not later than the current time.
-  ASIO_DECL virtual void get_ready_timers(op_queue<operation>& ops);
-  // Dequeue all timers.
-  ASIO_DECL virtual void get_all_timers(op_queue<operation>& ops);
-  // Cancel and dequeue operations for the given timer.
-  ASIO_DECL std::size_t cancel_timer(
-      per_timer_data& timer, op_queue<operation>& ops,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-  // Cancel and dequeue operations for the given timer and key.
-  ASIO_DECL void cancel_timer_by_key(per_timer_data* timer,
-      op_queue<operation>& ops, void* cancellation_key);
-  // Move operations from one timer to another, empty timer.
-  ASIO_DECL void move_timer(per_timer_data& target,
-      per_timer_data& source);
-private:
-  timer_queue<forwarding_posix_time_traits> impl_;
-};
-} // namespace detail
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/timer_queue_ptime.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-#endif // ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP