Boost-Commit :

Date view	Thread view	Subject view	Author view

From: bdawes_at_[hidden]
Date: 2007-10-08 13:53:46

Next message: ghost_at_[hidden]: "[Boost-commit] svn:boost r39805 - trunk/tools/build/v2"
Previous message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r39803 - sandbox/committee/LWG"

Author: bemandawes
Date: 2007-10-08 13:53:46 EDT (Mon, 08 Oct 2007)
New Revision: 39804
URL: http://svn.boost.org/trac/boost/changeset/39804

Log:
thread10 - merge of updates from 10/3++
Text files modified:
sandbox/committee/LWG/thread_library.html | 1068 +++++++++++++++++++--------------------
1 files changed, 514 insertions(+), 554 deletions(-)

Modified: sandbox/committee/LWG/thread_library.html
==============================================================================
--- sandbox/committee/LWG/thread_library.html (original)
+++ sandbox/committee/LWG/thread_library.html 2007-10-08 13:53:46 EDT (Mon, 08 Oct 2007)
@@ -2,7 +2,7 @@
<html lang="en"><head>

- <meta http-equiv="content-type" content="text/html; charset=utf-8"/><title>thread</title>
+ <meta http-equiv="content-type" content="text/html; charset=utf-8"/><title>Tread Working Draft 10</title>

 <style>
 p {text-align:justify}
@@ -20,7 +20,7 @@
 .comment { color: #800000; }
 span.underline
 {
- text-decoration: underline;
+// text-decoration: underline;
 }

 span.strikethrough
@@ -46,9 +46,10 @@
 
<a href="mailto:hinnant_at_[hidden]">Howard E. Hinnant</a>,
<a href="mailto:jeff_at_[hidden]">Jeff Garland</a>,
-<a href="mailto:public_at_[hidden]">Alisdair Meredith</a>
+<a href="mailto:public_at_[hidden]">Alisdair Meredith</a>,
+<a href="mailto:chris_at_[hidden]">Chris Kohlhoff</a>
 
-2007-10-03
+2007-10-04
</address>
<hr/>
<h1 align="center">Multi-threading Library for Standard C++</h1>
@@ -57,29 +58,6 @@

<ul>
<li>Introduction</li>
-<del class="diff"><li>Thread
-</li>
-<li>Mutex
- <ul>
- <li>Mutex Rationale and Examples
- <ul>
- <li>Mutex concepts</li>
- <li>Time Issues</li>
- </ul>
- </li>
- <li>Lock Rationale and Examples</li>
- <li>Generic Locking Algorithm Rationale and Examples</li>
- </ul>
-</li>
-<li>Condition Variables
- <ul>
- <li>Condition Rationale and Examples
- <ul>
- <li>Condition Variable Flexibility</li>
- </ul>
- </li>
- </ul>
-</li></del>
<li>Proposed Wording<ul>
 <li>Threads Proposed Wording</li>
 <li>Mutexes and Locks Proposed Wording</li>
@@ -205,8 +183,8 @@
 thread::id get_id();

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

} // this_thread

@@ -667,8 +645,8 @@
 thread::id get_id();

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

} // this_thread
</pre></blockquote>
@@ -698,13 +676,13 @@
</blockquote>
</blockquote>

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

<blockquote>

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


Effects: The current thread of execution blocks for at least the amount of time specified.
@@ -806,7 +784,6 @@

<blockquote><pre>namespace std {

-struct static_mutex;
struct mutex;
struct recursive_mutex;
struct timed_mutex;
@@ -822,7 +799,7 @@

class lock_error;

-template <class Mutex> class scoped_lock;
+template <class Mutex> class lock_guard;
template <class Mutex> class unique_lock;

template <class Mutex> void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y);
@@ -838,23 +815,24 @@
<h3>Mutex concepts</h3>


-Objects of the mutex types enforce mutual exclusion between threads of execution
-by limiting ownership of a mutex object to a single thread of execution. A
-thread of execution gets ownership of a mutex object by calling <tt>lock()</tt> and
-relinquishes ownership by calling <tt>unlock()</tt>. Ownership can not
-be transferred from one thread of execution to another. The same
-thread of execution that calls
-<tt>lock()</tt> for a mutex object must call <tt>unlock() f</tt>or the object. Mutexes can be either recursive
-or non-recursive. The syntax is the same for both recursive and non-recursive
-mutexes, but the semantics for the member functions differs as described below.
+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>
+and relinquishes ownership by calling <tt>unlock()</tt>. The
+thread of execution 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
+as described below.



-Each mutex type shall be default constructible and destructible. If the default construction
-of the Mutex type fails, an exception of type <tt>system_error</tt> shall be thrown. The destructor
-of the Mutex type shall not throw an exception.
-Mutex types are neither copyable
-nor movable. Each mutex type shall have the following member functions:
+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.
+A mutex type is neither copyable
+nor movable. A mutex type shall have the following member functions:


<blockquote>
@@ -872,8 +850,7 @@
Throws: <tt>system_error</tt>.


-Thread safety: Calls from different threads of execution to <tt>lock</tt>, <tt>try_lock</tt>,
-and <tt>unlock</tt> functions on an object of a mutex type shall not result in data races or deadlocks.
+Thread safety: This is an acquire operation.

</blockquote>
</blockquote>
@@ -893,8 +870,7 @@
Returns: <tt>true</tt> if ownership was obtained, otherwise <tt>false</tt>.


-Thread safety: Calls from different threads of execution to <tt>lock</tt>, <tt>try_lock</tt>,
-and <tt>unlock</tt> functions on an object of a mutex type shall not result in data races or deadlocks.
+Thread safety: This is an acquire operation if <tt>try_lock</tt> returns <tt>true</tt>.


Throws: Nothing.
@@ -915,8 +891,7 @@
(via either <tt>lock()</tt> or <tt>try_lock()</tt> or by any other locking function) before ownership is released.


-Thread safety: Calls from different threads of execution to <tt>lock</tt>,
-and <tt>try_lock</tt> functions on an object of a mutex type shall not result in data races or deadlocks.
+Thread safety: This is a release operation.


Throws: Nothing.
@@ -929,14 +904,14 @@
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,
otherwise if the native type is not copyable, is a pointer to this native type.
-The implementation shall document whether or not the <tt>native_handle_type</tt>
+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 a handle
-to this internal data structure. [Example:
+also shall be a member function <tt>native_handle()</tt> which returns <tt>
+native_handle_type</tt>. [Example:


<blockquote><pre>class mutex
@@ -966,45 +941,6 @@
or its environment.


-<h4>Class static_mutex</h4>
-
-<blockquote class="note">
-
-The class <tt>static_mutex</tt> is based on a new language feature <tt>constexpr</tt>
-which is not yet in the working draft, nor do we have field experience with it. Should
-this language feature fail to deliver the static initialization behavior desired, we
-recommend removing <tt>static_mutex</tt> from the working paper.
-
-</blockquote>
-
-<blockquote><pre>namespace std {
-
-struct static_mutex
-{
-public:
- constexpr static_mutex();
- ~static_mutex();
-
- static_mutex(const static_mutex&) = delete;
- static_mutex& operator=(const static_mutex&) = delete;
-
- void lock();
- bool try_lock();
- void unlock();
-
- typedef unspecified native_handle_type; // conditionally present. example: pthread_mutex_t*
- native_handle_type native_handle(); // conditionally present
-};
-
-} // std
-</pre></blockquote>
-
-
-The class <code>static_mutex</code> is a non-recursive mutex. It shall be a standard-layout type ([?]),
-and does not require dynamic initialization. The default constructor,
-if dynamically initialized, shall not throw an exception.
-
-
<h4>Class mutex</h4>

<blockquote><pre>namespace std {
@@ -1071,13 +1007,14 @@


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

Precondition: For non-recursive mutexes the current thread of execution shall not own the mutex.
-The type <tt>ElapsedTime</tt> shall be explicitly convertible to <tt>nanoseconds</tt>.
+The type <tt>TimeDuration</tt> provides resolution information (ticks_per_second) that allows conversion
+of the specified value into the native time resolution.


Effects: The function attempts to obtain ownership of the mutex within the specified time.
@@ -1089,8 +1026,7 @@
Returns: <tt>true</tt> if ownership was obtained, otherwise <tt>false</tt>.


-Thread safety: Calls to this member function from different
-threads of execution shall not result in data races or deadlocks.
+Thread safety: This is a synchronization operation.


Throws: Nothing.
@@ -1113,8 +1049,8 @@

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

 typedef unspecified native_handle_type; // conditionally present. example: pthread_mutex_t*
@@ -1144,8 +1080,8 @@

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

 typedef unspecified native_handle_type; // conditionally present. example: pthread_mutex_t*
@@ -1197,44 +1133,42 @@
};
</pre></blockquote>

-<h4>Class scoped_lock</h4>
+<h4>Class lock_guard</h4>

<blockquote><pre>namespace std {

template <class Mutex>
-class scoped_lock
+class lock_guard
{
public:
 typedef Mutex mutex_type;

- explicit scoped_lock(mutex_type& m);
- scoped_lock(mutex_type& m, adopt_lock_t);
- ~scoped_lock();
+ explicit lock_guard(mutex_type& m);
+ lock_guard(mutex_type& m, adopt_lock_t);
+ ~lock_guard();

- scoped_lock(scoped_lock const&) = delete;
- scoped_lock& operator=(scoped_lock const&) = delete;
-
- constexpr bool owns() const; <ins>Remove?</ins>
+ lock_guard(lock_guard const&) = delete;
+ lock_guard& operator=(lock_guard const&) = delete;
};

} // std
</pre></blockquote>


-<tt>scoped_lock</tt> is used to control the ownership of a mutex within a single scope.
-An invariant of the <tt>scoped_lock</tt> object is that it maintains the ownership of the
-mutex throughout the <tt>scoped_lock</tt>'s lifetime. Mutex ownership can not be deferred
-or transferred away from the <tt>scoped_lock</tt>.
+<tt>lock_guard</tt> is used to control the ownership of a mutex within a single scope.
+An invariant of the <tt>lock_guard</tt> object is that it maintains the ownership of the
+mutex throughout the <tt>lock_guard</tt>'s lifetime. Mutex ownership can not be deferred
+or transferred away from the <tt>lock_guard</tt>.


<blockquote>
-<pre>explicit scoped_lock(mutex_type& m);
+<pre>explicit lock_guard(mutex_type& m);
</pre>
<blockquote>

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


Effects: Stores a reference to <tt>m</tt> and calls <tt>m.lock()</tt>.
@@ -1243,13 +1177,13 @@
</blockquote>

<blockquote>
-<pre>scoped_lock(mutex_type& m, adopt_lock_t);
+<pre>lock_guard(mutex_type& m, adopt_lock_t);
</pre>
<blockquote>

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


Effects: Stores a reference to <tt>m</tt> and performs no other operation on it.
@@ -1258,7 +1192,7 @@
</blockquote>

<blockquote>
-<pre>~scoped_lock();
+<pre>~lock_guard();
</pre>
<blockquote>

@@ -1270,20 +1204,6 @@
</blockquote>
</blockquote>

-
-<blockquote>
-<pre>constexpr bool owns() const;
-</pre>
-<blockquote>
-
-Returns: <tt>true</tt>.
-
-
-Throws: Nothing.
-
-</blockquote>
-</blockquote>
-
<h4>Class unique_lock</h4>

<blockquote><pre>namespace std {
@@ -1309,11 +1229,14 @@

 void lock();
 bool try_lock();
- template <class ElapsedTime>
- bool timed_lock(const ElapsedTime& rel_t);
+
+ template <class TimeDuration>
+ bool timed_lock(const TimeDuration& rel_t);
+ bool timed_lock(const system_time& abs_time);
+
 void unlock();

- bool owns() const;
+ bool owns_lock() const;
 operator unspecified-bool-type () const;
 mutex_type* mutex() const;

@@ -1346,7 +1269,7 @@
Postcondition:

<blockquote><pre>mutex() == 0
-owns() == false
+owns_lock() == false
</pre></blockquote>
</blockquote>
</blockquote>
@@ -1367,7 +1290,7 @@
Postcondition:

<blockquote><pre>mutex() == &m
-owns() == true
+owns_lock() == true
</pre></blockquote>
</blockquote>
</blockquote>
@@ -1389,7 +1312,7 @@
Postcondition:

<blockquote><pre>mutex() == &m
-owns() == false
+owns_lock() == false
</pre></blockquote>
</blockquote>
</blockquote>
@@ -1411,7 +1334,7 @@
Postcondition:

<blockquote><pre>mutex() == &m
-owns() == The result of the call to m.try_lock()
+owns_lock() == The result of the call to m.try_lock()
</pre></blockquote>
</blockquote>
</blockquote>
@@ -1432,7 +1355,7 @@
Postcondition:

<blockquote><pre>mutex() == &m
-owns() == true
+owns_lock() == true
</pre></blockquote>
</blockquote>
</blockquote>
@@ -1442,7 +1365,7 @@
</pre>
<blockquote>

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


@@ -1462,9 +1385,9 @@
Postcondition:

<blockquote><pre>mutex() == The value of u.mutex() prior to the construction.
-owns() == The value of u.owns() prior to the construction.
+owns_lock() == The value of u.owns_lock() prior to the construction.
u.mutex() == 0
-u.owns() == false
+u.owns_lock() == false
</pre></blockquote>

Throws: Nothing.
@@ -1477,16 +1400,16 @@
</pre>
<blockquote>

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


Postcondition:

<blockquote><pre>mutex() == The value of u.mutex() prior to the construction.
-owns() == The value of u.owns() prior to the construction.
+owns_lock() == The value of u.owns_lock() prior to the construction.
u.mutex() == 0
-u.owns() == false
+u.owns_lock() == false
</pre></blockquote>

Throws: Nothing.
@@ -1509,10 +1432,10 @@
Effects: Calls <tt>lock()</tt> on the referenced mutex.


-Postcondition: <tt>owns() == true</tt>.
+Postcondition: <tt>owns_lock() == true</tt>.


-Throws: <tt>lock_error</tt>, if on entry <tt>owns()</tt> is <tt>true</tt>.
+Throws: <tt>lock_error</tt>, if on entry <tt>owns_lock()</tt> is <tt>true</tt>.
</blockquote>
</blockquote>

@@ -1527,30 +1450,32 @@
Returns: The result of the call to <tt>try_lock()</tt> on the referenced mutex.


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


-Throws: <tt>lock_error</tt>, if on entry <tt>owns()</tt> is <tt>true</tt>.<tt> </tt>
+Throws: <tt>lock_error</tt>, if on entry <tt>owns_lock()</tt> is <tt>true</tt>.<tt> </tt>

</blockquote>
</blockquote>

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

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


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


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


-Throws: <tt>lock_error</tt>, if on entry <tt>owns()</tt> is <tt>true</tt>.
+Throws: <tt>lock_error</tt>, if on entry <tt>owns_lock()</tt> is <tt>true</tt>.
</blockquote>
</blockquote>

@@ -1562,16 +1487,16 @@
Effects: Calls <tt>void unlock()</tt> on the referenced mutex.


-Postcondition: <tt>owns() == false</tt>.
+Postcondition: <tt>owns_lock() == false</tt>.


-Throws: <tt>lock_error</tt>, if on entry <tt>owns()</tt> is <tt>false</tt>.
+Throws: <tt>lock_error</tt>, if on entry <tt>owns_lock()</tt> is <tt>false</tt>.

</blockquote>
</blockquote>

<blockquote>
-<pre>bool owns() const;
+<pre>bool owns_lock() const;
</pre>
<blockquote>

@@ -1588,7 +1513,7 @@
</pre>
<blockquote>

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


Throws: Nothing.
@@ -1633,7 +1558,7 @@
Postcondition:

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

Throws: Nothing.
@@ -1706,74 +1631,78 @@

<h3><a name="ConditionVariablesWording">Condition variables</a></h3>

-<cond_varcondition_variable> synopsis
+<condition_variable> synopsis

<blockquote><pre>namespace std {

-class cond_varcondition_variable;
-class gen_cond_vargeneral_condition_variable;
+class condition_variable;
+class condition_variable_any;

} // std
</pre></blockquote>

-<h4>Class cond_varcondition_variable</h4>
+<h4>Class condition_variable</h4>


-An object of class <tt>cond_varcondition_variable</tt> is a synchronization primitive
+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.


+
+If and only if the condition variable type is internally represented by an object
+which can be passed to operating system specific interfaces, then there shall be a
+implementation-defined member typedef <tt>native_handle_type</tt> that is an alias
+to this native type, if it is copyable, or if the native type is not copyable,
+a pointer to this native type. The implementation shall document whether the
+<tt>native_handle_type</tt> member 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.
+
+
<blockquote><pre>namespace std {

-class cond_varcondition_variable
+class condition_variable
{
public:
- cond_varcondition_variable();
- ~cond_varcondition_variable();
-
- cond_varcondition_variable(const cond_varcondition_variable&) = delete;
- cond_varcondition_variable& operator=(const cond_varcondition_variable&) = delete;
+ typedef implementation-defined native_handle_type;
+
+ condition_variable();
+ ~condition_variable();
+
+ condition_variable(const condition_variable&) = delete;
+ condition_variable& operator=(const condition_variable&) = delete;

 void notify_one();
 void notify_all();
 void wait(unique_lock<mutex>& lock);
 template <class Predicate>
 void wait(unique_lock<mutex>& lock, Predicate pred);
- bool timed_wait(unique_lock<mutex>& lock, const utc_time& abs_time);
+ bool timed_wait(unique_lock<mutex>& lock, const system_time& abs_time);
 template <class Predicate>
- bool timed_wait(unique_lock<mutex>& lock, const utc_time& abs_time, Predicate pred);
+ bool timed_wait(unique_lock<mutex>& lock, const system_time& abs_time, Predicate pred);
+ native_handle_type native_handle();
};

} // std
</pre></blockquote>

<blockquote>
-<pre>cond_varcondition_variable();
+<pre>condition_variable();
</pre>
<blockquote>

-Effects: Constructs an object of class <tt>cond_varcondition_variable</tt>.
+Effects: Constructs an object of class <tt>condition_variable</tt>.

</blockquote>
</blockquote>

<blockquote>
-<pre>~cond_varcondition_variable();
+<pre>~condition_variable();
</pre>
<blockquote>

@@ -1791,12 +1720,11 @@
<blockquote>

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

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

@@ -1808,13 +1736,12 @@
</pre>
<blockquote>

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

@@ -1827,19 +1754,15 @@
<blockquote>

Precondition: <tt>lock</tt> is locked by the current thread of execution. No
-other thread of execution is waiting on this <tt>cond_varcondition_variable</tt> object unless <tt>lock</tt>
+other thread of execution 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 out.
-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
+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
unblock and return even in the absence of a notification.


@@ -1851,8 +1774,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</tt>
+<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
object from different threads of execution shall not result in data
races or deadlocks.

@@ -1875,13 +1797,12 @@

<blockquote>
-<pre>bool timed_wait(unique_lock<mutex>& lock, const utc_time& abs_time);
+<pre>bool timed_wait(unique_lock<mutex>& lock, const system_time& abs_time);
</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>cond_varcondition_variable</tt> object unless <tt>lock</tt>
+other thread of execution is waiting on this <tt>condition_variable</tt> object unless <tt>lock</tt>
refers to, the same underlying <tt>mutex</tt> object.


@@ -1890,13 +1811,10 @@
any reason, <tt>lock</tt> will be locked as the exception propagates
out. If the absolute time specified by <tt>abs_time</tt> passes (that
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>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
+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
notification.

@@ -1914,16 +1832,15 @@

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

<blockquote>
-<pre>template <class _Predicate>
- bool timed_wait(unique_lock<mutex>& lock, const utc_time& abs_time, Predicate pred);
+<pre>template <class Predicate>
+ bool timed_wait(unique_lock<mutex>& lock, const system_time& abs_time, Predicate pred);
</pre>
<blockquote>

@@ -1947,17 +1864,25 @@
</blockquote>
</blockquote>

+<blockquote>
+<pre>native_handle_type native_handle();
+</pre>
+<blockquote>
+
+Returns: the representation of the underlying object used to implement <tt>*this</tt>.
+
+</blockquote>
+</blockquote>
+
+

-<tt>cond_varcondition_variable</tt> shall be a standard-layout type ([?]).
+<tt>condition_variable</tt> shall be a standard-layout type ([?]).


-<h4>Class gen_cond_vargeneral_condition_variable</h4>
+<h4>Class condition_variable_any</h4>


-An object of class <tt>gen_cond_vargeneral_condition_variable</tt> is a synchronization primitive
+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.

@@ -1968,23 +1893,33 @@
meet this requirement.


+
+If and only if the <tt>condition_variable_any</tt> type is internally represented by an
+an object or objects 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 a type providing access to the object or objects. The type
+<tt>native_handle_type</tt> must be copyable; if the object or objects are not copyable,
+<tt>native_handle_type</tt> must be a pointer 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.
+
+
<blockquote><pre>namespace std {

-class gen_cond_vargeneral_condition_variable
+class condition_variable_any
{
public:
- gen_cond_vargeneral_condition_variable();
- ~gen_cond_vargeneral_condition_variable();
-
- gen_cond_vargeneral_condition_variable(const gen_cond_vargeneral_condition_variable&) = delete;
- gen_cond_vargeneral_condition_variable& operator=(const gen_cond_vargeneral_condition_variable&) = delete;
+ typedef implementation-defined native_handle_type;
+ condition_variable_any();
+ ~condition_variable_any();
+
+ condition_variable_any(const condition_variable_any&) = delete;
+ condition_variable_any& operator=(const condition_variable_any&) = delete;

 void notify_one();
 void notify_all();
@@ -1993,29 +1928,27 @@
 template <class Lock, class Predicate>
 void wait(Lock& lock, Predicate pred);
 template <class Lock>
- bool timed_wait(Lock& lock, const utc_time& abs_time);
+ bool timed_wait(Lock& lock, const system_time& abs_time);
 template <class Lock, class Predicate>
- bool timed_wait(Lock& lock, const utc_time& abs_time, Predicate pred);
+ bool timed_wait(Lock& lock, const system_time& abs_time, Predicate pred);
+ native_handle_type native_handle();
};

} // std
</pre></blockquote>

<blockquote>
-<pre>gen_cond_vargeneral_condition_variable();
+<pre>condition_variable_any();
</pre>
<blockquote>

-Effects: Constructs an object of class <tt>gen_cond_vargeneral_condition_variable</tt>.
+Effects: Constructs an object of class <tt>condition_variable_any</tt>.

</blockquote>
</blockquote>

<blockquote>
-<pre>~gen_cond_vargeneral_condition_variable();
+<pre>~condition_variable_any();
</pre>
<blockquote>

@@ -2033,13 +1966,11 @@
<blockquote>

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

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>general_condition_variable</tt>
+<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
races or deadlocks.

@@ -2051,15 +1982,12 @@
</pre>
<blockquote>

-Effects: Unblock all threads 
-of executionthat are blocked waiting for <code>*this</code>.
+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
-<code>notify_all</code> member functions of the same <tt>general_condition_variable</tt>
+<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
races or deadlocks.

@@ -2073,19 +2001,15 @@

Precondition: <tt>lock</tt> is locked by the current thread of execution. If
<tt>Lock</tt> supports recursive locking, the lock count is one. No
-other thread of execution is waiting on this <tt>gen_cond_vargeneral_condition_variable</tt> object unless <tt>lock</tt>
+other thread of execution 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 out.
-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
+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
unblock and return even in the absence of a notification.


@@ -2097,9 +2021,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>general_condition_variable</tt>
+<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
races or deadlocks.

@@ -2122,14 +2044,13 @@

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

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


@@ -2138,14 +2059,10 @@
any reason, <tt>lock</tt> will be locked as the exception propagates
out. If the absolute time specified by <tt>abs_time</tt> passes (that
is, system time equals or exceeds <tt>abs_time</tt>) before the
-<tt>general_condition_variable</tt> is notified, or if the absolute time specified by
+<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
+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
notification.

@@ -2163,9 +2080,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>general_condition_variable</tt>
+<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
races or deadlocks.
</blockquote>
@@ -2173,7 +2088,7 @@

<blockquote>
<pre>template <class _Predicate>
- bool timed_wait(Lock& lock, const utc_time& abs_time, Predicate pred);
+ bool timed_wait(Lock& lock, const system_time& abs_time, Predicate pred);
</pre>
<blockquote>

@@ -2197,6 +2112,15 @@
</blockquote>
</blockquote>

+<blockquote>
+<pre>native_handle_type native_handle();
+</pre>
+<blockquote>
+
+Returns: the representation of the underlying object or objects used to implement <tt>*this</tt>.
+
+</blockquote>
+</blockquote>

<hr/>

@@ -2205,7 +2129,13 @@

<hr/>

-
+ This clause describes components for determining and manipulating temporal values.
+ A time point represents a dimensionless instant
+ in the time continuum. A time duration represents a length of time
+ unattached to any time point. Time points and time durations have a
+ resolution which is their smallest representable time duration. Time points
+ have an epoch or start of a given time scale. For time_t the epoch is
+ 1970-01-01 00:00:00

<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>
@@ -2223,22 +2153,36 @@
 class nanoseconds;

 //timepoint
- class utc_time;
+ class system_time;
+
+ //functions
+ system_time get_system_time();

- template<class time_type="">
- class hiresolution_clock;
} //std
</class></pre></blockquote>

</div><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.class_utc_time"></a>class utc_time</h3></div></div></div>

-<blockquote><pre>class utc_time
+
+
+ The class <tt>system_time</tt> provides a time point that represents the current
+ Coordinated Universal Time, known as UTC, time.
+ <tt>system_time</tt> 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 <tt>system_time</tt> shall be EqualityComparable, LessThanComparable,
+ CopyConstructable, DefaultConstructable, and Assignable.
+
+
+
+<blockquote><pre>
+class system_time
{
 public:

- utc_time(); //epoch
- utc_time(time_t, nanoseconds ns);
- ~utc_time();
+ system_time();
+ system_time(time_t, nanoseconds ns);
+ ~system_time();

 time_t seconds_since_epoch() const;
 nanoseconds nanoseconds_since_epoch() const;
@@ -2250,145 +2194,138 @@
 static bool is_subsecond();

 //comparison functions
- bool operator==(const utc_time& rhs) const;
- bool operator!=(const utc_time& rhs) const;
- bool operator>(const utc_time& rhs) const;
- bool operator>=(const utc_time& rhs) const;
- bool operator<(const utc_time& rhs) const;
- bool operator<=(const utc_time& rhs) const;
+ bool operator==(const system_time& rhs) const;
+ bool operator!=(const system_time& rhs) const;
+ bool operator>(const system_time& rhs) const;
+ bool operator>=(const system_time& rhs) const;
+ bool operator<(const system_time& rhs) const;
+ bool operator<=(const system_time& rhs) const;

 //arithmetic functions
- nanoseconds operator-(const utc_time& rhs) const
+ nanoseconds operator-(const system_time& rhs) const

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

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

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

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

};
</pre></blockquote>
-
- The class utc_time provides a timepoint that represents the current UTC time.
- utc_time mustshall
- provide an epoch timeminimum range of 1970-01-01 00:00:00.000000000
- and a maximum time value of at least epoch time
- + 292 years.
- 

<blockquote class="note">

-<h3 class="title">Note</h3>
+<h3 class="title">Note</h3>
 292 years represents the number of nanoseconds that can be represented
 in a signed 64 bit integer.
</blockquote>

-<pre class="programlisting">utc_time();//epoch
-</pre>
- Effects: Constructs a utc_time
+<pre class="programlisting">
+system_time();</pre>
+ Effects: Constructs a system_time
 object representing the epoch time
 point 1970-01-01 00:00:00.000000000
 
 Throws: Nothing
- <pre class="programlisting">utc_time(time_t secs, nanoseconds ns);
+ <pre class="programlisting">
+system_time(time_t secs, nanoseconds ns);
</pre>
 Effects: Constructs a utc
- time object where representing the time point that is secs + 1,000,000,000*ns
- seconds after the epoch represents
- seconds since 1970-01-01 00:00:00.000000000 and nanoseconds provides an additional
- nanosecond offset
+ time object representing the time point that is secs + 1,000,000,000*ns
+ seconds after the epoch
 
 Remarks: If the total nanoseconds > 1 second the seconds are
 incremented appropriately
 
 Throws: Nothing
 
- ~utc_time(); 
- 
- Effects: Destroys the time point.
- 
- Throws: Nothing
- <pre class="programlisting">time_t seconds_since_epoch() const;
+ <pre class="programlisting">
+time_t seconds_since_epoch() const;
</pre>
 Returns: 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: 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: Returns 1000000000
 
 Throws: Nothing
- <pre class="programlisting">static tick_type seconds_per_tick();
+ <pre class="programlisting">
+static tick_type seconds_per_tick();
</pre>
 Returns: 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 utc_time& rhs) const;
+ <pre class="programlisting">
+bool operator==(const system_time& rhs) const;
</pre>
- Returns: Returns true if rhs is
- the same timetime
+ Returns: Returns true if
+ the time
 represented by *this is equal to the time represented by rhs.
 
 
 Throws: Nothing
- <pre class="programlisting">bool operator!=(const utc_time& rhs) const;
+ <pre class="programlisting">
+bool operator!=(const system_time& rhs) const;
</pre>
- Returns: Returns true if rhs is
- not the same timetime represented by *this is not equal to the time represented
+ Returns: 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 utc_time& rhs) const;
+ <pre class="programlisting">
+bool operator>(const system_time& rhs) const;
</pre>
- Returns: Returns true if time is
- greater than rhs timerepresented by
+ Returns: Returns true if time represented by
 *this is greater than the time represented by rhs.
 
 Throws: Nothing
- <pre class="programlisting">bool operator>=(const utc_time& rhs) const;
+ <pre class="programlisting">
+bool operator>=(const system_time& rhs) const;
</pre>
- Returns: Returns true if timeis
- greater or equal than rhs timerepresented
+ Returns: 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 utc_time& rhs) const;
+ <pre class="programlisting">
+bool operator<(const system_time& rhs) const;
</pre>
- Returns: Returns true if time is
- less than rhs timerepresented by *this
+ Returns: Returns true if time represented by *this
 is less than the time represented by rhs.
 
 Throws: Nothing
- <pre class="programlisting">bool operator<=(const utc_time& rhs) const;
+ <pre class="programlisting">
+bool operator<=(const system_time& rhs) const;
</pre>
- Returns: Returns true if time is
- less than rhs timerepresented by *this
+ Returns: 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 utc_time& rhs) const
+ <pre class="programlisting">
+nanoseconds operator-(const system_time& rhs) const
</pre>
- Returns: Returns the difference
- between two times in a nanosecond count. Returns
+ Returns: Returns
 the difference in nanoseconds between the time represented by *this and the
 time represented by rhs. 
 
@@ -2396,15 +2333,17 @@
 count.
 
 Throws: Nothing
- <pre class="programlisting">template<typename time_duration_type>
-utc_time operator+(const time_duration_type& td) const;
+ <pre class="programlisting">
+template<typename TimeDuration>
+system_time operator+(const TimeDuration& td) const;
</pre>
 Returns: Returns the duration converted to nanosecond resolution
 and added to the time represented by *this.
 
 Throws: Nothing
- <pre class="programlisting">template<typename time_duration_type>
-utc_time& operator+=(const time_duration_type& td);
+ <pre class="programlisting">
+template<typename TimeDuration>
+system_time& operator+=(const TimeDuration& td);
</pre>
 Effects: Convert the duration to nanosecond resolution add to nanoseconds
 to the time represented by *this.
@@ -2412,15 +2351,17 @@
 Returns: Modified value of this.
 
 Throws: Nothing
- <pre class="programlisting">template<typename time_duration_type>
-utc_time operator-(const time_duration_type& td) const;
+ <pre class="programlisting">
+template<typename TimeDuration>
+system_time operator-(const TimeDuration& td) const;
</pre>
 Returns: Returns the duration converted to nanosecond resolution
 and subtracted from the time represented by *this.
 
 Throws: Nothing
- <pre class="programlisting">template<typename time_duration_type>
-utc_time& operator-=(const time_duration_type& td)
+ <pre class="programlisting">
+template<typename TimeDuration>
+system_time& operator-=(const TimeDuration& td)
</pre>
 Effects: Convert the duration to nanosecond resolution subtract
 from the time represented by *this
@@ -2432,26 +2373,19 @@
 </div>

+<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.template_class_hiresolution_clock"></a>function get_system_time</h3></div></div></div>

-<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.template_class_hiresolution_clock"></a>template class hiresolution_clock</h3></div></div></div>
+
+ The function <tt>get_system_time</tt> provides access to the system clock at a
+ resolution up to nanoseconds. The actual resolution may vary from platform to platform.
+

-<blockquote><pre>
-template<class time_type>
-class hiresolution_clock
-{
-public:
- static time_type universal_time();
- static tick_type ticks_per_second();
-};

+<blockquote><pre>
+ system_time get_system_time();
</pre></blockquote>

-
- The hiresolution_clock provides access to the operating system clock at a
- resolution up to nanoseconds. The actual resolution will may vary from platform to platform. The time_type parameter provides compatibility for user
- defined time types as specified in the TR2 proposal.
- 
<blockquote class="note">

<h3 class="title">Note</h3>
@@ -2460,181 +2394,176 @@
 interface, but it uses different C-level interfaces depending on the operating
 system.
 </blockquote>
-<pre class="programlisting">static time_type universal_time();
-</pre>
- Returns: The Current UTC time -
- equivalent of time_t with fractional sections. An
- object of time_type that represents the current UTC time as measured from
- the computer clock. 
- <div class="note" style="margin-left: 0.5in; margin-right: 0.5in;"><h3 class="title">Note</h3>
- universal_time is the equivalent of the iso
- C time call, but with a higher resolution as defined by the platform.
- </div>
- Remarks: Function is thread-safe on platforms supporting threading.
- Successive Every
- calls to this function will produce return
- and value
- that is equal or greater time value
- in all casesthan the value returned
- by any previous call.
- 
- Throws: Nothing
- 
- static tick_type ticks_per_second();
- 
- Returns: The number of ticks in one
- second provided by the clock implementation.
- 
- Throws: Nothing
- </div>

-<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.common_duration_functions"></a>Common Duration Functions</h3></div></div></div>
+
+<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.common_duration_functions"></a>Common Duration Functions</h3></div></div></div>
+
+
 The following functions are common functions to all durations types. These
 functions provide the basis for durations to be EqualityComparable, LessThanComparable
- as well as the usual arithmetic operations.
+ 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>class duration_type { //where duration_type== nanoseconds, microseconds, etc
+
+<blockquote><pre>
+class TimeDuration {

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

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

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

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

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

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

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

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

- template<typename rhs_duration_type>
- duration_type operator-=(const rhs_duration_type& d)
+ template<typename RhsTimeDuration>
+ TimeDuration operator-=(const RhsTimeDuration& d)

- template<typename rhs_duration_type>
- duration_type operator+ (const rhs_duration_type& d) const
+ template<typename RhsTimeDuration>
+ TimeDuration operator+ (const RhsTimeDuration& d) const

- template<typename rhs_duration_type>
- duration_type operator+=(const rhs_duration_type& d)
-
- duration_type operator/ (int divisor) const
- duration_type operator/=(int divisor)
- duration_type operator* (int rhs) const
- duration_type operator*=(int divisor)
+ 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)

 tick_type get_count() const

}
</pre></blockquote>

- The following details each of these functions.
- <pre class="programlisting">template<typename rhs_duration_type>
-bool operator==(const rhs_duration_type& rhs) const;
+ <pre class="programlisting">
+template<typename RhsTimeDuration>
+bool operator==(const RhsTimeDuration& rhs) const;
</pre>
 Returns: Returns true if rhs duration is greater.
 
 Throws: Nothing
- <pre class="programlisting">template<typename rhs_duration_type>
-bool operator!=(const rhs_duration_type& rhs) const;
+ <pre class="programlisting">
+template<typename RhsTimeDuration>
+bool operator!=(const RhsTimeDuration& rhs) const;
</pre>
 Returns: Returns true if rhs is not the same time.
 
 Throws: Nothing
- <pre class="programlisting">template<typename rhs_duration_type>
-bool operator>(const rhs_duration_type& rhs) const;
+ <pre class="programlisting">
+template<typename RhsTimeDuration>
+bool operator>(const RhsTimeDuration& rhs) const;
</pre>
 Returns: Returns true if the rhs duration is larger.
 
 Throws: Nothing
- <pre class="programlisting">template<typename rhs_duration_type>
-bool operator>=(const rhs_duration_type& rhs) const;
+ <pre class="programlisting">
+template<typename RhsTimeDuration>
+bool operator>=(const RhsTimeDuration& rhs) const;
</pre>
 Returns: Returns true if greater or equal than the rhs duration.
 
 Throws: Nothing
- <pre class="programlisting">template<typename rhs_duration_type>
-bool operator<(const rhs_duration_type& rhs) const;
+ <pre class="programlisting">
+template<typename RhsTimeDuration>
+bool operator<(const RhsTimeDuration& rhs) const;
</pre>
 Returns: Returns true if less than the rhs duration.
 
 Throws: Nothing
- <pre class="programlisting">template<typename rhs_duration_type>
-bool operator<=(const rhs_duration_type& rhs) const;
+ <pre class="programlisting">
+template<typename RhsTimeDuration>
+bool operator<=(const RhsTimeDuration& rhs) const;
</pre>
 Returns: Returns true if less or equal to the rhs duration.
 
 Throws: Nothing
- <pre class="programlisting">//sign inversion
-duration_type operator-() const
+ <pre class="programlisting">
+//sign inversion
+TimeDuration operator-() const
</pre>
 Returns: Negated value of the duration.
 
 Throws: Nothing
- <pre class="programlisting">//arithmetic operations
-template<typename rhs_duration_type>
-duration_type operator- (const rhs_duration_type& d) const
+ <pre class="programlisting">
+//arithmetic operations
+template<typename RhsTimeDuration>
+TimeDuration operator- (const RhsTimeDuration& d) const
</pre>
 Returns: A duration value equal to this-rhs_duration.
 
- Remarks: This will fail to compiler if the rhs_duration_type is
+ Remarks: This will fail to compiler if the RhsTimeDuration is
 of higher resolution.
 
 Throws: Nothing
- <pre class="programlisting">template<typename rhs_duration_type>
-duration_type operator-=(const rhs_duration_type& d)
+ <pre class="programlisting">
+template<typename RhsTimeDuration>
+TimeDuration operator-=(const RhsTimeDuration& d)
</pre>
 Effects: Modifies to value equal to this-rhs_duration. 
 
 Returns: this 
 
- Remarks: This will fail to compiler if the rhs_duration_type is
+ Remarks: This will fail to compiler if the RhsTimeDuration is
 of higher resolution.
 
 Throws: Nothing
- <pre class="programlisting">template<typename rhs_duration_type>
-duration_type operator+ (const rhs_duration_type& d) const
+ <pre class="programlisting">
+template<typename RhsTimeDuration>
+TimeDuration operator+ (const RhsTimeDuration& d) const
</pre>
 Returns: Duration equal to this+rhs_duration. 
 
- Remarks: This will fail to compiler if the rhs_duration_type is
+ Remarks: This will fail to compiler if the RhsTimeDuration is
 of higher resolution.
 
 Throws: Nothing
- <pre class="programlisting">template<typename rhs_duration_type>
-duration_type operator+=(const rhs_duration_type& d)
+ <pre class="programlisting">
+template<typename RhsTimeDuration>
+TimeDuration operator+=(const RhsTimeDuration& d)
</pre>
 Effects: Modifies to value equal to this+rhs_duration. 
 
 Returns: this 
 
- Remarks: This will fail to compiler if the rhs_duration_type is
+ Remarks: This will fail to compiler if the RhsTimeDuration is
 of higher resolution.
 
 Throws: Nothing
- <pre class="programlisting">duration_type operator/ (int divisor) const
+ <pre class="programlisting">
+TimeDuration operator/ (int divisor) const
</pre>
 Returns: Duration with value equal to this/divisor according to
 integer arithmetic rules.
 
 Throws: Nothing
- <pre class="programlisting">duration_type operator/=(int divisor)
+ <pre class="programlisting">
+TimeDuration operator/=(int divisor)
</pre>
 Effects: Change value of this by this/divisor according to integer
 arithmetic rules.
@@ -2642,19 +2571,22 @@
 Returns: this 
 
 Throws: Nothing
- <pre class="programlisting">duration_type operator* (int rhs) const
+ <pre class="programlisting">
+TimeDuration operator* (int rhs) const
</pre>
 Returns: Duration with value equal to this*rhs 
 
 Throws: Nothing
- <pre class="programlisting">duration_type operator*=(int rhs)
+ <pre class="programlisting">
+TimeDuration 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: Returns the count at the resolution of the time duration
 type.
@@ -2665,12 +2597,13 @@
<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.class_nanoseconds"></a>class nanoseconds</h3></div></div></div>

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

 nanoseconds(long long=0);
- nanoseconds(const nanoseconds& rhs);
+ nanoseconds(const nanoseconds& rhs);
 ~nanoseconds();

 //traits information
@@ -2685,34 +2618,34 @@
</pre></blockquote>

 Class nanoseconds represents a count of nanoseconds.
- <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
 
- ~nanoseconds();
- 
- Effects: Destruct count.
- 
- 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
 
@@ -2721,7 +2654,8 @@

<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.class_microseconds"></a>class microseconds</h3></div></div></div>

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

@@ -2745,40 +2679,41 @@
</pre></blockquote>

 Class microseconds represents a count of microseconds.
- <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
 
- ~microseconds();
- 
- Effects: Destruct count.
- 
- 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
 
@@ -2788,7 +2723,8 @@
<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.class_milliseconds"></a>class milliseconds</h3></div></div></div>

-<blockquote><pre>class milliseconds
+<blockquote><pre>
+class milliseconds
{
 public:
 milliseconds(long long=0);
@@ -2810,44 +2746,46 @@
</pre></blockquote>

 Class milliseconds represents a count of milliseconds.
- <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
 
- ~milliseconds();
- 
- Effects: Destruct count.
- 
- 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
 
@@ -2857,7 +2795,8 @@
<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.class_seconds"></a>class seconds</h3></div></div></div>

-<blockquote><pre>class seconds
+<blockquote><pre>
+class seconds
{
 public:
 seconds(long long s=0);
@@ -2881,49 +2820,52 @@
</pre></blockquote>

 Class seconds represents a count of seconds.
- <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
 
- ~seconds(); 
- 
- Effects: Destruct count.
- 
- 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
 
@@ -2934,7 +2876,8 @@

-<blockquote><pre>class minutes
+<blockquote><pre>
+class minutes
{
 public:
 minutes(long long s=0);
@@ -2959,54 +2902,58 @@
</pre></blockquote>

 Class minutes represents a count of minutes.
- <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
 
- ~minutes(); 
- 
- Effects: Destruct count.
- 
- 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
 
@@ -3014,7 +2961,8 @@
 </div><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.class_hours"></a>class hours</h3></div></div></div>

-<blockquote><pre>class hours
+<blockquote><pre>
+class hours
{
 public:
 hours(long long s=0);
@@ -3042,66 +2990,69 @@


 Class hours represents a count of hours.
- <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
 
- ~hours(); 
- 
- Effects: Destruct count.
- 
- 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
 
 Throws: Nothing
 

-
-
<h2><a name="References">References</a></h2>
<ul>
 <li>
@@ -3119,7 +3070,7 @@
 <li>
 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2043.html">
 N2043</a>, Simplifying And Extending Mutex and Scoped Lock Types For C++
- Multi-Threading Library, Ion Gaztañaga</li>
+ Multi-Threading Library, Ion Gaztaï¿½aga</li>
 <li>
 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2090.html">
 N2090</a>, A Threading API for C++, Peter Dimov</li>
@@ -3138,6 +3089,14 @@
 <li>
 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2285.html">
 N2285</a>, A Multi-threading Library for Standard C++, Revision 2, Pete Becker</li>
+ <li>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2411.html">
+ N2411</a>, Proposal for Date-Time Types in C++0x To Support Threading APIs v2, Jeff Garland</li>
+ <li>
+ <a href="http://www.iso.org/iso/en/CatalogueDetailPage.CatalogueDetail?CSNUMBER=40874">
+ ISO 8601: 2004</a>Data elements and interchange formats -- Information interchange -- Representation of dates and times</li>
+
+
</ul>

@@ -3148,12 +3107,13 @@
Boost.Thread Library, as refined by literally hundreds of other Boost users and
contributors. Dinkumware and Metrowerks (now Freescale) implementations of
Boost.Thread, developed respectively by Pete Becker and Howard Hinnant, created
-further existing practice. Proposals by Pete Becker, Peter Dimov, Ion Gaztañaga,
+further existing practice. Proposals by Pete Becker, Peter Dimov, Ion Gaztaï¿½aga,
and Anthony Williams were also influential. Peter, Ion, and Anthony also
contributed numerous critiques, suggestions, and comments on the current
-proposal, as did other members of an ad hoc threads working group.
+proposal, as did other members of an ad hoc threads working group. Jeff Garland
+contributed the date time portions of the proposal based on the Boost.DateTime
+Library and his TR2 proposals.


</div></body></html><ins class="diff">
</ins>
-

Next message: ghost_at_[hidden]: "[Boost-commit] svn:boost r39805 - trunk/tools/build/v2"
Previous message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r39803 - sandbox/committee/LWG"

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