Boost-Commit :

Date view	Thread view	Subject view	Author view

From: Lawrence_at_[hidden]
Date: 2007-10-23 01:18:36

Author: crowl
Date: 2007-10-23 01:18:36 EDT (Tue, 23 Oct 2007)
New Revision: 40337
URL: http://svn.boost.org/trac/boost/changeset/40337

Log:
Insert blank lines between block-level elements,
which is handy with editors that understand paragraphs.
Remove some empty paragraphs.

Text files modified:
sandbox/committee/LWG/thread_library.html | 460 +++++++++++++++++++++++++++++++++++++--
1 files changed, 432 insertions(+), 28 deletions(-)

Modified: sandbox/committee/LWG/thread_library.html
==============================================================================
--- sandbox/committee/LWG/thread_library.html (original)
+++ sandbox/committee/LWG/thread_library.html 2007-10-23 01:18:36 EDT (Tue, 23 Oct 2007)
@@ -332,6 +332,7 @@
 operator<< (basic_ostream<charT, traits>&& out, const thread::id& id);

</code></pre>
+

Objects of type <code>thread::id</code> represent the identity of threads. Each
joinable thread has a unique identity. All non-joinable threads share the same
@@ -351,9 +352,11 @@

Effects: Constructs an object of type <code>id</code>.

+

Throws: Nothing.

+

Postcondition: Represents the non-joinable identity.

@@ -371,6 +374,7 @@
<code>x</code> and <code>y</code> represent the same identity,
returns <code>true</code>. Otherwise returns <code>false</code>.

+

Throws: Nothing.

@@ -386,13 +390,13 @@

Returns: <code>!(x == y)</code>

+

Throws: Nothing.

</blockquote>
</blockquote>

-
<blockquote>
<pre><code>
bool operator<(const thread::id& x, const thread::id& y);
@@ -402,6 +406,7 @@

Returns: a value such that <code>operator<</code> is a total ordering as described in [alg.sorting].

+

Throws: Nothing.

@@ -412,10 +417,12 @@
<pre><code>
bool operator<=(const thread::id& x, const thread::id& y);
</code></pre>
+
<blockquote>

Returns: <code>!(y < x)</code>

+

Throws: Nothing.

@@ -426,10 +433,12 @@
<pre><code>
bool operator>(const thread::id& x, const thread::id& y);
</code></pre>
+
<blockquote>

Returns: <code>y < x</code>

+

Throws: Nothing.

@@ -440,10 +449,12 @@
<pre><code>
bool operator>=(const thread::id& x, const thread::id& y);
</code></pre>
+
<blockquote>

Returns: <code>!(x < y)</code>

+

Throws: Nothing.

@@ -462,6 +473,7 @@
Effects: Inserts an unspecified text representation of the <code>thread::id</code> into
the stream <code>out</code>.

+

Returns: <code>out</code>.

@@ -474,24 +486,29 @@
<pre><code>
thread();
</code></pre>
+
<blockquote>

Effects: Constructs a <code>thread</code> object that does not represent an
actual thread.

+

Postconditions:

+
<blockquote>
<pre><code>
get_id() == thread::id()
&& joinable() == false
</code></pre>
+

[Note: This is also the state of a <code>thread</code>
object after <code>detach</code> or <code>join</code> is successfully called. -- end note]

</blockquote>
+

Throws: Nothing.

@@ -510,6 +527,7 @@
If <code>f</code> is an rvalue, <code>F</code> is <code>MoveConstructible</code>.
[Crowl: Is this enforced by code?]

+

Effects: Constructs an object of type <code>thread</code> and executes <code>INVOKE(f, t1, t2, ..., tN)</code>
in a new thread, where <code>t1, t2,
@@ -518,18 +536,22 @@
If <code>f</code> terminates with an uncaught
exception, <code>std::terminate()</code> shall be called.

+

Postconditions:

+
<blockquote>
<pre><code>
get_id() != thread::id()
&& joinable() == true
</code></pre>
+

<code>*this</code> represents the newly started thread.

</blockquote>
+

Throws: <code>system_error</code> if unable to start the new thread.

@@ -545,6 +567,7 @@

Effects: Constructs an object of type <code>thread</code> from <code>x</code>.

+

Postconditions: <code>x.joinable()</code> is <code>false</code>.
<code>x.get_id() == thread().get_id()</code>. <code>joinable()</code>
@@ -552,6 +575,7 @@
<code>get_id()</code> returns the value of <code>x.get_id()</code> prior to the
start of construction.

+

Throws: Nothing.

@@ -570,6 +594,7 @@
Effects: If <code>joinable()</code> then <code>detach()</code>,
otherwise no effects.

+

Throws: Nothing.

@@ -589,6 +614,7 @@
<code>detach()</code>. Then assigns the state of <code>x</code> to <code>*this</code>
and sets <code>x</code> to a default constructed state.

+

Postconditions: <code>x.joinable()</code> is <code>false</code>.
<code>x.get_id() == thread().get_id()</code>. <code>joinable()</code> returns the
@@ -597,6 +623,7 @@
<code>get_id()</code> returns the value of <code>x.get_id()</code> prior to the
assignment.

+

Throws: Nothing.

@@ -614,6 +641,7 @@

Effects: Swaps the state of <code>*this</code> and <code>x</code>.

+

Throws: Nothing.

@@ -629,6 +657,7 @@

Returns: <code>get_id() != id()</code>.

+

Throws: Nothing.

@@ -644,6 +673,7 @@

Preconditions: <code>joinable()</code> is <code>true</code>.

+

Effects: The current thread blocks until the thread
represented by <code>*this</code> completes.
@@ -651,6 +681,7 @@
on a memory location that the joiner does an acquire on.
I.e. there is a happens before relationship.]

+

Postconditions: After a normal return of <code>join()</code>,
<code>joinable()</code> is <code>false</code>. If <code>join()</code> throws an exception, the thread represented by
@@ -673,6 +704,7 @@

Preconditions: <code>joinable()</code> is <code>true</code>.

+

Effects: The thread represented by
<code>*this</code> continues execution. When the thread represented by
@@ -680,10 +712,12 @@
[Crowl: The programmer shall or the implementation shall?
Which resources?]

+

Postconditions: <code>joinable()</code> is <code>false</code>. <code>*this</code>
does not represent a thread.

+

Throws: Nothing.

@@ -702,6 +736,7 @@
represented by
<code>*this.</code>

+

Throws: Nothing.

@@ -722,6 +757,7 @@
--end note] If this value is not computable or well defined a
return value of 1 is recommended, but not required.

+

Throws: Nothing.

@@ -736,6 +772,7 @@
void swap(thread&& x, thread& y);
void swap(thread& x, thread&& y);
</code></pre>
+
<blockquote>

Effects: <code>x.swap(y)</code>.
@@ -772,6 +809,7 @@
and does not compare equal to a default constructed <code>thread::id</code>, else returns
a default constructed <code>thread::id</code>

+

Throws: Nothing.

@@ -787,6 +825,7 @@

Effects: Offers the operating system the opportunity to schedule another thread.

+

Throws: Nothing.

@@ -803,9 +842,11 @@

Requires: <code>Duration</code> shall be explicitly convertible to <code>nanoseconds</code>.

+

Effects: The current thread blocks for at least the amount of time specified.

+

Throws: Nothing.

@@ -815,7 +856,6 @@
<h4><code>struct once_flag</code></h4>

<blockquote>
-

Objects of class <code>once_flag</code> are opaque data structures that allow
<code>call_once</code> to initialize data without causing a data race or
@@ -831,6 +871,7 @@
Effects: Constructs a object of type
<code>once_flag</code>.

+

Postcondition: Internal state is set to indicate to an invocation
of <code>call_once</code> with this <code>once_flag</code> as its initial
@@ -843,14 +884,12 @@
<h4><code>non-member function call_once</code></h4>

<blockquote>
-
<pre><code>
template<class Callable, class Args...>
void call_once(once_flag& flag, Callable func, Args&&... args);
</code></pre>

<blockquote>
-

Requires: If <code>func</code> is an lvalue, Callable
 is
@@ -888,6 +927,7 @@

[Examples:

+
<blockquote>
<pre><code>
std::once_flag flag;
@@ -982,19 +1022,23 @@
<pre><code>
void lock();
</code></pre>
+
<blockquote>

Precondition: For non-recursive mutexes the current thread shall not own the mutex.

+

Effects: The current thread will block until the mutex is not owned by another thread.
[Crowl: I.e. happens before?]
Upon successful completion, the current thread owns the mutex.

+

Throws: <code>system_error</code> when an error condition occurs. The
possible error conditions are implementation defined.

+

Thread safety: This is an acquire operation.

@@ -1005,10 +1049,12 @@
<pre><code>
bool try_lock();
</code></pre>
+
<blockquote>

Precondition: For non-recursive mutexes the current thread shall not own the mutex.

+

Effects:
If ownership can be obtained without blocking,
@@ -1024,14 +1070,16 @@
And such a guarantee would preclude potentially interesting
<code>try_lock()</code> implementations based on <code>compare_swap</code>.
— end note]
-

+

Returns: <code>true</code> if ownership was obtained, otherwise <code>false</code>.

+

Thread safety: This is an acquire operation if <code>try_lock</code> returns <code>true</code>.

+

Throws: Nothing.

@@ -1042,18 +1090,22 @@
<pre><code>
void unlock();
</code></pre>
+
<blockquote>

Precondition: The current thread shall own the mutex.

+

Effects: For a non-recursive mutex ownership is released. For a recursive mutex
<code>unlock()</code> must be called the same number of times which the mutex was locked
(via either <code>lock()</code> or <code>try_lock()</code> or by any other locking function) before ownership is released.

+

Thread safety: This is a release operation.

+

Throws: Nothing.

@@ -1136,12 +1188,14 @@
template <class Duration>
 bool timed_lock(const Duration& rel_time);
</code></pre>
+
<blockquote>

Precondition: For non-recursive mutexes the current thread shall not own
the mutex. .
[Crowl: Roundup here instead of under various locks.]

+

Effects:
The function attempts to obtain ownership of the mutex
@@ -1158,13 +1212,16 @@
but implementations are expected to make a strong effort to do so.
— end note]

+

Returns: <code>true</code> if ownership was obtained, otherwise <code>false</code>.

+

Thread safety: This is a synchronization operation.
[Crowl: on the memory locations of the lock.]

+

Throws: Nothing.

@@ -1318,12 +1375,14 @@
<pre><code>
explicit lock_guard(mutex_type& m);
</code></pre>
+
<blockquote>

Precondition: If <code>mutex_type</code> is not a recursive mutex, the current thread
does not own the mutex. The lifetime of <code>m</code> includes the lifetime
of the <code>lock_guard</code> object.

+

Effects: Stores a reference to <code>m</code> and calls <code>m.lock()</code>.
[Crowl: An acquire specification is not necessary because of m.lock().]
@@ -1335,12 +1394,14 @@
<pre><code>
lock_guard(mutex_type& m, adopt_lock_t);
</code></pre>
+
<blockquote>

Precondition: The current thread has ownership of the mutex <code>m</code>.
The lifetime of <code>m</code> includes the lifetime of the <code>
lock_guard</code> object.

+

Effects: Stores a reference to <code>m</code> and performs no other operation on it.

@@ -1351,10 +1412,12 @@
<pre><code>
~lock_guard();
</code></pre>
+
<blockquote>

Effects: <code>m.unlock()</code>.

+

Throws: Nothing.

@@ -1422,13 +1485,16 @@
<pre><code>
unique_lock();
</code></pre>
+
<blockquote>

Effects: Constructs an object of type <code>unique_lock</code>.

+

Postcondition:

+
<blockquote>
<pre><code>
mutex() == 0
@@ -1442,18 +1508,22 @@
<pre><code>
explicit unique_lock(mutex_type& m);
</code></pre>
+
<blockquote>

Precondition: If <code>mutex_type</code> is not a recursive mutex, the current thread
does not own the mutex. The lifetime of <code>m</code> includes the lifetime
of the <code>unique_lock</code> object.

+

Effects: Stores a reference to <code>m</code> and calls <code>m.lock()</code>.

+

Postcondition:

+
<blockquote>
<pre><code>
mutex() == &m
@@ -1467,6 +1537,7 @@
<pre><code>
unique_lock(mutex_type& m, defer_lock_t);
</code></pre>
+
<blockquote>

Precondition: If <code>mutex_type</code> is not a recursive mutex, the current thread
@@ -1474,12 +1545,15 @@
The lifetime of <code>m</code> includes the lifetime of the <code>
unique_lock</code> object.

+

Effects: Stores a reference to <code>m</code> and performs no other operation on it.

+

Postcondition:

+
<blockquote>
<pre><code>
mutex() == &m
@@ -1493,6 +1567,7 @@
<pre><code>
unique_lock(mutex_type& m, try_to_lock_t);
</code></pre>
+
<blockquote>

Precondition: If <code>mutex_type</code> is not a recursive mutex, then the current thread
@@ -1500,12 +1575,15 @@
The lifetime of <code>m</code> includes the lifetime of the <code>
unique_lock</code> object.

+

Effects: Stores a reference to <code>m</code> and calls <code>m.try_lock()</code>.

+

Postcondition:

+
<blockquote>
<pre><code>
mutex() == &m
@@ -1519,18 +1597,22 @@
<pre><code>
unique_lock(mutex_type& m, adopt_lock_t);
</code></pre>
+
<blockquote>

Precondition: The current thread has ownership of the mutex <code>m</code>.
The lifetime of <code>m</code> includes the lifetime of the <code>
unique_lock</code> object.

+

Effects: Stores a reference to <code>m</code> and performs no other operation on it.

+

Postcondition:

+
<blockquote>
<pre><code>
mutex() == &m
@@ -1544,11 +1626,13 @@
<pre><code>
~unique_lock();
</code></pre>
+
<blockquote>

Effects: If <code>owns_lock()</code> calls <code>unlock()</code> on the referenced mutex.
Otherwise there are no effects.

+

Throws: Nothing.

@@ -1559,13 +1643,16 @@
<pre><code>
unique_lock(unique_lock&& u);
</code></pre>
+
<blockquote>

Effects: Transfers mutex ownership (if any) from <code>u</code> to <code>this</code>.

+

Postcondition:

+
<blockquote>
<pre><code>
mutex() == The value of u.mutex() prior to the construction.
@@ -1574,6 +1661,7 @@
u.owns_lock() == false
</code></pre>
</blockquote>
+

Throws: Nothing.

@@ -1584,14 +1672,17 @@
<pre><code>
unique_lock& operator=(unique_lock&& u);
</code></pre>
+
<blockquote>

Effects: If <code>owns_lock()</code> calls <code>unlock()</code>, and then
transfers mutex ownership (if any) from <code>u</code> to <code>this</code>.

+

Postcondition:

+
<blockquote>
<pre><code>
mutex() == The value of u.mutex() prior to the construction.
@@ -1600,9 +1691,11 @@
u.owns_lock() == false
</code></pre>
</blockquote>
+

Throws: Nothing.

+

Note: With a recursive mutex it is possible that both
<code>this</code> and <code>u</code> own the same mutex before the assignment.
@@ -1617,13 +1710,16 @@
<pre><code>
void lock();
</code></pre>
+
<blockquote>

Effects: Calls <code>lock()</code> on the referenced mutex.

+

Postcondition: <code>owns_lock() == true</code>.

+

Throws: <code>lock_error</code>, if on entry <code>owns_lock()</code> is <code>true</code>.

@@ -1634,16 +1730,20 @@
<pre><code>
bool try_lock();
</code></pre>
+
<blockquote>

Effects: Calls <code>try_lock()</code> on the referenced mutex.

+

Returns: The result of the call to <code>try_lock()</code> on the referenced mutex.

+

Postcondition: <code>owns_lock() == </code>The result of the call to <code>try_lock()</code> on the referenced mutex.

+

Throws: <code>lock_error</code>, if on entry <code>owns_lock()</code> is <code>true</code>.<code> </code>

@@ -1655,18 +1755,22 @@
template <class Duration>
 bool timed_lock(const Duration& rel_t);
</code></pre>
+
<blockquote>

Effects: Calls <code>timed_lock(rel_t)</code> on the referenced mutex.
 If the resolution of Duration is greater [Crowl: less] than the native
 resolution the time is rounded up to the nearest native resolution.

+

Returns: The result of the call to <code>timed_lock(rel_t)</code> on the referenced mutex.

+

Postcondition: <code>owns_lock() == </code>The result of the call to <code>timed_lock(rel_t)</code> on the referenced mutex.

+

Throws: <code>lock_error</code>, if on entry <code>owns_lock()</code> is <code>true</code>.

@@ -1677,13 +1781,16 @@
<pre><code>
void unlock();
</code></pre>
+
<blockquote>

Effects: Calls <code>unlock()</code> on the referenced mutex.

+

Postcondition: <code>owns_lock() == false</code>.

+

Throws: <code>lock_error</code>, if on entry <code>owns_lock()</code> is <code>false</code>.

@@ -1694,10 +1801,12 @@
<pre><code>
bool owns_lock() const;
</code></pre>
+
<blockquote>

Returns: <code>true</code> if <code>this</code> owns a lock on a referenced mutex, else <code>false</code>.

+

Throws: Nothing.

@@ -1708,10 +1817,12 @@
<pre><code>
operator <var>unspecified-bool-type</var> () const;
</code></pre>
+
<blockquote>

Returns: Non-null if <code>owns_lock()</code> would return <code>true</code>, else returns null.

+

Throws: Nothing.

@@ -1722,10 +1833,12 @@
<pre><code>
mutex_type* mutex() const;
</code></pre>
+
<blockquote>

Returns: A pointer to the referenced mutex, or null if there is no referenced mutex.

+

Throws: Nothing.

@@ -1736,10 +1849,12 @@
<pre><code>
void swap(unique_lock&& u);
</code></pre>
+
<blockquote>

Effects: Swaps state with <code>u</code>.

+

Throws: Nothing.

@@ -1750,19 +1865,23 @@
<pre><code>
mutex_type* release();
</code></pre>
+
<blockquote>

Returns: A pointer to the referenced mutex, or null if there is no referenced mutex.

+

Postcondition:

+
<blockquote>
<pre><code>
mutex() == 0
owns_lock() == false
</code></pre>
</blockquote>
+

Throws: Nothing.

@@ -1775,10 +1894,12 @@
template <class Mutex> void swap(unique_lock<Mutex>&& x, unique_lock<Mutex>& y);
template <class Mutex> void swap(unique_lock<Mutex>& x, unique_lock<Mutex>&& y);
</code></pre>
+
<blockquote>

Effects: <code>x.swap(y)</code>.

+

Throws: Nothing.

@@ -1791,6 +1912,7 @@
<pre><code>
template <class L1, class L2, class ...L3> int try_lock(L1&, L2&, L3&...);
</code></pre>
+
<blockquote>

Requires: Each template parameter type must supply the following member functions with semantics
@@ -1798,18 +1920,21 @@
exception. [Note: The <code>unique_lock</code> class template meets these requirements
when suitable instantiated. --end note]

+
<blockquote>
<pre><code>
bool try_lock();
void unlock();
</code></pre>
</blockquote>
+

Effects: The functions attempts to lock all arguments without blocking by calling <code>try_lock()</code>
on each of them. If any argument can not be locked, then all arguments which have already been locked will
be unlocked. On return, either all arguments will be locked, or none of them will be locked. If an
exception is thrown by a call to <code>try_lock()</code>, there are no effects.

+

Returns: If all arguments were successfully locked, returns <code>-1</code>. Otherwise returns a 0-based index
value indicating
@@ -1822,6 +1947,7 @@
<pre><code>
template <class L1, class L2, class ...L3> void lock(L1&, L2&, L3&...);
</code></pre>
+
<blockquote>

Requires: Each template parameter type must supply the following member functions with semantics
@@ -1829,6 +1955,7 @@
throw an exception [Note: The <code>unique_lock</code> class template meets these requirements
when suitable instantiated. --end note]

+
<blockquote>
<pre><code>
void lock();
@@ -1836,6 +1963,7 @@
void unlock();
</code></pre>
</blockquote>
+

Effects: All arguments are locked with an algorithm that avoids deadlock.
If an exception is thrown by a call to <code>lock()</code> or <code>try_lock()</code>, there are no effects.
@@ -1903,6 +2031,7 @@
<pre><code>
condition_variable();
</code></pre>
+
<blockquote>

Effects: Constructs an object of class <code>condition_variable</code>.
@@ -1914,10 +2043,12 @@
<pre><code>
~condition_variable();
</code></pre>
+
<blockquote>

Effects: Destroys the object.

+

Throws: Nothing.

@@ -1928,14 +2059,18 @@
<pre><code>
void notify_one();
</code></pre>
+
<blockquote>

Effects: If any threads are blocked waiting for <code>*this</code>,
unblocks at least one those threads.
[Crowl: Is any lock released?]

+

[Crowl: Needs to say release operation.]
+
+

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
@@ -1950,11 +2085,13 @@
<pre><code>
void notify_all();
</code></pre>
+
<blockquote>

Effects: Unblock all threads that are blocked waiting for <code>*this</code>.
[Crowl: Needs to say release operation.]

+

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
@@ -1969,12 +2106,14 @@
<pre><code>
void wait(unique_lock<mutex>& lock);
</code></pre>
+
<blockquote>

Precondition: <code>lock</code> is locked by the current thread. No
other thread is waiting on this <code>condition_variable</code> object unless <code>lock</code>
refers to the same underlying <code>mutex</code> object.

+

Effects: Atomically blocks and releases the lock on
<code>lock</code>. If the <code>wait</code> throws an exception, <code>lock</code> will be
@@ -1982,14 +2121,17 @@
unblock and return even in the absence of a notification.
[Crowl: Needs to say acquire operation.]

+

Postcondition: <code>lock</code> is locked by the current
thread.

+

Throws: ???
See issue 26

+

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
@@ -2005,10 +2147,12 @@
template <class Predicate>
 void wait(unique_lock<mutex>& lock, Predicate pred);
</code></pre>
+
<blockquote>

Effects: While <code>pred()</code> returns <code>false</code> calls <code>wait(lock)</code>.

+

[Note: Does not block if <code>pred()</code> is initially <code>true</code>. 
--end note]
@@ -2016,17 +2160,18 @@
</blockquote>
</blockquote>

-
<blockquote>
<pre><code>
bool timed_wait(unique_lock<mutex>& lock, const system_time& abs_time);
</code></pre>
+
<blockquote>

Precondition: The <code>lock</code> is locked by the current thread. No
other thread is waiting on this <code>condition_variable</code> object unless <code>lock</code>
refers to, the same underlying <code>mutex</code> object.

+

Effects: Atomically blocks and releases the lock on
<code>lock</code>. If the <code>timed_wait</code> should throw an exception for
@@ -2040,19 +2185,23 @@
thread may unblock and return even in the absence of a
notification.

+

Postcondition: <code>lock</code> is locked by the current
thread.

+

Returns: <code>true</code> if the call to <code>timed_wait</code> is notified prior
to the indicated timeout,
otherwise returns <code>false</code>.

+

Throws: ???
See issue 26

+

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
@@ -2070,10 +2219,12 @@
template <class Predicate>
 bool timed_wait(unique_lock<mutex>& lock, const system_time& abs_time, Predicate pred);
</code></pre>
+
<blockquote>

Effects: As if:

+
<blockquote>
<pre><code>
while (!pred())
@@ -2084,9 +2235,11 @@
return true;
</code></pre>
</blockquote>
+

Returns: <code>pred()</code>.

+

Note: There is no blocking if <code>pred()</code> is initially <code>true</code>, even
if the timeout has already expired. The return value indicates whether the predicate
@@ -2095,7 +2248,6 @@
</blockquote>
</blockquote>

-

<code>condition_variable</code> shall be a standard-layout class (chapter 9 [class]).

@@ -2150,6 +2302,7 @@
<pre><code>
condition_variable_any();
</code></pre>
+
<blockquote>

Effects: Constructs an object of class <code>condition_variable_any</code>.
@@ -2161,10 +2314,12 @@
<pre><code>
~condition_variable_any();
</code></pre>
+
<blockquote>

Effects: Destroys the object.

+

Throws: Nothing.

@@ -2175,11 +2330,13 @@
<pre><code>
void notify_one();
</code></pre>
+
<blockquote>

Effects: If any threads are blocked waiting for <code>*this</code>,
unblocks at least one those threads.

+

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
@@ -2194,10 +2351,12 @@
<pre><code>
void notify_all();
</code></pre>
+
<blockquote>

Effects: Unblock all threads of execution that are blocked waiting for <code>*this</code>.

+

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
@@ -2212,6 +2371,7 @@
<pre><code>
void wait(Lock& lock);
</code></pre>
+
<blockquote>

Precondition: <code>lock</code> is locked by the current thread. If
@@ -2219,6 +2379,7 @@
other thread is waiting on this <code>condition_variable_any</code> object unless <code>lock</code>
is, or refers to, the same underlying mutex object.

+

Effects: Atomically blocks and releases the lock on
<code>lock</code>. If the <code>wait</code> should throw an exception for any
@@ -2227,14 +2388,17 @@
notification to this blocked thread. The current thread may
unblock and return even in the absence of a notification.

+

Postcondition: <code>lock</code> is locked by the current
thread.

+

Throws: <code>system_error</code> when an error condition occurs. The
possible error conditions are implementation defined.  

+

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
@@ -2250,21 +2414,23 @@
template <class Predicate>
 void wait(lock_type& lock, Predicate pred);
</code></pre>
+
<blockquote>

Effects: While <code>pred()</code> returns <code>false</code>, calls <code>wait(lock)</code>.

+

Note: There is no blocking if <code>pred()</code> is initially <code>true</code>.

</blockquote>
</blockquote>

-
<blockquote>
<pre><code>
bool timed_wait(Lock& lock, const system_time& abs_time);
</code></pre>
+
<blockquote>

Precondition: The <code>lock</code> is locked by the current thread. If
@@ -2272,6 +2438,7 @@
other thread is waiting on this <code>condition_variable_any</code> object unless <code>lock</code>
is, or refers to, the same underlying mutex object.

+

Effects: Atomically blocks and releases the lock on
<code>lock</code>. If the <code>timed_wait</code> should throw an exception for
@@ -2285,19 +2452,23 @@
thread may unblock and return even in the absence of a
notification.

+

Postcondition: <code>lock</code> is locked by the current
thread.

+

Returns: <code>true</code> if the call to <code>timed_wait</code> is notified prior
to the indicated timeout,
otherwise returns <code>false</code>.

+

Throws: <code>system_error</code> when an error condition occurs. The
possible error conditions are implementation defined.  

+

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
@@ -2313,10 +2484,12 @@
template <class _Predicate>
 bool timed_wait(Lock& lock, const system_time& abs_time, Predicate pred);
</code></pre>
+
<blockquote>

Effects: As if:

+
<blockquote>
<pre><code>
while (!pred())
@@ -2327,9 +2500,11 @@
return true;
</code></pre>
</blockquote>
+

Returns: <code>pred()</code>.

+

Note: There is no blocking if <code>pred()</code> is initially <code>true</code>, even
if the timeout has already expired. The return value indicates whether the predicate
@@ -2353,7 +2528,6 @@
 have an epoch or start of a given time scale. For time_t the epoch is
 1970-01-01 00:00:00.

-

Throughout this clause, the names of template parameters are used to express
 type requirements. Define Duration,
@@ -2388,19 +2562,18 @@

<h3 class="title"><a name="n2411_07_0271___proposal_for_date_time_types_in_c__0x_to_support_threading_apis_v2.proposed_text.class_utc_time"></a>class system_time</h3>

-

 The class <code>system_time</code> provides a time point that represents the current
 Coordinated Universal Time, known as UTC, time.
 <code>system_time</code> shall provide an epoch time of 1970-01-01 00:00:00.000000000
 and a maximum time value of at least epoch time + 292 years.

+

 class <code>system_time</code> shall be EqualityComparable, LessThanComparable,
 CopyConstructable, DefaultConstructable, and Assignable.


-
<blockquote>
<pre><code>
class system_time
@@ -2459,201 +2632,257 @@
<pre><code>
system_time();
</code></pre>
+

 Effects: Constructs a system_time
 object representing the epoch time point 1970-01-01 00:00:00.000000000

+

 Throws: Nothing.

+
<pre><code>
system_time(time_t secs, nanoseconds ns);
</code></pre>
+

 Effects: Constructs a utc
 time object representing the time point that is secs + 1,000,000,000*ns after the epoch.

+

 Remarks: If the total nanoseconds > 1 second the seconds are
 incremented appropriately.

+

 Throws: Nothing.

-
-
+
<pre><code>
time_t seconds_since_epoch() const;
</code></pre>
+

 Returns: The count of seconds since 1970-01-01 00:00:00.

+

 Throws: Nothing.

+
<pre><code>
nanoseconds nanoseconds_since_epoch() const;
</code></pre>
+

 Returns: The count of nanoseconds
 since 1970-01-01 00:00:00.

+

 Throws: Nothing.

+
<pre><code>
static tick_type ticks_per_second();
</code></pre>
+

 Returns: 1000000000

+

 Throws: Nothing.

+
<pre><code>
static tick_type seconds_per_tick();
</code></pre>
+

 Returns: 0

+

 Remarks: Since this is a subsecond type it returns 0 for seconds_per_tick.

+

 Throws: Nothing.

+
<pre><code>
static bool is_subsecond();
</code></pre>
+

 Returns: true.

+

 Throws: Nothing.

+
<pre><code>
bool operator==(const system_time& rhs) const;
</code></pre>
+

 Returns: True if
 the time
 represented by *this is equal to the time represented by rhs.

+

 Throws: Nothing.

+
<pre><code>
bool operator!=(const system_time& rhs) const;
</code></pre>
+

 Returns: True if the time represented by *this is not equal to the time represented
 by rhs

+

 Throws: Nothing.

+
<pre><code>
bool operator>(const system_time& rhs) const;
</code></pre>
+

 Returns: True if time represented by
 *this is greater than the time represented by rhs.

+

 Throws: Nothing.

+
<pre><code>
bool operator>=(const system_time& rhs) const;
</code></pre>
+

 Returns: True if time represented
 by *this is greater or equal than the time represented by rhs.

+

 Throws: Nothing.

+
<pre><code>
bool operator<(const system_time& rhs) const;
</code></pre>
+

 Returns: True if time represented by *this
 is less than the time represented by rhs.

+

 Throws: Nothing.

+
<pre><code>
bool operator<=(const system_time& rhs) const;
</code></pre>
+

 Returns: True if time represented by *this
 is less or equal than the time represented by rhs.

+

 Throws: Nothing.

+
<pre><code>
nanoseconds operator-(const system_time& rhs) const
</code></pre>
+

 Returns: 
 The difference in nanoseconds between the time represented by *this and the
 time represented by rhs.

+

 Remarks: If rhs is greater the result will be a negative nanosecond.
 count.

+

 Throws: Nothing.

+
<pre><code>
template<typename Duration>
system_time operator+(const Duration& td) const;
</code></pre>
+

 Returns: The duration converted to nanosecond resolution
 and added to the time represented by *this.

+

 Throws: Nothing.

+
<pre><code>
template<typename Duration>
system_time& operator+=(const Duration& td);
</code></pre>
+

 Effects: Convert the duration to nanosecond resolution add to nanoseconds
 to the time represented by *this.

+

 Returns: Modified value of this.

+

 Throws: Nothing.

+
<pre><code>
template<typename Duration>
system_time operator-(const Duration& td) const;
</code></pre>
+

 Returns: The duration converted to nanosecond resolution
 and subtracted from the time represented by *this.

+

 Throws: Nothing.

+
<pre><code>
template<typename Duration>
system_time& operator-=(const Duration& td)
</code></pre>
+

 Effects: Convert the duration to nanosecond resolution subtract and
 from the time represented by *this.

+

 Returns: Modified value of this.

+

 Throws: Nothing.

@@ -2666,7 +2895,6 @@
 resolution up to nanoseconds. The actual resolution may vary from platform to platform.


-
<blockquote>
<pre><code>
 system_time get_system_time();
@@ -2691,16 +2919,17 @@
 functions provide the basis for durations to be EqualityComparable, LessThanComparable
 as well arithmetic operations.

+

 In the following text duration_type refers to the containing duration type.

+

 All duration types are EqualityComparable, LessThanComparable,
 CopyConstructable, DefaultConstructable, and Assignable for duration
 objects of the same type.


-
<blockquote>
<pre><code>
class Duration {
@@ -2751,196 +2980,250 @@
}
</code></pre>
</blockquote>
-
-
+
<pre><code>
template<typename RhsDuration>
bool operator==(const RhsDuration& rhs) const;
</code></pre>
+

 Returns: True if rhs duration is greater.

+

 Throws: Nothing.

+
<pre><code>
template<typename RhsDuration>
bool operator!=(const RhsDuration& rhs) const;
</code></pre>
+

 Returns: True if rhs is not the same time.

+

 Throws: Nothing.

+
<pre><code>
template<typename RhsDuration>
bool operator>(const RhsDuration& rhs) const;
</code></pre>
+

 Returns: True if the rhs duration is larger.

+

 Throws: Nothing.

+
<pre><code>
template<typename RhsDuration>
bool operator>=(const RhsDuration& rhs) const;
</code></pre>
+

 Returns: True if greater or equal than the rhs duration.

+

 Throws: Nothing.

+
<pre><code>
template<typename RhsDuration>
bool operator<(const RhsDuration& rhs) const;
</code></pre>
+

 Returns: True if less than the rhs duration.

+

 Throws: Nothing.

+
<pre><code>
template<typename RhsDuration>
bool operator<=(const RhsDuration& rhs) const;
</code></pre>
+

 Returns: True if less or equal to the rhs duration.

+

 Throws: Nothing.

+
<pre><code>
//sign inversion
Duration operator-() const
</code></pre>
+

 Returns: Negated value of the duration.

+

 Throws: Nothing.

+
<pre><code>
//arithmetic operations
template<typename RhsDuration>
Duration operator- (const RhsDuration& d) const
</code></pre>
+

 Returns: A duration value equal to this-rhs_duration.

+

 Remarks: This will fail to compiler if the
 RhsDuration is
 of higher resolution.

+

 Throws: Nothing.

+
<pre><code>
template<typename RhsDuration>
Duration operator-=(const RhsDuration& d)
</code></pre>
+

 Effects: Modifies to value equal to this-rhs_duration.

+

 Returns: this

+

 Remarks: This will fail to compiler if the
 RhsDuration is
 of higher resolution.

+

 Throws: Nothing.

+
<pre><code>
template<typename RhsDuration>
Duration operator+ (const RhsDuration& d) const
</code></pre>
+

 Returns: Duration equal to this+rhs_duration.

+

 Remarks: This will fail to compiler if the
 RhsDuration is
 of higher resolution.

+

 Throws: Nothing.

+
<pre><code>
template<typename RhsDuration>
Duration operator+=(const RhsDuration& d)
</code></pre>
+

 Effects: Modifies to value equal to this+rhs_duration.

+

 Returns: this

+

 Remarks: This will fail to compiler if the
 RhsDuration is
 of higher resolution.

+

 Throws: Nothing.

+
<pre><code>
Duration operator/ (int divisor) const
</code></pre>
+

 Returns: Duration with value equal to this/divisor according to
 integer arithmetic rules.

+

 Throws: Nothing.

+
<pre><code>
Duration operator/=(int divisor)
</code></pre>
+

 Effects: Change value of this by this/divisor according to integer
 arithmetic rules.

+

 Returns: this

+

 Throws: Nothing.

+
<pre><code>
Duration operator* (int rhs) const
</code></pre>
+

 Returns: Duration with value equal to this*rhs

+

 Throws: Nothing.

+
<pre><code>
Duration operator*=(int rhs)
</code></pre>
+

 Effects: Modifies to value equal to this*rhs.

+

 Returns: this

+

 Throws: Nothing.

+
<pre><code>
tick_type get_count() const
</code></pre>
+

 Returns: The count at the resolution of the time duration
 type.

+

 Throws: Nothing.

@@ -2976,48 +3259,60 @@
<pre><code>
nanoseconds(long long=0);
</code></pre>
+

 Effects: Constructs an object with a count of nanoseconds - default
 is zero.

+

 Throws: Nothing.

+
<pre><code>
nanoseconds(const nanoseconds& rhs);
</code></pre>
+

 Effects: Copy construction.

+

 Throws: Nothing.

-
-
+
<pre><code>
static tick_type ticks_per_second();
</code></pre>
+

 Returns: 1000000000

+

 Throws: Nothing.

+
<pre><code>
static tick_type seconds_per_tick();
</code></pre>
+

 Returns: 0

+

 Throws: Nothing.

+
<pre><code>
static bool is_subsecond();
</code></pre>
+

 Returns: true

+

 Throws: Nothing.

@@ -3057,65 +3352,79 @@
<pre><code>
microseconds(long long=0);
</code></pre>
+

 Effects: Constructs an object with a count of microseconds - default
 is zero.

+

 Throws: Nothing.

+
<pre><code>
microseconds(const microseconds& rhs);
</code></pre>
+

 Effects: Copy construction.

+

 Throws: Nothing.

-
-
+
<pre><code>
//conversions
operator nanoseconds() const
</code></pre>
+

 Returns: microsecond count converted to nanoseconds

+

 Throws: Nothing.

+
<pre><code>
static tick_type ticks_per_second();
</code></pre>
+

 Returns: 1000000

+

 Throws: Nothing.

+
<pre><code>
static tick_type seconds_per_tick();
</code></pre>
+

 Returns: 0

+

 Throws: Nothing.

+
<pre><code>
static bool is_subsecond();
</code></pre>
+

 Returns: true

+

 Throws: Nothing.


<h3 class="title"><a name="n2411_07_0271___proposal_for_date_time_types_in_c__0x_to_support_threading_apis_v2.proposed_text.class_milliseconds"></a>class milliseconds</h3>

-

Objects of class <code>milliseconds</code> can be used to represent a count of milliseconds.

@@ -3147,66 +3456,84 @@
<pre><code>
milliseconds(long long=0);
</code></pre>
+

 Effects: Constructs an object with a count of milliseconds - default
 is zero.

+

 Throws: Nothing.

+
<pre><code>
milliseconds(const milliseconds& rhs);
</code></pre>
+

 Effects: Copy construction.

+

 Throws: Nothing.

-
-
+
<pre><code>
operator nanoseconds() const
</code></pre>
+

 Returns: millisecond count converted to nanoseconds

+

 Throws: Nothing.

+
<pre><code>
operator microseconds() const
</code></pre>
+

 Returns: millisecond count converted to microseconds

+

 Throws: Nothing.

+
<pre><code>
static tick_type ticks_per_second();
</code></pre>
+

 Returns: 1000

+

 Throws: Nothing.

+
<pre><code>
static tick_type seconds_per_tick();
</code></pre>
+

 Returns: 0

+

 Throws: Nothing.

+
<pre><code>
static bool is_subsecond();
</code></pre>
+

 Returns: true

+

 Throws: Nothing.

@@ -3246,82 +3573,102 @@
<pre><code>
seconds(long long=0);
</code></pre>
+

 Effects: Constructs an object with a count of seconds - default is
 zero.

+

 Throws: Nothing.

+
<pre><code>
seconds(const seconds& rhs);
</code></pre>
+

 Effects: Copy construction.

+

 Throws: Nothing.

-
-
+
<pre><code>
operator nanoseconds() const
</code></pre>
+

 Returns: second count converted to nanoseconds

+

 Throws: Nothing.

+
<pre><code>
operator microseconds() const
</code></pre>
+

 Returns: second count converted to microseconds

+

 Throws: Nothing.

+
<pre><code>
operator milliseconds() const
</code></pre>
+

 Returns: second count converted to milliseconds

+

 Throws: Nothing.

+
<pre><code>
static tick_type ticks_per_second();
</code></pre>
+

 Returns: 1

+

 Throws: Nothing.

+
<pre><code>
static tick_type seconds_per_tick();
</code></pre>
+

 Returns: 1

+

 Throws: Nothing.

+
<pre><code>
static bool is_subsecond();
</code></pre>
+

 Returns: false

+

 Throws: Nothing.


<h3 class="title"><a name="n2411_07_0271___proposal_for_date_time_types_in_c__0x_to_support_threading_apis_v2.proposed_text.class_minutes"></a>class minutes</h3>

-

Objects of class <code>minutes</code> can be used to represent a count of minutes.

@@ -3352,87 +3699,115 @@
};
</code></pre>
</blockquote>
+
<pre><code>
minutes(long long=0);
</code></pre>
+

 Effects: Constructs an object with a count of minutes - default is
 zero.

+

 Throws: Nothing.

+
<pre><code>
minutes(const minutes& rhs);
</code></pre>
+

 Effects: Copy construction.

+

 Throws: Nothing.

+


+
<pre><code>
operator nanoseconds() const
</code></pre>
+

 Returns: minute count converted to nanoseconds

+

 Throws: Nothing.

+
<pre><code>
operator microseconds() const
</code></pre>
+

 Returns: minute count converted to microseconds

+

 Throws: Nothing.

+
<pre><code>
operator milliseconds() const
</code></pre>
+

 Returns: minute count converted to milliseconds

+

 Throws: Nothing.

+
<pre><code>
operator seconds() const
</code></pre>
+

 Returns: minute count converted to seconds

+

 Throws: Nothing.

+
<pre><code>
static tick_type ticks_per_second();
</code></pre>
+

 Returns: 0

+

 Throws: Nothing.

+
<pre><code>
static tick_type seconds_per_tick();
</code></pre>
+

 Returns: 60

+

 Throws: Nothing.

+
<pre><code>
static bool is_subsecond();
</code></pre>
+

 Returns: false

+

 Throws: Nothing.

@@ -3471,96 +3846,125 @@
</code></pre>
</blockquote>

-
<pre><code>
hours(long long=0);
</code></pre>
+

 Effects: Constructs an object with a count of hours - default is zero.

+

 Throws: Nothing.

+
<pre><code>
hours(const hours& rhs);
</code></pre>
+

 Effects: Copy construction.

+

 Throws: Nothing.

+


+
<pre><code>
operator nanoseconds() const
</code></pre>
+

 Returns: hour count converted to nanoseconds

+

 Throws: Nothing.

+
<pre><code>
operator microseconds() const
</code></pre>
+

 Returns: hour count converted to microseconds

+

 Throws: Nothing.

+
<pre><code>
operator milliseconds() const
</code></pre>
+

 Returns: hour count converted to milliseconds

+

 Throws: Nothing.

+
<pre><code>
operator seconds() const
</code></pre>
+

 Returns: hour count converted to seconds

+

 Throws: Nothing.

+
<pre><code>
operator minutes() const
</code></pre>
+

 Returns: hour count converted to seconds.

+

 Throws: Nothing.

+
<pre><code>
static tick_type ticks_per_second();
</code></pre>
+

 Returns: 0

+

 Throws: Nothing.

+
<pre><code>
static tick_type seconds_per_tick();
</code></pre>
+

 Returns: 3600

+

 Throws: Nothing.

+
<pre><code>
static bool is_subsecond();
</code></pre>
+

 Returns: false

+

 Throws: Nothing.

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk