2011-05-28 Jonathan Wakely <jwakely.gcc@gmail.com>

	* include/std/future (launch): Update enumerators and define
	operators required for bitmask type. Remove trailing whitespace.
	* src/future.cc: Remove trailing whitespace.
	* testsuite/30_threads/async/any.cc: Adjust.
	* testsuite/30_threads/async/sync.cc: Adjust.
	* testsuite/30_threads/async/launch.cc: New.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@174374 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 57 insertions, 28 deletions

diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future
index 479904c5cf9..2b3e982200d 100644
--- a/libstdc++-v3/include/std/future
+++ b/libstdc++-v3/include/std/future
@@ -75,12 +75,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   future_category() noexcept;
 
   /// Overload for make_error_code.
-  inline error_code 
+  inline error_code
   make_error_code(future_errc __errc) noexcept
   { return error_code(static_cast<int>(__errc), future_category()); }
 
   /// Overload for make_error_condition.
-  inline error_condition 
+  inline error_condition
   make_error_condition(future_errc __errc) noexcept
   { return error_condition(static_cast<int>(__errc), future_category()); }
 
@@ -99,10 +99,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     virtual ~future_error() noexcept;
 
-    virtual const char* 
+    virtual const char*
     what() const noexcept;
 
-    const error_code& 
+    const error_code&
     code() const noexcept { return _M_code; }
   };
 
@@ -116,22 +116,51 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Res>
     class atomic_future;
 
-  template<typename _Signature> 
+  template<typename _Signature>
     class packaged_task;
 
   template<typename _Res>
     class promise;
 
   /// Launch code for futures
-  enum class launch 
-  { 
-    any, 
-    async, 
-    sync 
+  enum class launch
+  {
+    async = 1,
+    deferred = 2
   };
 
+  inline constexpr launch operator&(launch __x, launch __y)
+  {
+    return static_cast<launch>(
+	static_cast<int>(__x) & static_cast<int>(__y));
+  }
+
+  inline constexpr launch operator|(launch __x, launch __y)
+  {
+    return static_cast<launch>(
+	static_cast<int>(__x) | static_cast<int>(__y));
+  }
+
+  inline constexpr launch operator^(launch __x, launch __y)
+  {
+    return static_cast<launch>(
+	static_cast<int>(__x) ^ static_cast<int>(__y));
+  }
+
+  inline constexpr launch operator~(launch __x)
+  { return static_cast<launch>(~static_cast<int>(__x)); }
+
+  inline launch& operator&=(launch& __x, launch __y)
+  { return __x = __x & __y; }
+
+  inline launch& operator|=(launch& __x, launch __y)
+  { return __x = __x | __y; }
+
+  inline launch& operator^=(launch& __x, launch __y)
+  { return __x = __x ^ __y; }
+
   /// Status code for futures
-  enum class future_status 
+  enum class future_status
   {
     ready,
     timeout,
@@ -206,7 +235,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
 
 	// Return lvalue, future will add const or rvalue-reference
-	_Res& 
+	_Res&
 	_M_value() noexcept { return *static_cast<_Res*>(_M_addr()); }
 
 	void
@@ -484,7 +513,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     private:
       _Res* 			_M_value_ptr;
-      
+
       void _M_destroy() { delete this; }
     };
 
@@ -513,10 +542,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       __basic_future(const __basic_future&) = delete;
       __basic_future& operator=(const __basic_future&) = delete;
 
-      bool 
+      bool
       valid() const noexcept { return static_cast<bool>(_M_state); }
 
-      void 
+      void
       wait() const
       {
         _State_base::_S_check(_M_state);
@@ -629,7 +658,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       shared_future<_Res> share();
     };
- 
+
   /// Partial specialization for future<R&>
   template<typename _Res>
     class future<_Res&> : public __basic_future<_Res&>
@@ -663,7 +692,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
       /// Retrieving the value
-      _Res& 
+      _Res&
       get()
       {
         typename _Base_type::_Reset __reset(*this);
@@ -706,7 +735,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
       /// Retrieving the value
-      void 
+      void
       get()
       {
         typename _Base_type::_Reset __reset(*this);
@@ -760,7 +789,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	return __rs;
       }
     };
- 
+
   /// Partial specialization for shared_future<R&>
   template<typename _Res>
     class shared_future<_Res&> : public __basic_future<_Res&>
@@ -796,7 +825,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
       /// Retrieving the value
-      _Res& 
+      _Res&
       get() { return this->_M_get_result()._M_get(); }
     };
 
@@ -835,7 +864,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
       // Retrieving the value
-      void 
+      void
       get() { this->_M_get_result(); }
     };
 
@@ -880,7 +909,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef __future_base::_Result<_Res>			_Res_type;
       typedef typename __future_base::_Ptr<_Res_type>::type	_Ptr_type;
       template<typename, typename> friend class _State::_Setter;
-      
+
       shared_ptr<_State>                        _M_future;
       _Ptr_type                                 _M_storage;
 
@@ -983,7 +1012,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { }
 
       promise(promise&& __rhs) noexcept
-      : _M_future(std::move(__rhs._M_future)), 
+      : _M_future(std::move(__rhs._M_future)),
 	_M_storage(std::move(__rhs._M_storage))
       { }
 
@@ -1175,7 +1204,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     };
 
   template<typename _Res, typename... _Args>
-    struct __future_base::_Task_state<_Res(_Args...)> 
+    struct __future_base::_Task_state<_Res(_Args...)>
     : __future_base::_State_base
     {
       typedef _Res _Res_type;
@@ -1334,7 +1363,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     public:
       typedef _Res _Res_type;
 
-      explicit 
+      explicit
       _Async_state(std::function<_Res()>&& __fn)
       : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)),
 	_M_thread(mem_fn(&_Async_state::_M_do_run), this)
@@ -1356,14 +1385,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       thread _M_thread;
     };
 
-  /// async 
+  /// async
   template<typename _Fn, typename... _Args>
     future<typename result_of<_Fn(_Args...)>::type>
     async(launch __policy, _Fn&& __fn, _Args&&... __args)
     {
       typedef typename result_of<_Fn(_Args...)>::type result_type;
       std::shared_ptr<__future_base::_State_base> __state;
-      if (__policy == launch::async)
+      if ((__policy & (launch::async|launch::deferred)) == launch::async)
 	{
 	  typedef typename __future_base::_Async_state<result_type> _State;
 	  __state = std::make_shared<_State>(std::bind<result_type>(
@@ -1384,7 +1413,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     __async_sfinae_helper<typename decay<_Fn>::type, _Fn, _Args...>::type
     async(_Fn&& __fn, _Args&&... __args)
     {
-      return async(launch::any, std::forward<_Fn>(__fn),
+      return async(launch::async|launch::deferred, std::forward<_Fn>(__fn),
 		   std::forward<_Args>(__args)...);
     }