[Boost-commit] svn:boost r80565 - trunk/libs/thread/doc

Subject: [Boost-commit] svn:boost r80565 - trunk/libs/thread/doc
From: vicente.botet_at_[hidden]
Date: 2012-09-17 17:30:49

Author: viboes
Date: 2012-09-17 17:30:48 EDT (Mon, 17 Sep 2012)
New Revision: 80565
URL: http://svn.boost.org/trac/boost/changeset/80565

Log:
Thread: fix some typos
Text files modified: 
   trunk/libs/thread/doc/futures.qbk        |     1 +                                       
   trunk/libs/thread/doc/mutex_concepts.qbk |    18 +++++++++---------                      
   trunk/libs/thread/doc/thread.qbk         |     3 +++                                     
   3 files changed, 13 insertions(+), 9 deletions(-)

Modified: trunk/libs/thread/doc/futures.qbk
==============================================================================
--- trunk/libs/thread/doc/futures.qbk	(original)
+++ trunk/libs/thread/doc/futures.qbk	2012-09-17 17:30:48 EDT (Mon, 17 Sep 2012)
@@ -70,6 +70,7 @@
 
 [template packaged_task_link[link_text] [link thread.synchronization.futures.reference.packaged_task [link_text]]]
 [def __packaged_task__ [packaged_task_link `boost::packaged_task`]]
+[def __packaged_task [packaged_task_link `boost::packaged_task`]]
 
 [template wait_for_any_link[link_text] [link thread.synchronization.futures.reference.wait_for_any [link_text]]]
 [def __wait_for_any__ [wait_for_any_link `boost::wait_for_any()`]]

Modified: trunk/libs/thread/doc/mutex_concepts.qbk
==============================================================================
--- trunk/libs/thread/doc/mutex_concepts.qbk	(original)
+++ trunk/libs/thread/doc/mutex_concepts.qbk	2012-09-17 17:30:48 EDT (Mon, 17 Sep 2012)
@@ -75,7 +75,7 @@
 [endsect]
 [section:lockable `Lockable` Concept]
 
-A type `L` meets the __Lockable requirements if it meets the __BasicLocable requirements and the following expressions are well-formed and have the specified semantics (`m` denotes a value of type `L`):
+A type `L` meets the __Lockable requirements if it meets the __BasicLockable requirements and the following expressions are well-formed and have the specified semantics (`m` denotes a value of type `L`):
 
 * `m.__try_lock()`
 
@@ -361,7 +361,7 @@
 * `m.__try_lock_upgrade_until(abs_time)`
 * `m.__unlock_and_lock_shared()`
 * `m.__unlock_and_lock_upgrade();`
-* `m.__unlock_upgrade_and_lock();`]
+* `m.__unlock_upgrade_and_lock();`
 * `m.__try_unlock_upgrade_and_lock()`
 * `m.__try_unlock_upgrade_and_lock_for(rel_time)`
 * `m.__try_unlock_upgrade_and_lock_until(abs_time)`
@@ -1070,7 +1070,7 @@
 
 [[Requires:] [The supplied `Mutex` type must implement `__try_unlock_shared_and_lock()`.]]
 
-[[Effects:] [Constructs an object of type __unique_lock. Let `pm` be and `owns` the ownership state. Initializes `pm` with nullptr and `owns` with false. 
+[[Effects:] [Constructs an object of type __unique_lock. Let `pm` be the pointer to the mutex and `owns` the ownership state. Initializes `pm` with nullptr and `owns` with false. 
 If `sl.__owns_lock()` returns `false`, sets `pm` to the return value of `sl.release()`. 
 Else `sl.__owns_lock()` returns `true`, and in this case if `sl.mutex()->try_unlock_shared_and_lock()` returns `true`, sets `pm` to the value returned by `sl.release()` and sets `owns` to `true`.]]
 
@@ -1096,8 +1096,8 @@
 [[Requires:] [The supplied `Mutex` type shall implement `__try_unlock_shared_and_lock_until(abs_time)`.]]
 
 [[Effects:] [Constructs an object of type `__unique_lock`, initializing `pm` with `nullptr` and `owns` with `false`. 
-If `sl.__owns_lock()` returns `false`, sets `pm` to the return value of `sl.__release()`. 
-Else `sl.owns_lock()` returns `true`, and in this case if `sl.mutex()->__try_unlock_shared_and_lock_until(abs_time)` returns `true`, sets `pm` to the value returned by `sl.release()` and sets `owns` to `true`.]]
+If `sl.__owns_lock_shared_ref__()` returns `false`, sets `pm` to the return value of `sl.release()`. 
+Else `sl.__owns_lock_shared_ref__()` returns `true`, and in this case if `sl.mutex()->__try_unlock_shared_and_lock_until(abs_time)` returns `true`, sets `pm` to the value returned by `sl.release()` and sets `owns` to `true`.]]
 
 [[Note:] [If `sl.owns_lock()` returns `true` and `sl.mutex()-> __try_unlock_shared_and_lock_until(abs_time)` returns `false`, `sl` is not modified.]]
 
@@ -1120,7 +1120,7 @@
 [[Requires:] [The supplied `Mutex` type shall implement `__try_unlock_shared_and_lock_for(rel_time)`.]]
 
 [[Effects:] [Constructs an object of type `__unique_lock`, initializing `pm` with `nullptr` and `owns` with `false`. 
-If `sl.__owns_lock()` returns `false`, sets `pm` to the return value of `sl.__release()`. 
+If `sl.__owns_lock()` returns `false`, sets `pm` to the return value of `sl.release()`. 
 Else `sl.owns_lock()` returns `true`, and in this case if `sl.mutex()-> __try_unlock_shared_and_lock_for(rel_time)` returns `true`, sets `pm` to the value returned by `sl.release()` and sets `owns` to `true`.]]
 
 [[Note:] [If `sl.owns_lock()` returns `true` and `sl.mutex()-> __try_unlock_shared_and_lock_for(rel_time)` returns `false`, `sl` is not modified.]]
@@ -1721,7 +1721,7 @@
 the constructor parameter. On destruction, the ownership is released. This
 provides simple RAII-style locking of a __shared_lockable_concept_type__ object, to facilitate exception-safe
 shared locking and unlocking. 
-In addition, the `__shared_lock_guard_ca(SharedLockable &m, boost::adopt_lock_t)` constructor allows the __shared_lock_guard object to
+In addition, the `__shared_lock_guard_constructor_adopt(SharedLockable &m, boost::adopt_lock_t)` constructor allows the __shared_lock_guard object to
 take shared ownership of a lock already held by the current thread.
 
 [section:constructor `shared_lock_guard(SharedLockable & m)`]
@@ -1792,9 +1792,9 @@
 
 [variablelist
 
-[[Effects:] [Stores a reference to `m`. Invokes `m.__unlock()` if `m` owns his lock and then stores the mutex by calling `m.__release()`.]]
+[[Effects:] [Stores a reference to `m`. Invokes `m.__unlock()` if `m` owns his lock and then stores the mutex by calling `m.release()`.]]
 
-[[Postcondition:] [`!m.__owns_lock() && m.__mutex()==0`.]]
+[[Postcondition:] [`!m.__owns_lock() && m.mutex()==0`.]]
 
 [[Throws:] [Any exception thrown by the call to `m.__unlock()`.]]
 

Modified: trunk/libs/thread/doc/thread.qbk
==============================================================================
--- trunk/libs/thread/doc/thread.qbk	(original)
+++ trunk/libs/thread/doc/thread.qbk	2012-09-17 17:30:48 EDT (Mon, 17 Sep 2012)
@@ -135,6 +135,7 @@
 
 [template owns_lock_ref_link[link_text] [link thread.synchronization.locks.unique_lock.owns_lock [link_text]]]
 [def __owns_lock_ref__ [owns_lock_ref_link `owns_lock()`]]
+[def __owns_lock [owns_lock_ref_link `owns_lock()`]]
 
 [template owns_lock_shared_ref_link[link_text] [link thread.synchronization.locks.shared_lock.owns_lock [link_text]]]
 [def __owns_lock_shared_ref__ [owns_lock_shared_ref_link `owns_lock()`]]
@@ -158,11 +159,13 @@
 
 [def __lock_guard__ [link thread.synchronization.locks.lock_guard `boost::lock_guard`]]
 [def __unique_lock__ [unique_lock_link `boost::unique_lock`]]
+[def __unique_lock [unique_lock_link `boost::unique_lock`]]
 [def __shared_lock__ [link thread.synchronization.locks.shared_lock `boost::shared_lock`]]
 [def __upgrade_lock__ [link thread.synchronization.locks.upgrade_lock `boost::upgrade_lock`]]
 [def __upgrade_to_unique_lock__ [link thread.synchronization.locks.upgrade_to_unique_lock `boost::upgrade_to_unique_lock`]]
 [def __reverse_lock [link thread.synchronization.other_locks.reverse_lock `reverse_lock`]]
 [def __shared_lock_guard [link thread.synchronization.other_locks.shared_lock_guard `shared_lock_guard`]]
+[def __shared_lock_guard_constructor_adopt [link thread.synchronization.other_locks.shared_lock_guard `shared_lock_guard`]]
 
 
 [def __thread__ [link thread.thread_management.thread `boost::thread`]]