couchbase 3.0.0.alpha.3 → 3.0.1

data/ext/third_party/asio/asio/include/asio/detail/memory.hpp

@@ -19,6 +19,7 @@
 #include <memory>
 
 #if !defined(ASIO_HAS_STD_SHARED_PTR)
+# include <boost/make_shared.hpp>
 # include <boost/shared_ptr.hpp>
 # include <boost/weak_ptr.hpp>
 #endif // !defined(ASIO_HAS_STD_SHARED_PTR)
@@ -31,9 +32,11 @@ namespace asio {
 namespace detail {
 
 #if defined(ASIO_HAS_STD_SHARED_PTR)
+using std::make_shared;
 using std::shared_ptr;
 using std::weak_ptr;
 #else // defined(ASIO_HAS_STD_SHARED_PTR)
+using boost::make_shared;
 using boost::shared_ptr;
 using boost::weak_ptr;
 #endif // defined(ASIO_HAS_STD_SHARED_PTR)

data/ext/third_party/asio/asio/include/asio/detail/null_event.hpp

@@ -55,6 +55,12 @@ public:
   {
   }
 
+  // Unlock the mutex and signal one waiter who may destroy us.
+  template <typename Lock>
+  void unlock_and_signal_one_for_destruction(Lock&)
+  {
+  }
+
   // If there's a waiter, unlock the mutex and signal it.
   template <typename Lock>
   bool maybe_unlock_and_signal_one(Lock&)

data/ext/third_party/asio/asio/include/asio/detail/pop_options.hpp

@@ -93,7 +93,7 @@
 
 // Greenhills C++
 
-#elif defined(__BORLANDC__)
+#elif defined(__BORLANDC__) && !defined(__clang__)
 
 // Borland C++
 

data/ext/third_party/asio/asio/include/asio/detail/posix_event.hpp

@@ -19,6 +19,7 @@
 
 #if defined(ASIO_HAS_PTHREADS)
 
+#include <cstddef>
 #include <pthread.h>
 #include "asio/detail/assert.hpp"
 #include "asio/detail/noncopyable.hpp"
@@ -70,6 +71,18 @@ public:
       ::pthread_cond_signal(&cond_); // Ignore EINVAL.
   }
 
+  // Unlock the mutex and signal one waiter who may destroy us.
+  template <typename Lock>
+  void unlock_and_signal_one_for_destruction(Lock& lock)
+  {
+    ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    bool have_waiters = (state_ > 1);
+    if (have_waiters)
+      ::pthread_cond_signal(&cond_); // Ignore EINVAL.
+    lock.unlock();
+  }
+
   // If there's a waiter, unlock the mutex and signal it.
   template <typename Lock>
   bool maybe_unlock_and_signal_one(Lock& lock)

data/ext/third_party/asio/asio/include/asio/detail/push_options.hpp

@@ -102,7 +102,7 @@
 
 // Greenhills C++
 
-#elif defined(__BORLANDC__)
+#elif defined(__BORLANDC__) && !defined(__clang__)
 
 // Borland C++
 

data/ext/third_party/asio/asio/include/asio/detail/reactive_descriptor_service.hpp

@@ -201,7 +201,7 @@ public:
     typedef reactive_wait_op<Handler, IoExecutor> op;
     typename op::ptr p = { asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(handler, io_ex);
+    p.p = new (p.v) op(success_ec_, handler, io_ex);
 
     ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
           &impl, impl.descriptor_, "async_wait"));
@@ -234,11 +234,22 @@ public:
   size_t write_some(implementation_type& impl,
       const ConstBufferSequence& buffers, asio::error_code& ec)
   {
-    buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs(buffers);
+    typedef buffer_sequence_adapter<asio::const_buffer,
+        ConstBufferSequence> bufs_type;
 
-    return descriptor_ops::sync_write(impl.descriptor_, impl.state_,
-        bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
+    if (bufs_type::is_single_buffer)
+    {
+      return descriptor_ops::sync_write1(impl.descriptor_,
+          impl.state_, bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+
+      return descriptor_ops::sync_write(impl.descriptor_, impl.state_,
+          bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
+    }
   }
 
   // Wait until data can be written without blocking.
@@ -265,7 +276,7 @@ public:
     typedef descriptor_write_op<ConstBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.descriptor_, buffers, handler, io_ex);
+    p.p = new (p.v) op(success_ec_, impl.descriptor_, buffers, handler, io_ex);
 
     ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
           &impl, impl.descriptor_, "async_write_some"));
@@ -288,7 +299,7 @@ public:
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(handler, io_ex);
+    p.p = new (p.v) op(success_ec_, handler, io_ex);
 
     ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
           &impl, impl.descriptor_, "async_write_some(null_buffers)"));
@@ -302,11 +313,22 @@ public:
   size_t read_some(implementation_type& impl,
       const MutableBufferSequence& buffers, asio::error_code& ec)
   {
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
+    typedef buffer_sequence_adapter<asio::mutable_buffer,
+        MutableBufferSequence> bufs_type;
 
-    return descriptor_ops::sync_read(impl.descriptor_, impl.state_,
-        bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
+    if (bufs_type::is_single_buffer)
+    {
+      return descriptor_ops::sync_read1(impl.descriptor_,
+          impl.state_, bufs_type::first(buffers).data(),
+          bufs_type::first(buffers).size(), ec);
+    }
+    else
+    {
+      bufs_type bufs(buffers);
+
+      return descriptor_ops::sync_read(impl.descriptor_, impl.state_,
+          bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
+    }
   }
 
   // Wait until data can be read without blocking.
@@ -334,7 +356,7 @@ public:
     typedef descriptor_read_op<MutableBufferSequence, Handler, IoExecutor> op;
     typename op::ptr p = { asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.descriptor_, buffers, handler, io_ex);
+    p.p = new (p.v) op(success_ec_, impl.descriptor_, buffers, handler, io_ex);
 
     ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
           &impl, impl.descriptor_, "async_read_some"));
@@ -357,7 +379,7 @@ public:
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(handler, io_ex);
+    p.p = new (p.v) op(success_ec_, handler, io_ex);
 
     ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
           &impl, impl.descriptor_, "async_read_some(null_buffers)"));
@@ -373,6 +395,9 @@ private:
 
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
+
+  // Cached success value to avoid accessing category singleton.
+  const asio::error_code success_ec_;
 };
 
 } // namespace detail

data/ext/third_party/asio/asio/include/asio/detail/reactive_null_buffers_op.hpp

@@ -16,9 +16,11 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/detail/bind_handler.hpp"
 #include "asio/detail/fenced_block.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/handler_work.hpp"
 #include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 
@@ -33,13 +35,13 @@ class reactive_null_buffers_op : public reactor_op
 public:
   ASIO_DEFINE_HANDLER_PTR(reactive_null_buffers_op);
 
-  reactive_null_buffers_op(Handler& handler, const IoExecutor& io_ex)
-    : reactor_op(&reactive_null_buffers_op::do_perform,
+  reactive_null_buffers_op(const asio::error_code& success_ec,
+      Handler& handler, const IoExecutor& io_ex)
+    : reactor_op(success_ec, &reactive_null_buffers_op::do_perform,
         &reactive_null_buffers_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static status do_perform(reactor_op*)
@@ -54,10 +56,14 @@ public:
     // Take ownership of the handler object.
     reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
-    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);
 
     ASIO_HANDLER_COMPLETION((*o));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -81,7 +87,7 @@ public:
 
 private:
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 } // namespace detail

data/ext/third_party/asio/asio/include/asio/detail/reactive_serial_port_service.hpp

@@ -139,9 +139,8 @@ public:
   asio::error_code send_break(implementation_type& impl,
       asio::error_code& ec)
   {
-    errno = 0;
-    descriptor_ops::error_wrapper(::tcsendbreak(
-          descriptor_service_.native_handle(impl), 0), ec);
+    int result = ::tcsendbreak(descriptor_service_.native_handle(impl), 0);
+    descriptor_ops::get_last_error(ec, result < 0);
     return ec;
   }
 

data/ext/third_party/asio/asio/include/asio/detail/reactive_socket_accept_op.hpp

@@ -17,8 +17,10 @@
 
 #include "asio/detail/config.hpp"
 #include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/handler_work.hpp"
 #include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_holder.hpp"
@@ -33,10 +35,12 @@ template <typename Socket, typename Protocol>
 class reactive_socket_accept_op_base : public reactor_op
 {
 public:
-  reactive_socket_accept_op_base(socket_type socket,
-      socket_ops::state_type state, Socket& peer, const Protocol& protocol,
-      typename Protocol::endpoint* peer_endpoint, func_type complete_func)
-    : reactor_op(&reactive_socket_accept_op_base::do_perform, complete_func),
+  reactive_socket_accept_op_base(const asio::error_code& success_ec,
+      socket_type socket, socket_ops::state_type state, Socket& peer,
+      const Protocol& protocol, typename Protocol::endpoint* peer_endpoint,
+      func_type complete_func)
+    : reactor_op(success_ec,
+        &reactive_socket_accept_op_base::do_perform, complete_func),
       socket_(socket),
       state_(state),
       peer_(peer),
@@ -93,16 +97,16 @@ class reactive_socket_accept_op :
 public:
   ASIO_DEFINE_HANDLER_PTR(reactive_socket_accept_op);
 
-  reactive_socket_accept_op(socket_type socket,
-      socket_ops::state_type state, Socket& peer, const Protocol& protocol,
-      typename Protocol::endpoint* peer_endpoint, Handler& handler,
-      const IoExecutor& io_ex)
-    : reactive_socket_accept_op_base<Socket, Protocol>(socket, state, peer,
-        protocol, peer_endpoint, &reactive_socket_accept_op::do_complete),
+  reactive_socket_accept_op(const asio::error_code& success_ec,
+      socket_type socket, socket_ops::state_type state, Socket& peer,
+      const Protocol& protocol, typename Protocol::endpoint* peer_endpoint,
+      Handler& handler, const IoExecutor& io_ex)
+    : reactive_socket_accept_op_base<Socket, Protocol>(
+        success_ec, socket, state, peer, protocol, peer_endpoint,
+        &reactive_socket_accept_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -112,7 +116,6 @@ public:
     // Take ownership of the handler object.
     reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
-    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);
 
     // On success, assign new connection to peer socket object.
     if (owner)
@@ -120,6 +123,11 @@ public:
 
     ASIO_HANDLER_COMPLETION((*o));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -143,7 +151,7 @@ public:
 
 private:
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 #if defined(ASIO_HAS_MOVE)
@@ -159,18 +167,18 @@ class reactive_socket_move_accept_op :
 public:
   ASIO_DEFINE_HANDLER_PTR(reactive_socket_move_accept_op);
 
-  reactive_socket_move_accept_op(const PeerIoExecutor& peer_io_ex,
-      socket_type socket, socket_ops::state_type state,
-      const Protocol& protocol, typename Protocol::endpoint* peer_endpoint,
-      Handler& handler, const IoExecutor& io_ex)
+  reactive_socket_move_accept_op(const asio::error_code& success_ec,
+      const PeerIoExecutor& peer_io_ex, socket_type socket,
+      socket_ops::state_type state, const Protocol& protocol,
+      typename Protocol::endpoint* peer_endpoint, Handler& handler,
+      const IoExecutor& io_ex)
     : peer_socket_type(peer_io_ex),
       reactive_socket_accept_op_base<peer_socket_type, Protocol>(
-        socket, state, *this, protocol, peer_endpoint,
+        success_ec, socket, state, *this, protocol, peer_endpoint,
         &reactive_socket_move_accept_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -181,7 +189,6 @@ public:
     reactive_socket_move_accept_op* o(
         static_cast<reactive_socket_move_accept_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
-    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);
 
     // On success, assign new connection to peer socket object.
     if (owner)
@@ -189,6 +196,11 @@ public:
 
     ASIO_HANDLER_COMPLETION((*o));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -217,7 +229,7 @@ private:
     rebind_executor<PeerIoExecutor>::other peer_socket_type;
 
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 #endif // defined(ASIO_HAS_MOVE)

data/ext/third_party/asio/asio/include/asio/detail/reactive_socket_connect_op.hpp

@@ -17,8 +17,10 @@
 
 #include "asio/detail/config.hpp"
 #include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
 #include "asio/detail/fenced_block.hpp"
+#include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+#include "asio/detail/handler_work.hpp"
 #include "asio/detail/memory.hpp"
 #include "asio/detail/reactor_op.hpp"
 #include "asio/detail/socket_ops.hpp"
@@ -31,8 +33,10 @@ namespace detail {
 class reactive_socket_connect_op_base : public reactor_op
 {
 public:
-  reactive_socket_connect_op_base(socket_type socket, func_type complete_func)
-    : reactor_op(&reactive_socket_connect_op_base::do_perform, complete_func),
+  reactive_socket_connect_op_base(const asio::error_code& success_ec,
+      socket_type socket, func_type complete_func)
+    : reactor_op(success_ec,
+        &reactive_socket_connect_op_base::do_perform, complete_func),
       socket_(socket)
   {
   }
@@ -60,14 +64,13 @@ class reactive_socket_connect_op : public reactive_socket_connect_op_base
 public:
   ASIO_DEFINE_HANDLER_PTR(reactive_socket_connect_op);
 
-  reactive_socket_connect_op(socket_type socket,
-      Handler& handler, const IoExecutor& io_ex)
-    : reactive_socket_connect_op_base(socket,
+  reactive_socket_connect_op(const asio::error_code& success_ec,
+      socket_type socket, Handler& handler, const IoExecutor& io_ex)
+    : reactive_socket_connect_op_base(success_ec, socket,
         &reactive_socket_connect_op::do_complete),
       handler_(ASIO_MOVE_CAST(Handler)(handler)),
-      io_executor_(io_ex)
+      work_(handler_, io_ex)
   {
-    handler_work<Handler, IoExecutor>::start(handler_, io_executor_);
   }
 
   static void do_complete(void* owner, operation* base,
@@ -78,10 +81,14 @@ public:
     reactive_socket_connect_op* o
       (static_cast<reactive_socket_connect_op*>(base));
     ptr p = { asio::detail::addressof(o->handler_), o, o };
-    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);
 
     ASIO_HANDLER_COMPLETION((*o));
 
+    // Take ownership of the operation's outstanding work.
+    handler_work<Handler, IoExecutor> w(
+        ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
+          o->work_));
+
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
@@ -105,7 +112,7 @@ public:
 
 private:
   Handler handler_;
-  IoExecutor io_executor_;
+  handler_work<Handler, IoExecutor> work_;
 };
 
 } // namespace detail