[Boost-commit] svn:boost r41937 - sandbox/committee/LWG

From: Lawrence_at_[hidden]
Date: 2007-12-09 15:46:30

Author: crowl
Date: 2007-12-09 15:46:30 EST (Sun, 09 Dec 2007)
New Revision: 41937
URL: http://svn.boost.org/trac/boost/changeset/41937

Log:
More line breaks to normalize HTML.

Text files modified: 
   sandbox/committee/LWG/thread_library.html |    95 ++++++++++++++++++++++++--------------- 
   1 files changed, 58 insertions(+), 37 deletions(-)

Modified: sandbox/committee/LWG/thread_library.html
==============================================================================
--- sandbox/committee/LWG/thread_library.html	(original)
+++ sandbox/committee/LWG/thread_library.html	2007-12-09 15:46:30 EST (Sun, 09 Dec 2007)
@@ -421,14 +421,17 @@
 <h4><a name="thread.timing_specifications">30.1.4 Timing Specifications [thread.timing_specifications]</a></h4>
 
 <p>
-Several functions described in this clause take an argument to specify a
-timeout.  These timeouts are specified as either a Duration or a Time Point type as specified in [time].
+Several functions described in this clause
+take an argument to specify a timeout.
+These timeouts are specified as either a Duration or a Time Point type
+as specified in [time].
 </p>
 
 <p>
-The resolution of timing provided by an implementation depends on
-both operating system and hardware.  The finest resolution provided by
-an implementation is called the native resolution.
+The resolution of timing provided by an implementation
+depends on both operating system and hardware.
+The finest resolution provided by an implementation
+is called the native resolution.
 </p>
 
 
@@ -1272,14 +1275,18 @@
 <h4><a name="thread.mutex.concept">30.3.1 Mutex requirements [thread.mutex.requirements]</a></h4>
 
 <p>
-A mutex object facilitates protection against data races and allows thread-safe
-synchronization of data between threads. A thread obtains ownership of a mutex
-object by calling <code>lock()</code> and relinquishes ownership by calling <code>unlock()</code>. The
-thread that calls <code>lock()</code> for a mutex object shall call <code>unlock()</code>. Mutexes may be
-either recursive or non-recursive, and may grant simultaneous ownership to one
-or many threads. The mutex types supplied by the Standard Library
-provide exclusive ownership semantics: only one thread may own the mutex at a
-time. Both recursive and non-recursive mutexes are supplied.
+A mutex object facilitates protection against data races
+and allows thread-safe synchronization of data between threads.
+A thread obtains ownership of a mutex object by calling <code>lock()</code>
+and relinquishes ownership by calling <code>unlock()</code>.
+The thread that calls <code>lock()</code> for a mutex object
+shall call <code>unlock()</code>.
+Mutexes may be either recursive or non-recursive,
+and may grant simultaneous ownership to one or many threads.
+The mutex types supplied by the Standard Library
+provide exclusive ownership semantics:
+only one thread may own the mutex at a time.
+Both recursive and non-recursive mutexes are supplied.
 </p>
 
 <p>
@@ -1469,8 +1476,9 @@
 </blockquote>
 
 <p>
-The class <code>mutex</code> provides a non-recursive mutex with exclusive
-ownership semantics. It satisfies all the Mutex requirements ([thread.mutex.requirements]).
+The class <code>mutex</code>
+provides a non-recursive mutex with exclusive ownership semantics.
+It satisfies all the Mutex requirements ([thread.mutex.requirements]).
 It shall be a standard-layout class ([class]).
 </p>
 
@@ -1486,10 +1494,13 @@
 </p>
 
 <ul>
-  <li>for a thread to call <code>lock()</code> or <code>try_lock()</code> if it
-  already owns the <code>mutex</code> object.</li>
-  <li>if a thread terminates while owning a <code>mutex</code> object.</li>
-  <li>to destroy a <code>mutex</code> object owned by any thread.</li>
+<li>for a thread to call <code>lock()</code> or <code>try_lock()</code> if it
+already owns the <code>mutex</code> object.
+</li>
+<li>if a thread terminates while owning a <code>mutex</code> object.
+</li>
+<li>to destroy a <code>mutex</code> object owned by any thread.
+</li>
 </ul>
 
 <h5><a name="thread.mutex.recursive">30.3.1.2 Class recursive_mutex [thread.mutex.recursive]</a></h5>
@@ -1520,8 +1531,9 @@
 </blockquote>
 
 <p>
-The class <code>recursive_mutex</code> provides a recursive mutex with exclusive
-ownership semantics. It satisfies all the Mutex requirements ([thread.mutex.requirements]).
+The class <code>recursive_mutex</code>
+provides a recursive mutex with exclusive ownership semantics.
+It satisfies all the Mutex requirements ([thread.mutex.requirements]).
 It shall be a standard-layout class ([class]).
 </p>
 
@@ -1533,16 +1545,21 @@
 </p>
 
 <p>
-A thread that owns a <code>recursive_mutex</code> object may acquire additional
-levels of ownership by calling <code>lock()</code> or <code>try_lock()</code>.
-It is unspecified how many levels of ownership may be acquired by a single
-thread. If a thread has already acquired the maximum level of ownership for a
-<code>recursive_mutex</code> object, additional calls to <code>try_lock()</code>
-shall fail, and additional calls to <code>lock()</code> shall throw an exception
-of type <code>system_error</code>. A thread must call <code>unlock()</code> once
-for each level of ownership acquired by calls to <code>lock()</code> and <code>
-try_lock()</code>. Only when all levels of ownership have been released may
-ownership be acquired by another thread.
+A thread that owns a <code>recursive_mutex</code> object
+may acquire additional levels of ownership
+by calling <code>lock()</code> or <code>try_lock()</code>.
+It is unspecified how many levels of ownership
+may be acquired by a single thread.
+If a thread has already acquired the maximum level of ownership
+for a <code>recursive_mutex</code> object,
+additional calls to <code>try_lock()</code> shall fail,
+and additional calls to <code>lock()</code> shall throw an exception
+of type <code>system_error</code>.
+A thread must call <code>unlock()</code> once
+for each level of ownership acquired by calls
+to <code>lock()</code> and <code> try_lock()</code>.
+Only when all levels of ownership have been released
+may ownership be acquired by another thread.
 </p>
 
 <p>
@@ -1550,8 +1567,10 @@
 </p>
 
 <ul>
-  <li>if a thread terminates while owning a <code>recursive_mutex</code> object.</li>
-  <li>to destroy a <code>recursive_mutex</code> object owned by any thread.</li>
+<li>if a thread terminates while owning a <code>recursive_mutex</code> object.
+</li>
+<li>to destroy a <code>recursive_mutex</code> object owned by any thread.
+</li>
 </ul>
 
 <h4><a name="thread.timed.concept">30.3.2 TimedMutex requirements [thread.timedmutex.requirements]</a></h4>
@@ -3087,7 +3106,8 @@
 
 <dt>Returns:</dt>
 <dd>
-<code>false</code> if the call is returning because the time duration specified by
+<code>false</code> if the call is returning
+because the time duration specified by
 <code>rel_time</code> has elapsed, <code>true</code> otherwise.
 </dd>
 
@@ -3453,7 +3473,8 @@
 
 <dt>Returns:</dt>
 <dd>
-<code>false</code> if the call is returning because the time duration specified by
+<code>false</code> if the call is returning
+because the time duration specified by
 <code>rel_time</code> has elapsed, <code>true</code> otherwise.
 </dd>
 
@@ -3666,8 +3687,8 @@
 </p>
 
 <p>
-Objects of duration types provide time length values. Duration types
-provide comparison and arithmetic operations on those values.
+Objects of duration types provide time length values.
+Duration types provide comparison and arithmetic operations on those values.
 </p>
 
 <p>