[thread] Harmonize presentation of synopses and declarations

Author: tkoeppe

source/threads.tex

@@ -333,7 +333,7 @@
   public:
     // types:
     class id;
-    using native_handle_type = @\impdef@; // See~\ref{thread.req.native}
+    using native_handle_type = @\impdefnc@;         // see~\ref{thread.req.native}
 
     // construct/copy/destroy:
     thread() noexcept;
@@ -350,10 +350,10 @@
     void join();
     void detach();
     id get_id() const noexcept;
-    native_handle_type native_handle(); // See~\ref{thread.req.native}
+    native_handle_type native_handle();                         // see~\ref{thread.req.native}
 
     // static members:
-    static unsigned hardware_concurrency() noexcept;
+    static unsigned int hardware_concurrency() noexcept;
   };
 }
 \end{codeblock}
@@ -366,7 +366,7 @@
 namespace std {
   class thread::id {
   public:
-      id() noexcept;
+    id() noexcept;
   };
 
   bool operator==(thread::id x, thread::id y) noexcept;
@@ -378,7 +378,7 @@
 
   template<class charT, class traits>
     basic_ostream<charT, traits>&
-      operator<< (basic_ostream<charT, traits>& out, thread::id id);
+      operator<<(basic_ostream<charT, traits>& out, thread::id id);
 
   // Hash support
   template <class T> struct hash;
@@ -1036,8 +1036,8 @@
     bool try_lock();
     void unlock();
 
-    using native_handle_type = @\impdefnc@; // See~\ref{thread.req.native}
-    native_handle_type native_handle();                // See~\ref{thread.req.native}
+    using native_handle_type = @\impdefnc@;          // see~\ref{thread.req.native}
+    native_handle_type native_handle();                         // see~\ref{thread.req.native}
   };
 }
 \end{codeblock}
@@ -1091,8 +1091,8 @@
     bool try_lock() noexcept;
     void unlock();
 
-    using native_handle_type = @\impdefnc@; // See~\ref{thread.req.native}
-    native_handle_type native_handle();                // See~\ref{thread.req.native}
+    using native_handle_type = @\impdefnc@;          // see~\ref{thread.req.native}
+    native_handle_type native_handle();                         // see~\ref{thread.req.native}
   };
 }
 \end{codeblock}
@@ -1223,16 +1223,16 @@
     timed_mutex(const timed_mutex&) = delete;
     timed_mutex& operator=(const timed_mutex&) = delete;
 
-    void lock();  // blocking
+    void lock();    // blocking
     bool try_lock();
     template <class Rep, class Period>
       bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
     template <class Clock, class Duration>
       bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
     void unlock();
 
-    using native_handle_type = @\impdefnc@; // See~\ref{thread.req.native}
-    native_handle_type native_handle();                // See~\ref{thread.req.native}
+    using native_handle_type = @\impdefnc@;          // see~\ref{thread.req.native}
+    native_handle_type native_handle();                         // see~\ref{thread.req.native}
   };
 }
 \end{codeblock}
@@ -1274,16 +1274,16 @@
     recursive_timed_mutex(const recursive_timed_mutex&) = delete;
     recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
 
-    void lock();  // blocking
+    void lock();    // blocking
     bool try_lock() noexcept;
     template <class Rep, class Period>
       bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
     template <class Clock, class Duration>
       bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
     void unlock();
 
-    using native_handle_type = @\impdefnc@; // See~\ref{thread.req.native}
-    native_handle_type native_handle();                // See~\ref{thread.req.native}
+    using native_handle_type = @\impdefnc@;          // see~\ref{thread.req.native}
+    native_handle_type native_handle();                         // see~\ref{thread.req.native}
   };
 }
 \end{codeblock}
@@ -1444,7 +1444,7 @@
     shared_mutex& operator=(const shared_mutex&) = delete;
 
     // Exclusive ownership
-    void lock(); // blocking
+    void lock();    // blocking
     bool try_lock();
     void unlock();
 
@@ -1453,8 +1453,8 @@
     bool try_lock_shared();
     void unlock_shared();
 
-    using native_handle_type = @\impdefnc@; // See~\ref{thread.req.native}
-    native_handle_type native_handle();                // See~\ref{thread.req.native}
+    using native_handle_type = @\impdefnc@;          // see~\ref{thread.req.native}
+    native_handle_type native_handle();                         // see~\ref{thread.req.native}
   };
 }
 \end{codeblock}
@@ -1579,7 +1579,7 @@
     shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
 
     // Exclusive ownership
-    void lock();  // blocking
+    void lock();                // blocking
     bool try_lock();
     template <class Rep, class Period>
       bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
@@ -1588,14 +1588,12 @@
     void unlock();
 
     // Shared ownership
-    void lock_shared();  // blocking
+    void lock_shared();         // blocking
     bool try_lock_shared();
     template <class Rep, class Period>
-      bool
-      try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
+      bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
     template <class Clock, class Duration>
-      bool
-      try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
+      bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
     void unlock_shared();
   };
 }
@@ -1671,7 +1669,7 @@
     lock_guard& operator=(const lock_guard&) = delete;
 
   private:
-    mutex_type& pm; // \expos
+    mutex_type& pm;             // \expos
   };
 
   template<class Mutex> lock_guard(lock_guard<Mutex>) -> lock_guard<Mutex>;
@@ -1739,7 +1737,7 @@
   template <class... MutexTypes>
   class scoped_lock {
   public:
-    using mutex_type = Mutex;  // If \tcode{MutexTypes...} consists of the single type \tcode{Mutex}
+    using mutex_type = Mutex;   // If \tcode{MutexTypes...} consists of the single type \tcode{Mutex}
 
     explicit scoped_lock(MutexTypes&... m);
     explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
@@ -1749,7 +1747,7 @@
     scoped_lock& operator=(const scoped_lock&) = delete;
 
   private:
-    tuple<MutexTypes&...> pm; // \expos
+    tuple<MutexTypes&...> pm;   // \expos
   };
 
   template<class... MutexTypes>
@@ -1863,8 +1861,8 @@
     mutex_type* mutex() const noexcept;
 
   private:
-    mutex_type* pm; // \expos
-    bool owns;      // \expos
+    mutex_type* pm;             // \expos
+    bool owns;                  // \expos
   };
 
   template<class Mutex> unique_lock(unique_lock<Mutex>) -> unique_lock<Mutex>;
@@ -2271,16 +2269,14 @@
 
     // \ref{thread.lock.shared.cons}, construct/copy/destroy
     shared_lock() noexcept;
-    explicit shared_lock(mutex_type& m);  // blocking
+    explicit shared_lock(mutex_type& m);        // blocking
     shared_lock(mutex_type& m, defer_lock_t) noexcept;
     shared_lock(mutex_type& m, try_to_lock_t);
     shared_lock(mutex_type& m, adopt_lock_t);
     template <class Clock, class Duration>
-      shared_lock(mutex_type& m,
-                  const chrono::time_point<Clock, Duration>& abs_time);
+      shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
     template <class Rep, class Period>
-      shared_lock(mutex_type& m,
-                const chrono::duration<Rep, Period>& rel_time);
+      shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
     ~shared_lock();
 
     shared_lock(const shared_lock&) = delete;
@@ -2290,7 +2286,7 @@
     shared_lock& operator=(shared_lock&& u) noexcept;
 
     // \ref{thread.lock.shared.locking}, locking
-    void lock();  // blocking
+    void lock();                                // blocking
     bool try_lock();
     template <class Rep, class Period>
       bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
@@ -2308,8 +2304,8 @@
     mutex_type* mutex() const noexcept;
 
   private:
-    mutex_type* pm; // \expos
-    bool owns;      // \expos
+    mutex_type* pm;                             // \expos
+    bool owns;                                  // \expos
   };
 
   template<class Mutex> shared_lock(shared_lock<Mutex>) -> shared_lock<Mutex>;
@@ -2551,8 +2547,7 @@
 \indexlibrarymember{try_lock_until}{shared_lock}%
 \begin{itemdecl}
 template <class Clock, class Duration>
-  bool
-  try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
+  bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2963,7 +2958,6 @@
 namespace std {
   class condition_variable {
   public:
-
     condition_variable();
     ~condition_variable();
 
@@ -2982,7 +2976,6 @@
       bool wait_until(unique_lock<mutex>& lock,
                       const chrono::time_point<Clock, Duration>& abs_time,
                       Predicate pred);
-
     template <class Rep, class Period>
       cv_status wait_for(unique_lock<mutex>& lock,
                          const chrono::duration<Rep, Period>& rel_time);
@@ -2991,8 +2984,8 @@
                     const chrono::duration<Rep, Period>& rel_time,
                     Predicate pred);
 
-    using native_handle_type = @\impdefnc@; // See~\ref{thread.req.native}
-    native_handle_type native_handle();                // See~\ref{thread.req.native}
+    using native_handle_type = @\impdefnc@;          // see~\ref{thread.req.native}
+    native_handle_type native_handle();                         // see~\ref{thread.req.native}
   };
 }
 \end{codeblock}
@@ -3371,12 +3364,11 @@
       cv_status wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time);
     template <class Lock, class Clock, class Duration, class Predicate>
       bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time,
-        Predicate pred);
+                      Predicate pred);
     template <class Lock, class Rep, class Period>
       cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
     template <class Lock, class Rep, class Period, class Predicate>
-      bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time,
-        Predicate pred);
+      bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
   };
 }
 \end{codeblock}
@@ -3751,8 +3743,9 @@
 
     const error_code& code() const noexcept;
     const char*       what() const noexcept;
+
   private:
-    error_code ec_;  // \expos
+    error_code ec_;             // \expos
   };
 }
 \end{codeblock}
@@ -3931,8 +3924,10 @@
     void set_value_at_thread_exit(@\seebelow@);
     void set_exception_at_thread_exit(exception_ptr p);
   };
+
   template <class R>
     void swap(promise<R>& x, promise<R>& y) noexcept;
+
   template <class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
 }
@@ -5010,8 +5005,10 @@
 
     void reset();
   };
+
   template <class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
+
   template <class R, class Alloc>
     struct uses_allocator<packaged_task<R>, Alloc>;
 }