Boost-Commit :

Date view	Thread view	Subject view	Author view

From: bdawes_at_[hidden]
Date: 2007-10-14 20:13:38

Next message: lists.drrngrvy_at_[hidden]: "[Boost-commit] svn:boost r40038 - in sandbox/boost_docs/branches/spirit_qbking: . doc doc/src"
Previous message: daniel_james_at_[hidden]: "[Boost-commit] svn:boost r40036 - trunk/boost/functional/hash"

Author: bemandawes
Date: 2007-10-14 20:13:37 EDT (Sun, 14 Oct 2007)
New Revision: 40037
URL: http://svn.boost.org/trac/boost/changeset/40037

Log:
Issue checked in Pete_comments.html have been addressed in library_thread.html
Text files modified:
   sandbox/committee/LWG/Pete_comments.html | 78 +++
   sandbox/committee/LWG/thread_library.html | 767 ++++++++++++++++++---------------------
   2 files changed, 409 insertions(+), 436 deletions(-)

Modified: sandbox/committee/LWG/Pete_comments.html
==============================================================================
--- sandbox/committee/LWG/Pete_comments.html (original)
+++ sandbox/committee/LWG/Pete_comments.html 2007-10-14 20:13:37 EDT (Sun, 14 Oct 2007)
@@ -12,10 +12,13 @@
✔ This is much better, but it's still in draft stage, not ready yet for voting
into the WD. Comments:
<ol>
- <li>the description of the meaning of thread::id is distributed among several
+ <li>✔ The description of the meaning of thread::id is distributed among several
 different clauses, and it's hard to figure out just what it means. 
+ 
+ Centralized the description of the meaning in the introduction to class
+ thread::id. 
 </li>
- <li>the description of thread::native_handle_type and native_handle() is so
+ <li>✔ The description of thread::native_handle_type and native_handle() is so
 vague (appropriately so) that it might be better to leave it out completely.
 Since you can't do anything meaningful with it if it's present, just leave it
 up to the implementation to tell you what it supports and what you can do with
@@ -23,39 +26,58 @@
 stays in, it's overconstrained. In particular, if it's copyable, this requires
 copying it to pass it to the OS, even if the OS takes a pointer to that
 object. Just leave it to the implementation to match what the OS requires. 
+ 
+ Removed normative wording, following the above rationale. Added a note to
+ clarify intent. 
 </li>
- <li>objects of type thread::id "uniquely identify" threads of execution.
+ <li>✔ Objects of type thread::id "uniquely identify" threads of execution.
 Except that they don't, because default-constructed objects compare equal, and
 the id returned from a thread that is not joinable also compares equal to a
 default-constructed object. 
+ 
+ Modified wording to resolve inconsistencies. Also defined thread::get_id()
+ in terms of this_thread::get_id() so that there is not possibility that
+ thread::get_id() and this_thread::get_id() for the same thread could return
+ different values. It's poor standardese to specify the same thing in two
+ places, since the specifications could diverge over time. 
 </li>
- <li>thread::get_id() for a default-constructed thread returns an object that
+ <li>✔ thread::get_id() for a default-constructed thread returns an object that
 refers to "not any thread". That last term isn't used anywhere else, so
 shouldn't be used. 
 </li>
- <li>default constructor for thread constructs an object that is not "attached"
+ <li>✔ Default constructor for thread constructs an object that is not "attached"
 to any thread; other constructors create objects that "represent" a thread.
 Assignment operator talks about an object that "refers" to a thread. 
+ 
+ Changed both to use "represents". 
 </li>
- <li>template constructor for thread: "if f is an rvalue, F must only be
+ <li>✔ Template constructor for thread: "if f is an rvalue, F must only be
 MoveConstructible". Does this mean that F must not be CopyConstructible? 
+ 
+ I changed both sentences to: "If <tt>f</tt> is an lvalue, <tt>F</tt> is <tt>CopyConstructible</tt>.
+If <tt>f</tt> is an rvalue, <tt>F</tt> is <tt>MoveConstructible</tt>."
+ Howard, please verify that's the
+ intended meaning. 
+ </li>
+ <li>✔ Thread::join "may throw system_error". Under what circumstances? 
+ 
+ Refined wording in the chapter's front matter, added additional wording for
+ specific cases. 
 </li>
- <li>thread::join "may throw system_error". Under what circumstances? 
+ <li>✔ call_once: "F is CopyConstructible", but F is not defined. 
 </li>
- <li>call_once: "F is CopyConstructible", but F is not defined. 
- </li>
- <li>Mutex concepts: mutex type is required to be Destructible, so requirement
+ <li>✔ Mutex concepts: mutex type is required to be Destructible, so requirement
 that its destructor not exit by an exception is redundant. 
 </li>
 <li>"If and only if the mutex type ...", followed by "If there is no ..."
 which is the obverse. Either use iff and only if, or use if ... else. 
 </li>
- <li>"Implementations may supply additional ..." is entirely redundant. 
+ <li>✔ "Implementations may supply additional ..." is entirely redundant. 
 </li>
- <li>"The class mutex is a ...", but "The class recursive_mutex shall be a
+ <li>✔ "The class mutex is a ...", but "The class recursive_mutex shall be a
 ...". 
 </li>
- <li>Timed Mutexes: "The type TimeDuration provides resolution information..."
+ <li>✔ Timed Mutexes: "The type TimeDuration provides resolution information..."
 doesn't sound like a precondition, but an informative description. To the
 extent that it's actually a precondition, it's a little fuzzy whether it only
 applies to non-recursive mutexes. 
@@ -96,22 +118,44 @@
 <li>condition_variable::wait: "... unless lock refers to the same underlying
 mutex object." Same as what? 
 </li>
- <li>condition_variable::wait, effects: "If the wait should throw an
+ <li>✔ condition_variable::wait, effects: "If the wait should throw an
 exception..." probably should be "If the wait throws an exception...". "for
 any reason" is redundant. "This thread of execution shall unblock ..." is part
 of the effects of notify and notify_all, not of wait. 
+ 
+ Since those effects were already specified in the effects of notify and
+ notify_all, the offending sentence was simply removed from wait(). 
 </li>
- <li>condition_variable::wait, throws: can throw only if a precondition is not
+ <li>condition_variable::wait [and timed_wait], throws: can throw only if a precondition is not
 met? What if the system returns an error? 
 </li>
- <li>condition_variable::wait(lock, pred): what are the constraints on the type
+ <li>✔ condition_variable::wait(lock, pred): what are the constraints on the type
 Predicate? 
+ 
+ Added the usual boilerplate wording to the front matter for the clause.
+ Ditto date-time clause, which was also missing the boilerplate. 
 </li>
 <li>condition_variable::timed_wait: the requirement that the function return
 false if the time elapses means that when a blocked thread is released by
 notify, the release code must check whether the time has elapsed, since the
 timeout may not have been noticed earlier. Is this intentional? Seems more
- useful to allow it to return true in this case.</li>
+ useful to allow it to return true in this case. 
+ </li>
+ <li>✔ Use "thread" to describe a "thread of execution". Use the term "thread
+ object" to describe objects of class thread. (Added by Beman, based on
+ guidance from Pete.) 
+ </li>
+ <li>✔ condition_variable::wait and time_wait specify "Throws: May throw <tt>system_error</tt> if a precondition is not met."
+ That's redundant since precondition violations can always result in an
+ exception. (Added by Beman) 
+ 
+ Removed. But also see 26. 
+ </li>
+ <li>"Common duration functions" needs to be morphed into "<code>Duration</code>
+ requirements" to resolve issue 13. In general, the current standard has no
+ concept of "concept". All concepts in the document need to be changed into
+ requirements. i.e. "Mutex concepts" -> "Mutex requirements".  (Added by
+ Beman.)</li>
</ol>

</body>

Modified: sandbox/committee/LWG/thread_library.html
==============================================================================
--- sandbox/committee/LWG/thread_library.html (original)
+++ sandbox/committee/LWG/thread_library.html 2007-10-14 20:13:37 EDT (Sun, 14 Oct 2007)
@@ -55,7 +55,7 @@
<a href="mailto:nick_at_[hidden]">Nick Stoughton</a>,
<a href="mailto:bdawes_at_[hidden]">Beman Dawes</a>
 
-2007-10-06
+2007-10-11
</address>
<hr/>
<h1 align="center">Multi-threading Library for Standard C++</h1>
@@ -100,8 +100,7 @@
<blockquote>
 Header <code>functional</code> synopsis

- <pre>
- namespace std {
+ <pre> namespace std {
 ...
 // Hash function specializations
 ...
@@ -135,9 +134,10 @@
<hr/>


-The following subclauses describe components to create and manage
-threads of execution [intro.execution? (N2334)], perform mutual exclusion and locking, and communicate
-between threads of execution.
+The following subclauses describe components to create and manage threads ([Reference
+to the new section from N2429 to be inserted between 1.9 and 1.10, titled
+"Multi-threaded executions and data races"]), perform mutual exclusion and locking, and communicate
+between threads.

<table style="border-collapse: collapse;" border="1" bordercolor="#111111" cellpadding="5" cellspacing="0" width="100%">
 <tbody><tr>
@@ -159,12 +159,24 @@
</tbody></table>


-Some functions
+Throughout this clause, the names of template parameters are used to express
+type requirements. The requirements for Duration parameters are specified in [reference
+to date-time library clause]. If a parameter is Predicate, <code>operator()</code>
+applied to the actual template argument shall return a value that is convertible
+to <code>bool</code>.
+
+
+Implementations of functions described in this clause are permitted to call
+operating system or other low-level applications program interfaces (API's). Some functions
described in this clause are specified to throw exceptions of type <tt>system_error</tt>
-([syserr.syserr]). The <tt>error_category</tt> ([syserr.errcat.overview])
-of the <tt>error_code</tt> reported by such exceptions <tt>code()</tt>
+([syserr.syserr]). Such exceptions shall be thrown when one of these operating
+system or other low-level API calls result in an error.
+
+
+The <tt>error_category</tt> ([syserr.errcat.overview])
+of the <tt>error_code</tt> reported by such an exception's <tt>code()</tt>
member function is implementation-defined. [Note: The category is
-typically <tt>native_category</tt> ([syserr.errcat.overview]) since these error
+typically <tt>system_category</tt> ([syserr.errcat.overview]) since these error
codes usually originate from the underlying operating system application program
interface (API). -- end note]

@@ -189,8 +201,8 @@
 thread::id get_id();

 void yield();
- template <class TimeDuration>
- void sleep(const TimeDuration& rel_t);
+ template <class Duration>
+ void sleep(const Duration& rel_t);

} // this_thread

@@ -211,10 +223,10 @@
<h4>Class thread</h4>


-An object of class <code>thread</code> manages a thread of execution.
-It provides a mechanism to create a new thread of execution,
-for the current thread of execution to wait for
-completion of a thread of execution, and to perform other operations to manage and query the state of the thread of execution.
+An object of class <code>thread</code> represents and manages a thread.
+It provides a mechanism to create a new thread,
+for the current thread to wait for
+completion of a thread, and to perform other operations to manage and query the state of the thread.


<blockquote><pre>class thread
@@ -251,26 +263,9 @@
classes (chapter 9 [class]).


-
-If and only if the <tt>thread</tt> type is internally represented
-by a single data structure which can be passed to operating system
-specific interfaces, there shall be a nested implementation-defined
-typedef <tt>native_handle_type</tt> that is an alias to this native
-type if it is copyable. Otherwise, if the native type is not copyable,
-it is a pointer to this native type. The implementation shall document
-whether the <tt>native_handle_type</tt> typedef is present.
-
-
-
-If the nested typedef <tt>native_handle_type</tt> exists, then there
-also shall be a member function <tt>native_handle()</tt> which returns the
-underlying representation.
-
-
<h5><tt>thread</tt> types</h5>
<h6>Class <tt>thread::id</tt></h6>
-<pre>
- class thread::id
+<pre> class thread::id
 {
 public:
 id();
@@ -288,19 +283,26 @@
 operator<< (basic_ostream<charT, traits>&& out, const thread::id& id);

</pre>
- Objects of type <tt>thread::id</tt> uniquely identify threads of execution.
+ Objects of type <tt>thread::id</tt> represent the identity of threads. Each
+joinable thread has a unique identity. All non-joinable threads share the same
+identity, and this identify is different from that of any joinable thread.
+
+
+[Note: Relational operators allows <tt>thread::id</tt> objects to be used as keys in associative containers. --end note]
+

<blockquote><pre>id();
</pre>

<blockquote>

-Effects: Constructs an object of type <tt>id</tt> which compares
-equal to other default constructed <tt>id</tt> objects.
+Effects: Constructs an object of type <tt>id</tt>.


Throws: Nothing.

+
+Postcondition: Represents the non-joinable identity.
</blockquote>
</blockquote>

@@ -309,9 +311,8 @@

<blockquote>

-Returns: If neither <tt>x</tt> nor <tt>y</tt> identifies
-a thread of execution, returns <tt>true</tt>. Otherwise if
-<tt>x</tt> and <tt>y</tt> identify the same thread of execution,
+Returns: If
+<tt>x</tt> and <tt>y</tt> represent the same identity,
returns <tt>true</tt>. Otherwise returns <tt>false</tt>.


@@ -343,9 +344,6 @@
Returns: a value such that <tt>operator<</tt> is a total ordering as described in [alg.sorting].


-[Note: Defining a comparison operator allows <tt>thread::id</tt> objects to be used as keys in associative containers. --end note]
-
-
Throws: Nothing.

</blockquote>
@@ -409,22 +407,19 @@
</pre>
<blockquote>

-Effects: Constructs a <tt>thread</tt> object not attached to any thread
-of execution. [Note: This is the state of a <tt>thread</tt>
-object after <tt>detach</tt> or <tt>join</tt> is successfully called. -- end note]
+Effects: Constructs a <tt>thread</tt> object that does not represent an
+actual thread.


Postconditions:

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

-Remarks: <tt>get_id()</tt> returns an identity that refers to
-not any thread. This identity compares equal to other
-non-<tt>join</tt>able <tt>thread</tt>s, and compares not equal to all
-other <tt>join</tt>able <tt>thread</tt>s.
-
+[Note: This is also the state of a <tt>thread</tt>
+object after <tt>detach</tt> or <tt>join</tt> is successfully called. -- end note]
+</blockquote>

Throws: Nothing.

@@ -436,13 +431,14 @@

<blockquote>

-Requires: <tt>F</tt> is a callable type [func.def]. If <tt>f</tt> is an lvalue, <tt>F</tt> must be <tt>CopyConstructible</tt>.
-If <tt>f</tt> is an rvalue, <tt>F</tt> must only be <tt>MoveConstructible</tt>.
+Requires: <tt>F</tt> is a callable type [func.def]. If <tt>f</tt> is an lvalue, <tt>F</tt>
+is <tt>CopyConstructible</tt>.
+If <tt>f</tt> is an rvalue, <tt>F</tt> is <tt>MoveConstructible</tt>.
[Crowl: Is this enforced by code?]


Effects: Constructs an object of type <tt>thread</tt> and executes <tt>INVOKE(f, t1, t2, ..., tN)</tt>
-in a new thread of execution, where <tt>t1, t2,
+in a new thread, where <tt>t1, t2,
..., tN</tt> are the values in <tt>args...</tt>.
Any return value from <tt>f</tt> is ignored.
If <tt>f</tt> terminates with an uncaught
@@ -454,10 +450,10 @@
<blockquote><pre>get_id() != thread::id()
&& joinable() == true
</pre>
-<code>*this</code> represents the newly started thread of execution.
+<code>*this</code> represents the newly started thread.
</blockquote>

-Throws: <tt>system_error</tt> if unable to start the new thread of execution.
+Throws: <tt>system_error</tt> if unable to start the new thread.

</blockquote>
</blockquote>
@@ -503,7 +499,7 @@

<blockquote>

-Effects: If <tt>this</tt> currently refers to a <tt>joinable</tt> thread object, calls
+Effects: If <tt>this</tt> currently represents a <tt>joinable</tt> thread object, calls
<tt>detach()</tt>. Then assigns the state of <tt>x</tt> to <tt>*this</tt>
and sets <tt>x</tt> to a default constructed state.

@@ -556,7 +552,7 @@
Preconditions: <tt>joinable()</tt> is <tt>true</tt>.


-Effects: The current thread of execution blocks until the thread of execution
+Effects: The current thread blocks until the thread
represented by <code>*this</code> completes.
[Crowl: I.e. upon completion the thread does on a release
on a memory location that the joiner does an acquire on.
@@ -564,12 +560,13 @@


Postconditions: After a normal return of <tt>join()</tt>,
-<tt>joinable()</tt> is <tt>false</tt>. If <tt>join()</tt> throws an exception, the thread of execution represented by
+<tt>joinable()</tt> is <tt>false</tt>. If <tt>join()</tt> throws an exception, the thread represented by
<tt>*this</tt> remains <tt>joinable</tt>.



-Throws: May throw <tt>system_error</tt>.
+Throws: <code>system_error</code> when an error condition occurs. The
+possible error conditions are implementation defined. 

</blockquote>
</blockquote>
@@ -582,15 +579,15 @@
Preconditions: <tt>joinable()</tt> is <tt>true</tt>.


-Effects: The thread of execution represented by
-<tt>*this</tt> continues execution. When the thread of execution represented by
+Effects: The thread represented by
+<tt>*this</tt> continues execution. When the thread represented by
<tt>*this</tt> ends execution it shall release any owned resources.
[Crowl: The programmer shall or the implementation shall?
Which resources?]


Postconditions: <tt>joinable()</tt> is <tt>false</tt>. <tt>*this</tt>
-does not represent a thread of execution.
+does not represent a thread.


Throws: Nothing.
@@ -603,11 +600,10 @@

<blockquote>

-Returns: An object of type <tt>thread::id</tt> which identifies the thread of execution
+Returns:
+<tt>this_thread::get_id()f</tt>or the thread
represented by
-<tt>*this</tt>. If this
-<tt>thread</tt> is not <tt>joinable()</tt> returns a default constructed <tt>thread::id</tt>.
-
+<tt>*this.</tt>

Throws: Nothing.

@@ -619,8 +615,11 @@

<blockquote>

-Returns: The underlying representation of the thread object.
-
+Returns: An object of an implementation-defined type. [Note: The
+intent is that <code>native_handle()</code> provides access to the underlying
+implementation, to allow use of implementation specific facilities. Code that
+relies on implementation specific facilities is inherently non-portable. --
+end note]

Throws: Nothing.

@@ -633,7 +632,7 @@

<blockquote>

-Returns: The number of threads of execution that can reasonably be expected to
+Returns: The number of threads that can reasonably be expected to
execute concurrently. [Note: This value should only be considered to be a hint.
--end note] If this value is not computable or well defined a
return value of 1 is recommended, but not required.
@@ -666,8 +665,8 @@
 thread::id get_id();

 void yield();
- template <class TimeDuration>
- void sleep(const TimeDuration& rel_t);
+ template <class Duration>
+ void sleep(const Duration& rel_t);

} // this_thread
</pre></blockquote>
@@ -677,8 +676,9 @@

<blockquote>

-Returns: Returns an object of type <tt>thread::id</tt> that uniquely identifies the current thread of execution. The object returned shall not compare equal to a default constructed <tt>thread::id</tt>.
-
+Returns: If the current thread is joinable, returns an object of type <tt>thread::id</tt> that uniquely identifies the current thread
+and does not compare equal to a default constructed <tt>thread::id</tt>, else returns
+a default constructed <tt>thread::id</tt>

Throws: Nothing.

@@ -690,23 +690,23 @@

<blockquote>

-Effects: Offers the operating system the opportunity to schedule another thread of execution.
+Effects: Offers the operating system the opportunity to schedule another thread.

Throws: Nothing.

</blockquote>
</blockquote>

-<blockquote><pre>template <class TimeDuration>
- void sleep(const TimeDuration& rel_t);
+<blockquote><pre>template <class Duration>
+ void sleep(const Duration& rel_t);
</pre>

<blockquote>

-Requires: <tt>TimeDuration</tt> shall be explicitly convertible to <tt>nanoseconds</tt>.
+Requires: <tt>Duration</tt> shall be explicitly convertible to <tt>nanoseconds</tt>.


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


Throws: Nothing.
@@ -746,10 +746,9 @@

 <blockquote>

- Requires: If the <code>Callable</code> argument <code>func</code> is an lvalue, <code>F</code>
+ Requires: If <code>func</code> is an lvalue, Callable
 is
- <code>CopyConstructible</code>. Otherwise, <code>func</code> is an rvalue, <code>
- and F</code> is
+ <code>CopyConstructible</code>. If <code>func</code> is an rvalue, Callable is
 <code>MoveConstructible</code>. Copying or moving (as appropriate) shall have no side effects, and the effect of calling the
 copy shall be equivalent to calling the original.

@@ -758,8 +757,8 @@
 <code>func(args)</code>,<code> </code>even if <code>call_once</code> is
 called multiple times for the same <code>once_flag</code> object. If multiple
 calls to <code>call_once</code> with the same <code>once_flag</code> object
- occur in separate threads of execution, only one
- thread of execution shall call <code>func</code>, and none shall proceed until the call to <code>func</code> has completed.
+ occur in separate threads, only one
+ thread shall call <code>func</code>, and none shall proceed until the call to <code>func</code> has completed.
[Crowl: I.e. the return of <code>func</code> happens before
the return of <code>call_once</code>.]
 If the invocation of <code>func</code> results in an exception being thrown,
@@ -769,7 +768,7 @@
 Throws: <code>system_error</code> or any exception propagated from <code>func</code>.

 Thread safety: Access to the same <code>once_flag</code> object by
- calls to <code>call_once</code> from different threads of execution shall
+ calls to <code>call_once</code> from different threads shall
 not result in a data race or deadlock.
[Crowl: The implementation shall not introduce these.]

@@ -841,11 +840,10 @@


Mutex objects provide synchronization operations to avoid data races. A
-mutex object supports mutual exclusion between threads of execution by
-limiting its ownership to a single thread of execution. A thread of
-execution obtains ownership of a mutex object by calling <tt>lock()</tt>
+mutex object supports mutual exclusion between threads by
+limiting its ownership to a single thread. A thread obtains ownership of a mutex object by calling <tt>lock()</tt>
and relinquishes ownership by calling <tt>unlock()</tt>. The
-thread of execution that calls <tt>lock()</tt> for a mutex object shall
+thread that calls <tt>lock()</tt> for a mutex object shall
call <tt>unlock()</tt>. Mutexes may be either recursive or
non-recursive. The syntax is the same for both recursive and
non-recursive mutexes, but the semantics differ for the member functions
@@ -854,8 +852,7 @@


A mutex type shall be <tt>DefaultConstructible</tt> and <tt>Destructible</tt>. If initialization
-of a mutex type fails, an exception of type <tt>system_error</tt> shall be thrown. The destructor
-of a mutex type shall not exit by an exception.
+of a mutex type fails, an exception of type <tt>system_error</tt> shall be thrown.
A mutex type is neither copyable
nor movable. A mutex type shall have the following member functions:

@@ -865,16 +862,16 @@
</pre>
<blockquote>

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


-Effects: The current thread of execution will block until the mutex is not owned by another thread of execution.
+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 of execution owns the mutex.
+Upon successful completion, the current thread owns the mutex.


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

Thread safety: This is an acquire operation.

@@ -886,7 +883,7 @@
</pre>
<blockquote>

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


Effects:
@@ -922,7 +919,7 @@
</pre>
<blockquote>

-Precondition: The current thread of execution shall own the mutex.
+Precondition: The current thread shall own the mutex.


Effects: For a non-recursive mutex ownership is released. For a recursive mutex
@@ -939,45 +936,52 @@
</blockquote>


-If and only if the mutex type is internally represented by a single data structure
+If and only if the mutex type is internally represented by a single data structure
which can be passed to operating system specific interfaces, then there shall be a nested
-implementation-defined typedef <tt>native_handle_type</tt> that is an alias to this native type if it is copyable,
+implementation-defined typedef <tt>
+native_handle_type</tt> that is an alias to this native type if it is copyable,
otherwise if the native type is not copyable, is a pointer to this native type.
-The implementation shall document whether the <tt>native_handle_type</tt>
-typedef is present.
+The implementation shall document whether the <tt>
+native_handle_type</tt>
+typedef is present. 



-If the nested typedef <tt>native_handle_type</tt> exists, then there
-also shall be a member function <tt>native_handle()</tt> which returns <tt>
-native_handle_type</tt>. [Example:
+If the nested typedef <tt>
+native_handle_type</tt> exists, then there
+also shall be a member function <tt>
+native_handle()</tt> which returns
+ <tt>
+native_handle_type</tt>.
+ [Example:
+


-<blockquote><pre>class mutex
+<blockquote><pre>class mutex
{
- pthread_mutex_t m;
+ pthread_mutex_t m;
public:
- typedef pthread_mutex_t* native_handle_type;
+ typedef pthread_mutex_t* native_handle_type;
 native_handle_type native_handle() {return &m;}
 ...
};
-</pre>
---end example]
+</pre>
+--end example]
</blockquote>


-If there is no single operating system specific data structure that implements
-the mutex type, then neither the nested type <tt>native_handle_type</tt> nor the
-member function <tt>native_handle()</tt> shall not be present. [Example:
-if a <tt>recursive_mutex</tt> is implemented with both a <tt>pthread_mutex_t</tt>
-and a separate lock count, then there will be no <tt>native_handle_type</tt>. 
---end example]
-
-
-
-Implementations may supply additional implementation-defined constructors
-which allow further customization as afforded by the implementation
-or its environment.
+If there is no single operating system specific data structure that implements
+the mutex type, then neither the nested type <tt>
+native_handle_type</tt> nor the
+member function <tt>native_handle()</tt> shall not be present.
+ [Example:
+if a <tt>recursive_mutex</tt> is implemented with both a
+ <tt>pthread_mutex_t</tt>
+and a separate lock count, then there will be no <tt>
+native_handle_type</tt>.
+ 
+--end example]
+


<h4>Class mutex</h4>
@@ -1005,7 +1009,7 @@
</pre></blockquote>


-The class <tt>mutex</tt> is a non-recursive mutex which satisfies all of the Mutex requirements.
+The class <tt>mutex</tt> provides a non-recursive mutex type which satisfies all of the Mutex requirements.
It shall be a standard-layout class (chapter 9 [class]).


@@ -1034,26 +1038,24 @@
</pre></blockquote>


-The class <tt>recursive_mutex</tt> shall be a recursive mutex which satisfies all of the Mutex requirements.
+The class <tt>recursive_mutex</tt> provides a recursive mutex type which satisfies all of the Mutex requirements.
It shall be a standard-layout class (chapter 9 [class]).


-<h3>Timed Mutexes</h3>
+<h3>Timed Mutex concept</h3>


-Types that meet the requirements of the Timed Mutex concept also meet the requirements of the Mutex concept
-and add a single member function:
-
+To meet the requirements of the Timed Mutex concept, types are required to meet the requirements of the Mutex concept
+and to provide the member function <code>timed_lock</code>.

<blockquote>
-<pre>template <class TimeDuration>
- bool timed_lock(const TimeDuration& rel_time);
+<pre>template <class Duration>
+ bool timed_lock(const Duration& rel_time);
</pre>
<blockquote>

-Precondition: For non-recursive mutexes the current thread of execution shall not own the mutex.
-The type <tt>TimeDuration</tt> provides resolution information (ticks_per_second) that allows conversion
-of the specified value into the native time resolution.
+Precondition: For non-recursive mutexes the current thread shall not own
+the mutex. .
[Crowl: Roundup here instead of under various locks.]


@@ -1100,8 +1102,8 @@

 void lock();
 bool try_lock();
- template <class TimeDuration>
- bool timed_lock(const TimeDuration& rel_time);
+ template <class Duration>
+ bool timed_lock(const Duration& rel_time);
 void unlock();

 typedef unspecified native_handle_type; // conditionally present. example: pthread_mutex_t*
@@ -1112,7 +1114,7 @@
</pre></blockquote>


-The class <tt>timed_mutex</tt> is a non-recursive mutex that satisfies all of the Timed Mutex requirements.
+The class <tt>timed_mutex</tt> provides a non-recursive mutex type that satisfies all of the Timed Mutex requirements.
It shall be a standard-layout class (chapter 9 [class]).


@@ -1131,8 +1133,8 @@

 void lock();
 bool try_lock();
- template <class TimeDuration>
- bool timed_lock(const TimeDuration& rel_time);
+ template <class Duration>
+ bool timed_lock(const Duration& rel_time);
 void unlock();

 typedef unspecified native_handle_type; // conditionally present. example: pthread_mutex_t*
@@ -1143,7 +1145,7 @@
</pre></blockquote>


-The class <tt>recursive_timed_mutex</tt> shall be a recursive mutex that satisfies all of the Timed Mutex requirements.
+The class <tt>recursive_timed_mutex</tt> provides a recursive mutex type that satisfies all of the Timed Mutex requirements.
It shall be a standard-layout class (chapter 9 [class]).


@@ -1217,7 +1219,7 @@
</pre>
<blockquote>

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

@@ -1233,7 +1235,7 @@
</pre>
<blockquote>

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

@@ -1282,8 +1284,8 @@
 void lock();
 bool try_lock();

- template <class TimeDuration>
- bool timed_lock(const TimeDuration& rel_t);
+ template <class Duration>
+ bool timed_lock(const Duration& rel_t);
 bool timed_lock(const system_time& abs_time);

 void unlock();
@@ -1331,7 +1333,7 @@
</pre>
<blockquote>

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

@@ -1352,7 +1354,7 @@
</pre>
<blockquote>

-Precondition: If <tt>mutex_type</tt> is not a recursive mutex, the current thread of execution
+Precondition: If <tt>mutex_type</tt> is not a recursive mutex, the current thread
does not own the mutex.
The lifetime of <tt>m</tt> includes the lifetime of the <tt>
unique_lock</tt> object.
@@ -1374,7 +1376,7 @@
</pre>
<blockquote>

-Precondition: If <tt>mutex_type</tt> is not a recursive mutex, then the current thread of execution
+Precondition: If <tt>mutex_type</tt> is not a recursive mutex, then the current thread
does not own the mutex.
The lifetime of <tt>m</tt> includes the lifetime of the <tt>
unique_lock</tt> object.
@@ -1396,7 +1398,7 @@
</pre>
<blockquote>

-Precondition: The current thread of execution has ownership of the mutex <tt>m</tt>.
+Precondition: The current thread has ownership of the mutex <tt>m</tt>.
The lifetime of <tt>m</tt> includes the lifetime of the <tt>
unique_lock</tt> object.

@@ -1511,13 +1513,13 @@
</blockquote>

<blockquote>
-<pre>template <class TimeDuration>
- bool timed_lock(const TimeDuration& rel_t);
+<pre>template <class Duration>
+ bool timed_lock(const Duration& rel_t);
</pre>
<blockquote>

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


@@ -1697,8 +1699,8 @@


An object of class <tt>condition_variable</tt> is a synchronization primitive
-used to cause a thread of execution to wait until notified by some other
-thread of execution that some condition is met, or a UTC[(?)] time is reached.
+used to cause a thread to wait until notified by some other
+thread that some condition is met, or a UTC[(?)] time is reached.



@@ -1771,15 +1773,15 @@
</pre>
<blockquote>

-Effects: If any threads of execution are blocked waiting for <code>*this</code>,
-unblocks at least one those threads of execution.
+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
<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
-object from different threads of execution shall not result in data
+object from different threads shall not result in data
races or deadlocks.

</blockquote>
@@ -1790,14 +1792,14 @@
</pre>
<blockquote>

-Effects: Unblock all threads of execution that are blocked waiting for <code>*this</code>.
+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
<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
-object from different threads of execution shall not result in data
+object from different threads shall not result in data
races or deadlocks.

</blockquote>
@@ -1808,30 +1810,28 @@
</pre>
<blockquote>

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


Effects: Atomically blocks and releases the lock on
-<tt>lock</tt>. If the <tt>wait</tt> should throw an exception for any
-reason, <tt>lock</tt> will be locked as the exception propagates.
-This thread of execution shall unblock when another threadof execution issues a
-notification to this blocked thread of execution. The current thread of execution may
+<tt>lock</tt>. If the <tt>wait</tt> throws an exception, <tt>lock</tt> will be
+locked as the exception propagates. The current thread may
unblock and return even in the absence of a notification.
[Crowl: Needs to say acquire operation.]


Postcondition: <tt>lock</tt> is locked by the current
-thread of execution.
+thread.

-Throws: May throw <tt>system_error</tt> if a precondition is not met.
-
+Throws: ???
+See issue 26

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
-object from different threads of execution shall not result in data
+object from different threads shall not result in data
races or deadlocks.

</blockquote>
@@ -1846,8 +1846,8 @@
Effects: While <tt>pred()</tt> returns <tt>false</tt> calls <tt>wait(lock)</tt>.


-Note: There is no blocking if <tt>pred()</tt> is initially <tt>true</tt>.
-
+[Note: Does not block if <tt>pred()</tt> is initially <tt>true</tt>. 
+--end note]
</blockquote>
</blockquote>

@@ -1857,8 +1857,8 @@
</pre>
<blockquote>

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


@@ -1869,27 +1869,27 @@
is, system time equals or exceeds <tt>abs_time</tt>) before the
<tt>condition_variable</tt> is notified, or if the absolute time specified by
<tt>abs_time</tt> has already been passed at the time of the call, then
-<tt>false</tt> is returned. This thread of execution shall unblock when
-another thread of execution issues a notification to this blocked thread of execution. The current
-thread of execution may unblock and return even in the absence of a
+<tt>false</tt> is returned. This thread shall unblock when
+another thread issues a notification to this blocked thread. The current
+thread may unblock and return even in the absence of a
notification.


Postcondition: <tt>lock</tt> is locked by the current
-thread of execution.
+thread.

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


-Throws: May throw <tt>system_error</tt> if a precondition is not met.
-
+Throws: ???
+See issue 26

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
-object from different threads of execution shall not result in data
+object from different threads shall not result in data
races or deadlocks.
[Crowl: Needs to say acquire operation.
Too much about other operations here.]
@@ -1942,8 +1942,8 @@


An object of class <tt>condition_variable_any</tt> is a synchronization primitive
-used to cause a thread of execution to wait until notified by some other
-thread of execution that some condition is met, or a UTC[(?)] time is reached.
+used to cause a thread to wait until notified by some other
+thread that some condition is met, or a UTC[(?)] time is reached.



@@ -2024,13 +2024,13 @@
</pre>
<blockquote>

-Effects: If any threads of execution are blocked waiting for <code>*this</code>,
-unblocks at least one those threads of execution.
+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
<code>notify_all</code> member functions of the same <tt>condition_variable_any</tt>
-object from different threads of execution shall not result in data
+object from different threads shall not result in data
races or deadlocks.

</blockquote>
@@ -2047,7 +2047,7 @@
Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
<code>notify_all</code> member functions of the same <tt>condition_variable_any</tt>
-object from different threads of execution shall not result in data
+object from different threads shall not result in data
races or deadlocks.

</blockquote>
@@ -2058,30 +2058,31 @@
</pre>
<blockquote>

-Precondition: <tt>lock</tt> is locked by the current thread of execution. If
+Precondition: <tt>lock</tt> is locked by the current thread. If
<tt>Lock</tt> supports recursive locking, the lock count is one. No
-other thread of execution is waiting on this <tt>condition_variable_any</tt> object unless <tt>lock</tt>
+other thread is waiting on this <tt>condition_variable_any</tt> object unless <tt>lock</tt>
is, or refers to, the same underlying mutex object.


Effects: Atomically blocks and releases the lock on
<tt>lock</tt>. If the <tt>wait</tt> should throw an exception for any
reason, <tt>lock</tt> will be locked as the exception propagates.
-This thread of execution shall unblock when another thread of execution issues a
-notification to this blocked thread of execution. The current thread of execution may
+This thread shall unblock when another thread issues a
+notification to this blocked thread. The current thread may
unblock and return even in the absence of a notification.


Postcondition: <tt>lock</tt> is locked by the current
-thread of execution.
+thread.

-Throws: May throw <tt>system_error</tt>.
+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
<code>notify_all</code> member functions of the same <tt>condition_variable_any</tt>
-object from different threads of execution shall not result in data
+object from different threads shall not result in data
races or deadlocks.

</blockquote>
@@ -2107,9 +2108,9 @@
</pre>
<blockquote>

-Precondition: The <tt>lock</tt> is locked by the current thread of execution. If
+Precondition: The <tt>lock</tt> is locked by the current thread. If
<tt>Lock</tt> supports recursive locking, the lock count is one. No
-other thread of execution is waiting on this <tt>condition_variable_any</tt> object unless <tt>lock</tt>
+other thread is waiting on this <tt>condition_variable_any</tt> object unless <tt>lock</tt>
is, or refers to, the same underlying mutex object.


@@ -2120,27 +2121,28 @@
is, system time equals or exceeds <tt>abs_time</tt>) before the
<tt>condition_variable_any</tt> is notified, or if the absolute time specified by
<tt>abs_time</tt> has already been passed at the time of the call, then
-<tt>false</tt> is returned. This thread of execution shall unblock when
-another thread of execution issues a notification to this blocked thread of execution. The current
-thread of execution may unblock and return even in the absence of a
+<tt>false</tt> is returned. This thread shall unblock when
+another thread issues a notification to this blocked thread. The current
+thread may unblock and return even in the absence of a
notification.


Postcondition: <tt>lock</tt> is locked by the current
-thread of execution.
+thread.

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


-Throws: May throw <tt>system_error</tt>.
+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
<code>notify_all</code> member functions of the same <tt>condition_variable_any</tt>
-object from different threads of execution shall not result in data
+object from different threads shall not result in data
races or deadlocks.

</blockquote>
@@ -2197,6 +2199,11 @@
 1970-01-01 00:00:00.

+ Throughout this clause, the names of template parameters are used to express
+ type requirements. Define Duration,
+ RhsDuration
+
+
<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2411_07_0271___proposal_for_date_time_types_in_c__0x_to_support_threading_apis_v2.proposed_text.header__date_time__synopsis"></a>
Header <date_time> Synopsis</h3></div></div></div>

@@ -2263,17 +2270,17 @@
 //arithmetic functions
 nanoseconds operator-(const system_time& rhs) const

- template<typename TimeDuration>
- system_time operator+(const TimeDuration& td) const;
+ template<typename Duration>
+ system_time operator+(const Duration& td) const;

- template<typename TimeDuration>
- system_time& operator+=(const TimeDuration& td);
+ template<typename Duration>
+ system_time& operator+=(const Duration& td);

- template<typename TimeDuration>
- system_time operator-(const TimeDuration& td) const;
+ template<typename Duration>
+ system_time operator-(const Duration& td) const;

- template<typename TimeDuration>
- system_time& operator-=(const TimeDuration& td)
+ template<typename Duration>
+ system_time& operator-=(const Duration& td)

};
</pre></blockquote>
@@ -2308,78 +2315,67 @@
 Returns: The count of seconds since 1970-01-01 00:00:00.
 
 Throws: Nothing.
- <pre class="programlisting">
-nanoseconds nanoseconds_since_epoch() const;
+ <pre class="programlisting">nanoseconds nanoseconds_since_epoch() const;
</pre>
 Returns: The count of nanoseconds
 since 1970-01-01 00:00:00.
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type ticks_per_second();
+ <pre class="programlisting">static tick_type ticks_per_second();
</pre>
 Returns: 1000000000
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type seconds_per_tick();
+ <pre class="programlisting">static tick_type seconds_per_tick();
</pre>
 Returns: 0
 
 Remarks: Since this is a subsecond type it returns 0 for seconds_per_tick.
 
 Throws: Nothing.
- <pre class="programlisting">
-static bool is_subsecond();
+ <pre class="programlisting">static bool is_subsecond();
</pre>
 Returns: true.
 
 Throws: Nothing.
- <pre class="programlisting">
-bool operator==(const system_time& rhs) const;
+ <pre class="programlisting">bool operator==(const system_time& rhs) const;
</pre>
 Returns: True if
 the time
 represented by *this is equal to the time represented by rhs.
 
 Throws: Nothing.
- <pre class="programlisting">
-bool operator!=(const system_time& rhs) const;
+ <pre class="programlisting">bool operator!=(const system_time& rhs) const;
</pre>
 Returns: True if the time represented by *this is not equal to the time represented
 by rhs
 
 Throws: Nothing.
- <pre class="programlisting">
-bool operator>(const system_time& rhs) const;
+ <pre class="programlisting">bool operator>(const system_time& rhs) const;
</pre>
 Returns: True if time represented by
 *this is greater than the time represented by rhs.
 
 Throws: Nothing.
- <pre class="programlisting">
-bool operator>=(const system_time& rhs) const;
+ <pre class="programlisting">bool operator>=(const system_time& rhs) const;
</pre>
 Returns: True if time represented
 by *this is greater or equal than the time represented by rhs.
 
 Throws: Nothing.
- <pre class="programlisting">
-bool operator<(const system_time& rhs) const;
+ <pre class="programlisting">bool operator<(const system_time& rhs) const;
</pre>
 Returns: True if time represented by *this
 is less than the time represented by rhs.
 
 Throws: Nothing.
- <pre class="programlisting">
-bool operator<=(const system_time& rhs) const;
+ <pre class="programlisting">bool operator<=(const system_time& rhs) const;
</pre>
 Returns: True if time represented by *this
 is less or equal than the time represented by rhs.
 
 Throws: Nothing.
- <pre class="programlisting">
-nanoseconds operator-(const system_time& rhs) const
+ <pre class="programlisting">nanoseconds operator-(const system_time& rhs) const
</pre>
 Returns: 
 The difference in nanoseconds between the time represented by *this and the
@@ -2389,17 +2385,15 @@
 count.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename TimeDuration>
-system_time operator+(const TimeDuration& td) const;
+ <pre class="programlisting">template<typename Duration>
+system_time operator+(const Duration& td) const;
</pre>
 Returns: The duration converted to nanosecond resolution
 and added to the time represented by *this.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename TimeDuration>
-system_time& operator+=(const TimeDuration& td);
+ <pre class="programlisting">template<typename Duration>
+system_time& operator+=(const Duration& td);
</pre>
 Effects: Convert the duration to nanosecond resolution add to nanoseconds
 to the time represented by *this.
@@ -2407,17 +2401,15 @@
 Returns: Modified value of this.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename TimeDuration>
-system_time operator-(const TimeDuration& td) const;
+ <pre class="programlisting">template<typename Duration>
+system_time operator-(const Duration& td) const;
</pre>
 Returns: The duration converted to nanosecond resolution
 and subtracted from the time represented by *this.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename TimeDuration>
-system_time& operator-=(const TimeDuration& td)
+ <pre class="programlisting">template<typename Duration>
+system_time& operator-=(const Duration& td)
</pre>
 Effects: Convert the duration to nanosecond resolution subtract and
 from the time represented by *this.
@@ -2467,158 +2459,148 @@


-<blockquote><pre>
-class TimeDuration {
+<blockquote><pre>class Duration {

 //comparison operators
- template<typename RhsTimeDuration>
- bool operator< (const RhsTimeDuration&) const;
+ template<typename RhsDuration>
+ bool operator< (const RhsDuration&) const;

- template<typename RhsTimeDuration>
- bool operator<= (const RhsTimeDuration&) const;
+ template<typename RhsDuration>
+ bool operator<= (const RhsDuration&) const;

- template<typename RhsTimeDuration>
- bool operator> (const RhsTimeDuration&) const;
+ template<typename RhsDuration>
+ bool operator> (const RhsDuration&) const;

- template<typename RhsTimeDuration>
- bool operator>= (const RhsTimeDuration&) const;
+ template<typename RhsDuration>
+ bool operator>= (const RhsDuration&) const;

- template<typename RhsTimeDuration>
- bool operator== (const RhsTimeDuration&) const;
+ template<typename RhsDuration>
+ bool operator== (const RhsDuration&) const;

- template<typename RhsTimeDuration>
- bool operator!= (const RhsTimeDuration&) const;
+ template<typename RhsDuration>
+ bool operator!= (const RhsDuration&) const;

 //sign inversion
- TimeDuration operator-() const
+ Duration operator-() const

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

- template<typename RhsTimeDuration>
- TimeDuration operator-=(const RhsTimeDuration& d)
+ template<typename RhsDuration>
+ Duration operator-=(const RhsDuration& d)

- template<typename RhsTimeDuration>
- TimeDuration operator+ (const RhsTimeDuration& d) const
+ template<typename RhsDuration>
+ Duration operator+ (const RhsDuration& d) const

- template<typename RhsTimeDuration>
- TimeDuration operator+=(const RhsTimeDuration& d)
-
- TimeDuration operator/ (int divisor) const
- TimeDuration operator/=(int divisor)
- TimeDuration operator* (int rhs) const
- TimeDuration operator*=(int divisor)
+ template<typename RhsDuration>
+ Duration operator+=(const RhsDuration& d)
+
+ Duration operator/ (int divisor) const
+ Duration operator/=(int divisor)
+ Duration operator* (int rhs) const
+ Duration operator*=(int divisor)

 tick_type get_count() const

}
</pre></blockquote>

- <pre class="programlisting">
-template<typename RhsTimeDuration>
-bool operator==(const RhsTimeDuration& rhs) const;
+ <pre class="programlisting">template<typename RhsDuration>
+bool operator==(const RhsDuration& rhs) const;
</pre>
 Returns: True if rhs duration is greater.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename RhsTimeDuration>
-bool operator!=(const RhsTimeDuration& rhs) const;
+ <pre class="programlisting">template<typename RhsDuration>
+bool operator!=(const RhsDuration& rhs) const;
</pre>
 Returns: True if rhs is not the same time.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename RhsTimeDuration>
-bool operator>(const RhsTimeDuration& rhs) const;
+ <pre class="programlisting">template<typename RhsDuration>
+bool operator>(const RhsDuration& rhs) const;
</pre>
 Returns: True if the rhs duration is larger.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename RhsTimeDuration>
-bool operator>=(const RhsTimeDuration& rhs) const;
+ <pre class="programlisting">template<typename RhsDuration>
+bool operator>=(const RhsDuration& rhs) const;
</pre>
 Returns: True if greater or equal than the rhs duration.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename RhsTimeDuration>
-bool operator<(const RhsTimeDuration& rhs) const;
+ <pre class="programlisting">template<typename RhsDuration>
+bool operator<(const RhsDuration& rhs) const;
</pre>
 Returns: True if less than the rhs duration.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename RhsTimeDuration>
-bool operator<=(const RhsTimeDuration& rhs) const;
+ <pre class="programlisting">template<typename RhsDuration>
+bool operator<=(const RhsDuration& rhs) const;
</pre>
 Returns: True if less or equal to the rhs duration.
 
 Throws: Nothing.
- <pre class="programlisting">
-//sign inversion
-TimeDuration operator-() const
+ <pre class="programlisting">//sign inversion
+Duration operator-() const
</pre>
 Returns: Negated value of the duration.
 
 Throws: Nothing.
- <pre class="programlisting">
-//arithmetic operations
-template<typename RhsTimeDuration>
-TimeDuration operator- (const RhsTimeDuration& d) const
+ <pre class="programlisting">//arithmetic operations
+template<typename RhsDuration>
+Duration operator- (const RhsDuration& d) const
</pre>
 Returns: A duration value equal to this-rhs_duration.
 
- Remarks: This will fail to compiler if the RhsTimeDuration is
+ Remarks: This will fail to compiler if the
+ RhsDuration is
 of higher resolution.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename RhsTimeDuration>
-TimeDuration operator-=(const RhsTimeDuration& d)
+ <pre class="programlisting">template<typename RhsDuration>
+Duration operator-=(const RhsDuration& d)
</pre>
 Effects: Modifies to value equal to this-rhs_duration.
 
 Returns: this
 
- Remarks: This will fail to compiler if the RhsTimeDuration is
+ Remarks: This will fail to compiler if the
+ RhsDuration is
 of higher resolution.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename RhsTimeDuration>
-TimeDuration operator+ (const RhsTimeDuration& d) const
+ <pre class="programlisting">template<typename RhsDuration>
+Duration operator+ (const RhsDuration& d) const
</pre>
 Returns: Duration equal to this+rhs_duration.
 
- Remarks: This will fail to compiler if the RhsTimeDuration is
+ Remarks: This will fail to compiler if the
+ RhsDuration is
 of higher resolution.
 
 Throws: Nothing.
- <pre class="programlisting">
-template<typename RhsTimeDuration>
-TimeDuration operator+=(const RhsTimeDuration& d)
+ <pre class="programlisting">template<typename RhsDuration>
+Duration operator+=(const RhsDuration& d)
</pre>
 Effects: Modifies to value equal to this+rhs_duration.
 
 Returns: this
 
- Remarks: This will fail to compiler if the RhsTimeDuration is
+ Remarks: This will fail to compiler if the
+ RhsDuration is
 of higher resolution.
 
 Throws: Nothing.
- <pre class="programlisting">
-TimeDuration operator/ (int divisor) const
+ <pre class="programlisting">Duration operator/ (int divisor) const
</pre>
 Returns: Duration with value equal to this/divisor according to
 integer arithmetic rules.
 
 Throws: Nothing.
- <pre class="programlisting">
-TimeDuration operator/=(int divisor)
+ <pre class="programlisting">Duration operator/=(int divisor)
</pre>
 Effects: Change value of this by this/divisor according to integer
 arithmetic rules.
@@ -2626,22 +2608,19 @@
 Returns: this
 
 Throws: Nothing.
- <pre class="programlisting">
-TimeDuration operator* (int rhs) const
+ <pre class="programlisting">Duration operator* (int rhs) const
</pre>
 Returns: Duration with value equal to this*rhs
 
 Throws: Nothing.
- <pre class="programlisting">
-TimeDuration operator*=(int rhs)
+ <pre class="programlisting">Duration operator*=(int rhs)
</pre>
 Effects: Modifies to value equal to this*rhs.
 
 Returns: this
 
 Throws: Nothing.
- <pre class="programlisting">
-tick_type get_count() const
+ <pre class="programlisting">tick_type get_count() const
</pre>
 Returns: The count at the resolution of the time duration
 type.
@@ -2655,8 +2634,7 @@
Objects of class <tt>nanoseconds</tt> can be used to represent a count of nanoseconds.


-<blockquote><pre>
-class nanoseconds
+<blockquote><pre>class nanoseconds
{
 public:

@@ -2675,34 +2653,29 @@
};
</pre></blockquote>

-<pre class="programlisting">
-nanoseconds(long long=0);
+<pre class="programlisting">nanoseconds(long long=0);
</pre>
 Effects: Constructs an object with a count of nanoseconds - default
 is zero.
 
 Throws: Nothing.
- <pre class="programlisting">
-nanoseconds(const nanoseconds& rhs);
+ <pre class="programlisting">nanoseconds(const nanoseconds& rhs);
</pre>
 Effects: Copy construction.
 
 Throws: Nothing.
 
- <pre class="programlisting">
-static tick_type ticks_per_second();
+ <pre class="programlisting">static tick_type ticks_per_second();
</pre>
 Returns: 1000000000
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type seconds_per_tick();
+ <pre class="programlisting">static tick_type seconds_per_tick();
</pre>
 Returns: 0
 
 Throws: Nothing.
- <pre class="programlisting">
-static bool is_subsecond();
+ <pre class="programlisting">static bool is_subsecond();
</pre>
 Returns: true
 
@@ -2715,8 +2688,7 @@
Objects of class <tt>microseconds</tt> can be used to represent a count of microseconds.


-<blockquote><pre>
-class microseconds
+<blockquote><pre>class microseconds
{
 public:

@@ -2739,41 +2711,35 @@

</pre></blockquote>

-<pre class="programlisting">
-microseconds(long long=0);
+<pre class="programlisting">microseconds(long long=0);
</pre>
 Effects: Constructs an object with a count of microseconds - default
 is zero.
 
 Throws: Nothing.
- <pre class="programlisting">
-microseconds(const microseconds& rhs);
+ <pre class="programlisting">microseconds(const microseconds& rhs);
</pre>
 Effects: Copy construction.
 
 Throws: Nothing.
 
- <pre class="programlisting">
-//conversions
+ <pre class="programlisting">//conversions
operator nanoseconds() const
</pre>
 Returns: microsecond count converted to nanoseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type ticks_per_second();
+ <pre class="programlisting">static tick_type ticks_per_second();
</pre>
 Returns: 1000000
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type seconds_per_tick();
+ <pre class="programlisting">static tick_type seconds_per_tick();
</pre>
 Returns: 0
 
 Throws: Nothing.
- <pre class="programlisting">
-static bool is_subsecond();
+ <pre class="programlisting">static bool is_subsecond();
</pre>
 Returns: true
 
@@ -2787,8 +2753,7 @@
Objects of class <tt>milliseconds</tt> can be used to represent a count of milliseconds.


-<blockquote><pre>
-class milliseconds
+<blockquote><pre>class milliseconds
{
 public:
 milliseconds(long long=0);
@@ -2809,46 +2774,39 @@
};
</pre></blockquote>

-<pre class="programlisting">
-milliseconds(long long=0);
+<pre class="programlisting">milliseconds(long long=0);
</pre>
 Effects: Constructs an object with a count of milliseconds - default
 is zero.
 
 Throws: Nothing.
- <pre class="programlisting">
-milliseconds(const milliseconds& rhs);
+ <pre class="programlisting">milliseconds(const milliseconds& rhs);
</pre>
 Effects: Copy construction.
 
 Throws: Nothing.
 
- <pre class="programlisting">
-operator nanoseconds() const
+ <pre class="programlisting">operator nanoseconds() const
</pre>
 Returns: millisecond count converted to nanoseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator microseconds() const
+ <pre class="programlisting">operator microseconds() const
</pre>
 Returns: millisecond count converted to microseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type ticks_per_second();
+ <pre class="programlisting">static tick_type ticks_per_second();
</pre>
 Returns: 1000
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type seconds_per_tick();
+ <pre class="programlisting">static tick_type seconds_per_tick();
</pre>
 Returns: 0
 
 Throws: Nothing.
- <pre class="programlisting">
-static bool is_subsecond();
+ <pre class="programlisting">static bool is_subsecond();
</pre>
 Returns: true
 
@@ -2861,8 +2819,7 @@
Objects of class <tt>seconds</tt> can be used to represent a count of seconds.


-<blockquote><pre>
-class seconds
+<blockquote><pre>class seconds
{
 public:
 seconds(long long s=0);
@@ -2885,52 +2842,44 @@
};
</pre></blockquote>

-<pre class="programlisting">
-seconds(long long=0);
+<pre class="programlisting">seconds(long long=0);
</pre>
 Effects: Constructs an object with a count of seconds - default is
 zero.
 
 Throws: Nothing.
- <pre class="programlisting">
-seconds(const seconds& rhs);
+ <pre class="programlisting">seconds(const seconds& rhs);
</pre>
 Effects: Copy construction.
 
 Throws: Nothing.
 
- <pre class="programlisting">
-operator nanoseconds() const
+ <pre class="programlisting">operator nanoseconds() const
</pre>
 Returns: second count converted to nanoseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator microseconds() const
+ <pre class="programlisting">operator microseconds() const
</pre>
 Returns: second count converted to microseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator milliseconds() const
+ <pre class="programlisting">operator milliseconds() const
</pre>
 Returns: second count converted to milliseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type ticks_per_second();
+ <pre class="programlisting">static tick_type ticks_per_second();
</pre>
 Returns: 1
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type seconds_per_tick();
+ <pre class="programlisting">static tick_type seconds_per_tick();
</pre>
 Returns: 1
 
 Throws: Nothing.
- <pre class="programlisting">
-static bool is_subsecond();
+ <pre class="programlisting">static bool is_subsecond();
</pre>
 Returns: false
 
@@ -2944,8 +2893,7 @@
Objects of class <tt>minutes</tt> can be used to represent a count of minutes.


-<blockquote><pre>
-class minutes
+<blockquote><pre>class minutes
{
 public:
 minutes(long long s=0);
@@ -2968,58 +2916,49 @@

};
</pre></blockquote>
-<pre class="programlisting">
-minutes(long long=0);
+<pre class="programlisting">minutes(long long=0);
</pre>
 Effects: Constructs an object with a count of minutes - default is
 zero.
 
 Throws: Nothing.
- <pre class="programlisting">
-minutes(const minutes& rhs);
+ <pre class="programlisting">minutes(const minutes& rhs);
</pre>
 Effects: Copy construction.
 
 Throws: Nothing.
 
- <pre class="programlisting">
-operator nanoseconds() const
+ <pre class="programlisting">operator nanoseconds() const
</pre>
 Returns: minute count converted to nanoseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator microseconds() const
+ <pre class="programlisting">operator microseconds() const
</pre>
 Returns: minute count converted to microseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator milliseconds() const
+ <pre class="programlisting">operator milliseconds() const
</pre>
 Returns: minute count converted to milliseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator seconds() const
+ <pre class="programlisting">operator seconds() const
</pre>
 Returns: minute count converted to seconds
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type ticks_per_second();
+ <pre class="programlisting">static tick_type ticks_per_second();
</pre>
 Returns: 0
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type seconds_per_tick();
+ <pre class="programlisting">static tick_type seconds_per_tick();
</pre>
 Returns: 60
 
 Throws: Nothing.
- <pre class="programlisting">
-static bool is_subsecond();
+ <pre class="programlisting">static bool is_subsecond();
</pre>
 Returns: false
 
@@ -3057,63 +2996,53 @@
</pre></blockquote>

-<pre class="programlisting">
-hours(long long=0);
+<pre class="programlisting">hours(long long=0);
</pre>
 Effects: Constructs an object with a count of hours - default is zero.
 
 Throws: Nothing.
- <pre class="programlisting">
-hours(const hours& rhs);
+ <pre class="programlisting">hours(const hours& rhs);
</pre>
 Effects: Copy construction.
 
 Throws: Nothing.
 
- <pre class="programlisting">
-operator nanoseconds() const
+ <pre class="programlisting">operator nanoseconds() const
</pre>
 Returns: hour count converted to nanoseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator microseconds() const
+ <pre class="programlisting">operator microseconds() const
</pre>
 Returns: hour count converted to microseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator milliseconds() const
+ <pre class="programlisting">operator milliseconds() const
</pre>
 Returns: hour count converted to milliseconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator seconds() const
+ <pre class="programlisting">operator seconds() const
</pre>
 Returns: hour count converted to seconds
 
 Throws: Nothing.
- <pre class="programlisting">
-operator minutes() const
+ <pre class="programlisting">operator minutes() const
</pre>
 Returns: hour count converted to seconds.
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type ticks_per_second();
+ <pre class="programlisting">static tick_type ticks_per_second();
</pre>
 Returns: 0
 
 Throws: Nothing.
- <pre class="programlisting">
-static tick_type seconds_per_tick();
+ <pre class="programlisting">static tick_type seconds_per_tick();
</pre>
 Returns: 3600
 
 Throws: Nothing.
- <pre class="programlisting">
-static bool is_subsecond();
+ <pre class="programlisting">static bool is_subsecond();
</pre>
 Returns: false
 
@@ -3184,4 +3113,4 @@


</div></body></html><ins class="diff">
-</ins>
+</ins>
\ No newline at end of file

Next message: lists.drrngrvy_at_[hidden]: "[Boost-commit] svn:boost r40038 - in sandbox/boost_docs/branches/spirit_qbking: . doc doc/src"
Previous message: daniel_james_at_[hidden]: "[Boost-commit] svn:boost r40036 - trunk/boost/functional/hash"

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