Ticket #8212: 8212.patch

File 8212.patch, 8.8 KB (added by viboes, 10 years ago)

Could you try this additional patch?

  • ../example/make_future.cpp

     
    1010
    1111int p1() { return 5; }
    1212
     13void p() { }
     14
     15#if defined BOOST_THREAD_USES_MOVE
     16boost::future<void> void_compute()
     17{
     18  return BOOST_THREAD_MAKE_RV_REF(boost::make_future());
     19}
     20#endif
     21
    1322boost::future<int> compute(int x)
    1423{
    1524  if (x == 0) return boost::make_future(0);
    … …  
    3039
    3140int main()
    3241{
     42#if defined BOOST_THREAD_USES_MOVE
    3343  {
     44    boost::future<void> f = void_compute();
     45    f.get();
     46  }
     47#endif
     48  {
    3449    boost::future<int> f = compute(2);
    3550    std::cout << f.get() << std::endl;
    3651  }
    3752  {
     53    boost::future<int> f = compute(0);
     54    std::cout << f.get() << std::endl;
     55  }
     56  {
    3857    boost::shared_future<int> f = shared_compute(2);
    3958    std::cout << f.get() << std::endl;
    4059  }

  • ../../../boost/thread/future.hpp

     
    16771677                boost::throw_exception(future_already_retrieved());
    16781678            }
    16791679            future_obtained=true;
    1680             return BOOST_THREAD_FUTURE<R>(future_);
     1680            return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<R>(future_));
    16811681        }
    16821682
    16831683        void set_value(typename detail::future_traits<R>::source_reference_type r)
    … …  
    18441844                boost::throw_exception(future_already_retrieved());
    18451845            }
    18461846            future_obtained=true;
    1847             return BOOST_THREAD_FUTURE<R&>(future_);
     1847            return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<R&>(future_));
    18481848        }
    18491849
    18501850        void set_value(R& r)
    … …  
    19901990            }
    19911991            future_obtained=true;
    19921992            return BOOST_THREAD_FUTURE<void>(future_);
     1993            //return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<void>(future_));
     1994            //BOOST_THREAD_FUTURE<void> res;
     1995            //return boost::move(res);
    19931996        }
    19941997
    19951998        void set_value()
    … …  
    29392942            {
    29402943                future_obtained=true;
    29412944                //return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<R>(task));
    2942                 return BOOST_THREAD_FUTURE<R>(task);
     2945                return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<R>(task));
    29432946            }
    29442947            else
    29452948            {
    … …  
    31393142        if (int(policy) & int(launch::async))
    31403143        {
    31413144#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
    3142           return boost::detail::make_future_async_object<Rp>(
     3145          return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_async_object<Rp>(
    31433146              BF(
    31443147                  thread_detail::decay_copy(boost::forward<F>(f))
    31453148                  , thread_detail::decay_copy(boost::forward<ArgTypes>(args))...
    31463149              )
    3147           );
     3150          ));
    31483151#else
    31493152          packaged_task_type pt( boost::forward<F>(f) );
    31503153
    … …  
    31603163        else if (int(policy) & int(launch::deferred))
    31613164        {
    31623165#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
    3163           return boost::detail::make_future_deferred_object<Rp>(
     3166          return BOOST_THREAD_MAKE_RV_REF(boost::detail::make_future_deferred_object<Rp>(
    31643167              BF(
    31653168                  thread_detail::decay_copy(boost::forward<F>(f))
    31663169                  , thread_detail::decay_copy(boost::forward<ArgTypes>(args))...
    31673170              )
    3168           );
     3171          ));
    31693172#else
    31703173              BOOST_THREAD_FUTURE<R> ret;
    31713174              return ::boost::move(ret);
    … …  
    31943197        BOOST_THREAD_FUTURE<R>
    31953198        async(R(*f)(BOOST_THREAD_FWD_REF(ArgTypes)...), BOOST_THREAD_FWD_REF(ArgTypes)... args)
    31963199        {
    3197           return async(launch(launch::any), f, boost::forward<ArgTypes>(args)...);
     3200          return BOOST_THREAD_MAKE_RV_REF(async(launch(launch::any), f, boost::forward<ArgTypes>(args)...));
    31983201        }
    31993202#else
    32003203        template <class R>
    32013204        BOOST_THREAD_FUTURE<R>
    32023205        async(R(*f)())
    32033206        {
    3204           return async(launch(launch::any), f);
     3207          return BOOST_THREAD_MAKE_RV_REF(async(launch(launch::any), f));
    32053208        }
    32063209#endif
    32073210#endif
    … …  
    32133216        )>::type>
    32143217        async(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(ArgTypes)... args)
    32153218        {
    3216             return async(launch(launch::any), boost::forward<F>(f), boost::forward<ArgTypes>(args)...);
     3219            return BOOST_THREAD_MAKE_RV_REF(async(launch(launch::any), boost::forward<F>(f), boost::forward<ArgTypes>(args)...));
    32173220        }
    32183221#else
    32193222        template <class F>
    32203223        BOOST_THREAD_FUTURE<typename boost::result_of<F()>::type>
    32213224        async(BOOST_THREAD_RV_REF(F) f)
    32223225        {
    3223             return async(launch(launch::any), boost::forward<F>(f));
     3226            return BOOST_THREAD_MAKE_RV_REF(async(launch(launch::any), boost::forward<F>(f)));
    32243227        }
    32253228#endif
    32263229
    … …  
    32373240    return BOOST_THREAD_MAKE_RV_REF(p.get_future());
    32383241  }
    32393242
    3240 
     3243#if defined BOOST_THREAD_USES_MOVE
    32413244  inline BOOST_THREAD_FUTURE<void> make_future()
    32423245  {
    32433246    promise<void> p;
    3244     return p.get_future();
    3245 
     3247    p.set_value();
     3248    return BOOST_THREAD_MAKE_RV_REF(p.get_future());
    32463249  }
     3250#endif
    32473251
    32483252  ////////////////////////////////
    32493253  // make_shared_future
    … …  
    33973401          new detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, F>(*this, boost::forward<F>(func), policy);
    33983402      if (ptr==0)
    33993403      {
    3400         return BOOST_THREAD_FUTURE<future_type>();
     3404        return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<future_type>());
    34013405      }
    34023406      this->future_->set_continuation_ptr(ptr, lock);
    3403       return ptr->next.get_future();
     3407      return BOOST_THREAD_MAKE_RV_REF(ptr->next.get_future());
    34043408    }
    34053409    else
    34063410    {
    … …  
    34213425    {
    34223426      boost::unique_lock<boost::mutex> lock(this->future_->mutex);
    34233427      detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, F > *ptr =
    3424           new detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, F>(*this, boost::forward<F>(func));
     3428          new
     3429          //BOOST_THREAD_MAKE_RV_REF((
     3430              detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, F>(*this, boost::forward<F>(func))
     3431              //))
     3432              ;
    34253433      if (ptr==0)
    34263434      {
    3427         return BOOST_THREAD_FUTURE<future_type>();
     3435        return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<future_type>());
    34283436      }
    34293437      this->future_->set_continuation_ptr(ptr, lock);
    34303438      return ptr->next.get_future();
    34313439    } else {
    34323440      // fixme what to do when the future has no associated state?
    3433       return BOOST_THREAD_FUTURE<future_type>();
     3441      return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<future_type>());
    34343442    }
    34353443
    34363444  }
    … …  
    34473455    {
    34483456      boost::unique_lock<boost::mutex> lock(this->future_->mutex);
    34493457      detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, RF(*)(BOOST_THREAD_FUTURE&) > *ptr =
    3450           new detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, RF(*)(BOOST_THREAD_FUTURE&)>(*this, func);
     3458          new
     3459          //BOOST_THREAD_MAKE_RV_REF((
     3460              detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, RF(*)(BOOST_THREAD_FUTURE&)>(*this, func)
     3461           //   ))
     3462      ;
    34513463      if (ptr==0)
    34523464      {
    3453         return BOOST_THREAD_FUTURE<future_type>();
     3465        return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<future_type>());
    34543466      }
    34553467      this->future_->set_continuation_ptr(ptr, lock);
    34563468      return ptr->next.get_future();
    34573469    } else {
    34583470      // fixme what to do when the future has no associated state?
    3459       return BOOST_THREAD_FUTURE<future_type>();
     3471      return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<future_type>());
    34603472    }
    34613473
    34623474  }
    … …  
    34723484    {
    34733485      boost::unique_lock<boost::mutex> lock(this->future_->mutex);
    34743486      detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, RF(*)(BOOST_THREAD_FUTURE&) > *ptr =
    3475           new detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, RF(*)(BOOST_THREAD_FUTURE&)>(*this, func, policy);
     3487          new
     3488          //BOOST_THREAD_MAKE_RV_REF((
     3489              detail::future_continuation<BOOST_THREAD_FUTURE<R>, future_type, RF(*)(BOOST_THREAD_FUTURE&)>(*this, func, policy)
     3490            //  ))
     3491      ;
    34763492      if (ptr==0)
    34773493      {
    3478         return BOOST_THREAD_FUTURE<future_type>();
     3494        return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<future_type>());
    34793495      }
    34803496      this->future_->set_continuation_ptr(ptr, lock);
    34813497      return ptr->next.get_future();
    34823498    } else {
    34833499      // fixme what to do when the future has no associated state?
    3484       return BOOST_THREAD_FUTURE<future_type>();
     3500      return BOOST_THREAD_MAKE_RV_REF(BOOST_THREAD_FUTURE<future_type>());
    34853501    }
    34863502
    34873503  }