comparison DEPENDENCIES/generic/include/boost/asio/impl/spawn.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 //
 // impl/spawn.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2015 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)
 //
 

 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/atomic_count.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/shared_ptr.hpp>

   public:
     coro_handler(basic_yield_context<Handler> ctx)
       : coro_(ctx.coro_.lock()),
         ca_(ctx.ca_),
         handler_(ctx.handler_),
+        ready_(0),
         ec_(ctx.ec_),
         value_(0)
     {
     }
 
     void operator()(T value)
     {
       *ec_ = boost::system::error_code();
-      *value_ = value;
-      (*coro_)();
+      *value_ = BOOST_ASIO_MOVE_CAST(T)(value);
+      if (--*ready_ == 0)
+        (*coro_)();
     }
 
     void operator()(boost::system::error_code ec, T value)
     {
       *ec_ = ec;
-      *value_ = value;
-      (*coro_)();
+      *value_ = BOOST_ASIO_MOVE_CAST(T)(value);
+      if (--*ready_ == 0)
+        (*coro_)();
     }
 
   //private:
     shared_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
     typename basic_yield_context<Handler>::caller_type& ca_;
     Handler& handler_;
+    atomic_count* ready_;
     boost::system::error_code* ec_;
     T* value_;
   };
 
   template <typename Handler>

   public:
     coro_handler(basic_yield_context<Handler> ctx)
       : coro_(ctx.coro_.lock()),
         ca_(ctx.ca_),
         handler_(ctx.handler_),
+        ready_(0),
         ec_(ctx.ec_)
     {
     }
 
     void operator()()
     {
       *ec_ = boost::system::error_code();
-      (*coro_)();
+      if (--*ready_ == 0)
+        (*coro_)();
     }
 
     void operator()(boost::system::error_code ec)
     {
       *ec_ = ec;
-      (*coro_)();
+      if (--*ready_ == 0)
+        (*coro_)();
     }
 
   //private:
     shared_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
     typename basic_yield_context<Handler>::caller_type& ca_;
     Handler& handler_;
+    atomic_count* ready_;
     boost::system::error_code* ec_;
   };
 
   template <typename Handler, typename T>
   inline void* asio_handler_allocate(std::size_t size,

 {
 public:
   typedef T type;
 
   explicit async_result(detail::coro_handler<Handler, T>& h)
-    : ca_(h.ca_)
-  {
+    : handler_(h),
+      ca_(h.ca_),
+      ready_(2)
+  {
+    h.ready_ = &ready_;
     out_ec_ = h.ec_;
     if (!out_ec_) h.ec_ = &ec_;
     h.value_ = &value_;
   }
 
   type get()
   {
-    ca_();
+    handler_.coro_.reset(); // Must not hold shared_ptr to coro while suspended.
+    if (--ready_ != 0)
+      ca_();
     if (!out_ec_ && ec_) throw boost::system::system_error(ec_);
-    return value_;
+    return BOOST_ASIO_MOVE_CAST(type)(value_);
   }
 
 private:
+  detail::coro_handler<Handler, T>& handler_;
   typename basic_yield_context<Handler>::caller_type& ca_;
+  detail::atomic_count ready_;
   boost::system::error_code* out_ec_;
   boost::system::error_code ec_;
   type value_;
 };
 

 {
 public:
   typedef void type;
 
   explicit async_result(detail::coro_handler<Handler, void>& h)
-    : ca_(h.ca_)
-  {
+    : handler_(h),
+      ca_(h.ca_),
+      ready_(2)
+  {
+    h.ready_ = &ready_;
     out_ec_ = h.ec_;
     if (!out_ec_) h.ec_ = &ec_;
   }
 
   void get()
   {
-    ca_();
+    handler_.coro_.reset(); // Must not hold shared_ptr to coro while suspended.
+    if (--ready_ != 0)
+      ca_();
     if (!out_ec_ && ec_) throw boost::system::system_error(ec_);
   }
 
 private:
+  detail::coro_handler<Handler, void>& handler_;
   typename basic_yield_context<Handler>::caller_type& ca_;
+  detail::atomic_count ready_;
   boost::system::error_code* out_ec_;
   boost::system::error_code ec_;
 };
 
 namespace detail {

   struct coro_entry_point
   {
     void operator()(typename basic_yield_context<Handler>::caller_type& ca)
     {
       shared_ptr<spawn_data<Handler, Function> > data(data_);
+#if !defined(BOOST_COROUTINES_UNIDIRECT) && !defined(BOOST_COROUTINES_V2)
       ca(); // Yield until coroutine pointer has been initialised.
+#endif // !defined(BOOST_COROUTINES_UNIDIRECT) && !defined(BOOST_COROUTINES_V2)
       const basic_yield_context<Handler> yield(
           data->coro_, ca, data->handler_);
       (data->function_)(yield);
       if (data->call_handler_)
         (data->handler_)();