|
|
Boost-Commit : |
From: hinnant_at_[hidden]
Date: 2007-12-07 14:48:12
Author: hinnant
Date: 2007-12-07 14:48:12 EST (Fri, 07 Dec 2007)
New Revision: 41834
URL: http://svn.boost.org/trac/boost/changeset/41834
Log:
put a bunch of variables in <var>
Text files modified:
sandbox/committee/LWG/thread_library.html | 264 ++++++++++++++++++++--------------------
1 files changed, 132 insertions(+), 132 deletions(-)
Modified: sandbox/committee/LWG/thread_library.html
==============================================================================
--- sandbox/committee/LWG/thread_library.html (original)
+++ sandbox/committee/LWG/thread_library.html 2007-12-07 14:48:12 EST (Fri, 07 Dec 2007)
@@ -3492,34 +3492,34 @@
system_time get_system_time();
template<typename Duration>
- system_time operator+(const Duration& td, const system_time& rhs);
+ system_time operator+(const Duration& <var>td</var>, const system_time& <var>rhs</var>);
template <class LhsDuration, class RhsDuration>
- bool operator==(const LhsDuration& lhs, const RhsDuration& rhs);
+ bool operator==(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);
template <class LhsDuration, class RhsDuration>
- bool operator!=(const LhsDuration& lhs, const RhsDuration& rhs);
+ bool operator!=(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);
template <class LhsDuration, class RhsDuration>
- bool operator< (const LhsDuration& lhs, const RhsDuration& rhs);
+ bool operator< (const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);
template <class LhsDuration, class RhsDuration>
- bool operator<=(const LhsDuration& lhs, const RhsDuration& rhs);
+ bool operator<=(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);
template <class LhsDuration, class RhsDuration>
- bool operator> (const LhsDuration& lhs, const RhsDuration& rhs);
+ bool operator> (const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);
template <class LhsDuration, class RhsDuration>
- bool operator>=(const LhsDuration& lhs, const RhsDuration& rhs);
+ bool operator>=(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);
template <class LhsDuration, class RhsDuration>
- <i>FRDuration</i> operator+(const LhsDuration& lhs, const RhsDuration& rhs)
+ <i>FRDuration</i> operator+(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>)
template <class LhsDuration, class RhsDuration>
- <i>FRDuration</i> operator-(const LhsDuration& lhs, const RhsDuration& rhs)
+ <i>FRDuration</i> operator-(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>)
template <class Duration>
- Duration operator*(Duration lhs, long rhs)
+ Duration operator*(Duration <var>lhs</var>, long <var>rhs</var>)
template <class Duration>
- Duration operator*(long lhs, Duration rhs)
+ Duration operator*(long <var>lhs</var>, Duration <var>rhs</var>)
template <class Duration>
- Duration operator/(Duration lhs, long rhs)
+ Duration operator/(Duration <var>lhs</var>, long <var>rhs</var>)
} // std</code></pre>
</blockquote>
@@ -3640,7 +3640,7 @@
static const bool is_subsecond = true;
// <i>construct/copy/destroy functions</i>
- nanoseconds(long long ns=0);
+ nanoseconds(long long <var>ns</var>=0);
nanoseconds(nanoseconds&&);
nanoseconds& operator=(nanoseconds&&);
@@ -3649,11 +3649,11 @@
<i> // modifier functions</i>
template<typename RhsDuration>
- nanoseconds& operator-=(const RhsDuration& d);
+ nanoseconds& operator-=(const RhsDuration& <var>d</var>);
template<typename RhsDuration>
- nanoseconds& operator+=(const RhsDuration& d);
- nanoseconds& operator*=(long multiplier);
- nanoseconds& operator/=(long divisor);
+ nanoseconds& operator+=(const RhsDuration& <var>d</var>);
+ nanoseconds& operator*=(long <var>multiplier</var>);
+ nanoseconds& operator/=(long <var>divisor</var>);
// <i>operations</i>
nanoseconds operator-() const;
@@ -3661,7 +3661,7 @@
</blockquote>
<pre><code>
-nanoseconds(long long ns=0);</code></pre>
+nanoseconds(long long <var>ns</var>=0);</code></pre>
<blockquote>
<dl>
@@ -3671,7 +3671,7 @@
</dd>
<dt>Postcondition:</dt>
-<dd><code>count() == ns;</code></dd>
+<dd><code>count() == <var>ns</var>;</code></dd>
</dl>
</blockquote>
@@ -3695,7 +3695,7 @@
static const bool is_subsecond = true;
// <i>construct/copy/destroy functions</i>
- microseconds(long long us=0);
+ microseconds(long long <var>us</var>=0);
microseconds(microseconds&&);
microseconds& operator=(microseconds&&);
@@ -3704,11 +3704,11 @@
<i> // modifier functions</i>
template<typename RhsDuration>
- microseconds& operator-=(const RhsDuration& d);
+ microseconds& operator-=(const RhsDuration& <var>d</var>);
template<typename RhsDuration>
- microseconds& operator+=(const RhsDuration& d);
- microseconds& operator*=(long multiplier);
- microseconds& operator/=(long divisor);
+ microseconds& operator+=(const RhsDuration& <var>d</var>);
+ microseconds& operator*=(long <var>multiplier</var>);
+ microseconds& operator/=(long <var>divisor</var>);
// <i>operations</i>
microseconds operator-() const;
@@ -3718,7 +3718,7 @@
};</code></pre>
</blockquote>
-<pre><code>microseconds(long long us=0);</code></pre>
+<pre><code>microseconds(long long <var>us</var>=0);</code></pre>
<blockquote>
<dl>
@@ -3728,7 +3728,7 @@
</dd>
<dt>Postcondition:</dt>
-<dd><code>count() == us;</code></dd>
+<dd><code>count() == <var>us</var>;</code></dd>
</dl>
</blockquote>
@@ -3766,7 +3766,7 @@
static const bool is_subsecond = true;
// <i>construct/copy/destroy functions</i>
- milliseconds(long long ms=0);
+ milliseconds(long long <var>ms</var>=0);
milliseconds(milliseconds&&);
milliseconds& operator=(milliseconds&&);
@@ -3775,11 +3775,11 @@
<i> // modifier functions</i>
template<typename RhsDuration>
- milliseconds& operator-=(const RhsDuration& d);
+ milliseconds& operator-=(const RhsDuration& <var>d</var>);
template<typename RhsDuration>
- milliseconds& operator+=(const RhsDuration& d);
- milliseconds& operator*=(long multiplier);
- milliseconds& operator/=(long divisor);
+ milliseconds& operator+=(const RhsDuration& <var>d</var>);
+ milliseconds& operator*=(long <var>multiplier</var>);
+ milliseconds& operator/=(long <var>divisor</var>);
// <i>operations</i>
milliseconds operator-() const;
@@ -3791,7 +3791,7 @@
</blockquote>
<pre><code>
-milliseconds(long long ms=0);</code></pre>
+milliseconds(long long <var>ms</var>=0);</code></pre>
<blockquote>
<dl>
@@ -3801,7 +3801,7 @@
</dd>
<dt>Postcondition:</dt>
-<dd><code>count() == ms;</code></dd>
+<dd><code>count() == <var>ms</var>;</code></dd>
</dl>
</blockquote>
@@ -3851,7 +3851,7 @@
static const bool is_subsecond = false;
// <i>construct/copy/destroy functions</i>
- seconds(long long s=0);
+ seconds(long long <var>s</var>=0);
seconds(seconds&&);
seconds& operator=(seconds&&);
@@ -3860,11 +3860,11 @@
<i> // modifier functions</i>
template<typename RhsDuration>
- seconds& operator-=(const RhsDuration& d);
+ seconds& operator-=(const RhsDuration& <var>d</var>);
template<typename RhsDuration>
- seconds& operator+=(const RhsDuration& d);
- seconds& operator*=(long multiplier);
- seconds& operator/=(long divisor);
+ seconds& operator+=(const RhsDuration& <var>d</var>);
+ seconds& operator*=(long <var>multiplier</var>);
+ seconds& operator/=(long <var>divisor</var>);
// <i>operations</i>
seconds operator-() const;
@@ -3877,7 +3877,7 @@
</blockquote>
<pre><code>
-seconds(long long s=0);</code></pre>
+seconds(long long <var>s</var>=0);</code></pre>
<blockquote>
<dl>
@@ -3887,7 +3887,7 @@
</dd>
<dt>Postcondition:</dt>
-<dd><code>count() == s;</code></dd>
+<dd><code>count() == <var>s</var>;</code></dd>
</dl>
</blockquote>
@@ -3949,7 +3949,7 @@
static const bool is_subsecond = false;
// <i>construct/copy/destroy functions</i>
- minutes(long long m=0);
+ minutes(long long <var>m</var>=0);
minutes(minutes&&);
minutes& operator=(minutes&&);
@@ -3958,11 +3958,11 @@
<i> // modifier functions</i>
template<typename RhsDuration>
- minutes& operator-=(const RhsDuration& d);
+ minutes& operator-=(const RhsDuration& <var>d</var>);
template<typename RhsDuration>
- minutes& operator+=(const RhsDuration& d);
- minutes& operator*=(long multiplier);
- minutes& operator/=(long divisor);
+ minutes& operator+=(const RhsDuration& <var>d</var>);
+ minutes& operator*=(long <var>multiplier</var>);
+ minutes& operator/=(long <var>divisor</var>);
// <i>operations</i>
minutes operator-() const;
@@ -3976,7 +3976,7 @@
</blockquote>
<pre><code>
-minutes(long long m=0);</code></pre>
+minutes(long long <var>m</var>=0);</code></pre>
<blockquote>
<dl>
@@ -3986,7 +3986,7 @@
</dd>
<dt>Postcondition:</dt>
-<dd><code>count() == n;</code></dd>
+<dd><code>count() == <var>m</var>;</code></dd>
</dl>
</blockquote>
@@ -4060,7 +4060,7 @@
static const bool is_subsecond = false;
// <i>construct/copy/destroy functions</i>
- hours(long long h=0);
+ hours(long long <var>h</var>=0);
hours(hours&&);
hours& operator=(hours&&);
@@ -4069,11 +4069,11 @@
<i> // modifier functions</i>
template<typename RhsDuration>
- hours& operator-=(const RhsDuration& d);
+ hours& operator-=(const RhsDuration& <var>d</var>);
template<typename RhsDuration>
- hours& operator+=(const RhsDuration& d);
- hours& operator*=(long multiplier);
- hours& operator/=(long divisor);
+ hours& operator+=(const RhsDuration& <var>d</var>);
+ hours& operator*=(long <var>multiplier</var>);
+ hours& operator/=(long <var>divisor</var>);
// <i>operations</i>
hours operator-() const;
@@ -4088,7 +4088,7 @@
</blockquote>
<pre><code>
-hours(long long h=0);</code></pre>
+hours(long long <var>h</var>=0);</code></pre>
<blockquote>
<dl>
@@ -4098,7 +4098,7 @@
</dd>
<dt>Postcondition:</dt>
-<dd><code>count() == h;</code></dd>
+<dd><code>count() == <var>h</var>;</code></dd>
</dl>
</blockquote>
@@ -4185,7 +4185,7 @@
public:
system_time();
- explicit system_time(time_t, nanoseconds ns=0);
+ explicit system_time(time_t, nanoseconds <var>ns</var>=0);
time_t seconds_since_epoch() const;
nanoseconds nanoseconds_since_epoch() const;
@@ -4197,27 +4197,27 @@
static const bool is_subsecond = true;
// <em>comparison functions</em>
- 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;
+ bool operator==(const system_time& <var>rhs</var>) const;
+ bool operator!=(const system_time& <var>rhs</var>) const;
+ bool operator>(const system_time& <var>rhs</var>) const;
+ bool operator>=(const system_time& <var>rhs</var>) const;
+ bool operator<(const system_time& <var>rhs</var>) const;
+ bool operator<=(const system_time& <var>rhs</var>) const;
// <em>arithmetic functions</em>
- nanoseconds operator-(const system_time& rhs) const
+ nanoseconds operator-(const system_time& <var>rhs</var>) const
template<typename Duration>
- system_time operator+(const Duration& td) const;
+ system_time operator+(const Duration& <var>td</var>) const;
template<typename Duration>
- system_time& operator+=(const Duration& td);
+ system_time& operator+=(const Duration& <var>td</var>);
template<typename Duration>
- system_time operator-(const Duration& td) const;
+ system_time operator-(const Duration& <var>td</var>) const;
template<typename Duration>
- system_time& operator-=(const Duration& td)
+ system_time& operator-=(const Duration& <var>td</var>)
};</code> </pre>
</blockquote>
@@ -4234,7 +4234,7 @@
</dl>
</blockquote>
- <pre><code>system_time(time_t secs, nanoseconds ns=0);</code> </pre>
+ <pre><code>system_time(time_t secs, nanoseconds <var>ns</var>=0);</code> </pre>
<blockquote>
<dl>
@@ -4242,7 +4242,7 @@
<dd>
Construct<var>s</var> a <code>system_time</code>
time object representing the time point
- <i><code>secs</code></i> + 1,000,000,000*<i><code>ns</code></i> after the epoch.
+ <i><code>secs</code></i> + 1,000,000,000*<i><code><var>ns</var></code></i> after the epoch.
</dd>
<dt>Remarks:</dt>
@@ -4260,7 +4260,7 @@
<dl>
<dt>Returns:</dt>
<dd>
- The seconds since 1970-01-01 00:00:00 represented by the current value
+ The seconds since the epoch time represented by the current value
of <code>*this</code>.
</dd>
@@ -4274,13 +4274,13 @@
<dt>Returns:</dt>
<dd>
The nanoseconds
-since 1970-01-01 00:00:00 represented by the current value of <code>*this</code>.
+since the epoch time represented by the current value of <code>*this</code>.
</dd>
</dl>
</blockquote>
-<pre><code>bool operator==(const system_time& rhs) const;</code></pre>
+<pre><code>bool operator==(const system_time& <var>rhs</var>) const;</code></pre>
<blockquote>
<dl>
@@ -4288,14 +4288,14 @@
<dd>
True if
the time point
-represented by <code>*this</code> is the same as the time point represented by <var>
-<code>rhs</code></var>.
+represented by <code>*this</code> is the same as the time point represented by
+<code><var>rhs</var></code>.
</dd>
</dl>
</blockquote>
-<pre><code>bool operator!=(const system_time& rhs) const;</code></pre>
+<pre><code>bool operator!=(const system_time& <var>rhs</var>) const;</code></pre>
<blockquote>
<dl>
@@ -4303,60 +4303,60 @@
<dd>
True if the time point represented by <code>*this</code> is not the same as the time
point represented
-by <var><code>rhs</code></var>.
+by <code><var>rhs</var></code>.
</dd>
</dl>
</blockquote>
-<pre><code>bool operator>(const system_time& rhs) const;</code></pre>
+<pre><code>bool operator>(const system_time& <var>rhs</var>) const;</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
True if the time point represented by
-<code>*this</code> is later than the time point represented by <var><code>rhs</code></var>.
+<code>*this</code> is later than the time point represented by <code><var>rhs</var></code>.
</dd>
</dl>
</blockquote>
-<pre><code>bool operator>=(const system_time& rhs) const;</code></pre>
+<pre><code>bool operator>=(const system_time& <var>rhs</var>) const;</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
True if the time point represented
-by <code>*this</code> is later or the same as the time point represented by <var>
-<code>rhs</code></var>.
+by <code>*this</code> is later or the same as the time point represented by
+<code><var>rhs</var></code>.
</dd>
</dl>
</blockquote>
-<pre><code>bool operator<(const system_time& rhs) const;</code></pre>
+<pre><code>bool operator<(const system_time& <var>rhs</var>) const;</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
True if the time point represented by <code>*this</code>
-is earlier than the time point represented by <var><code>rhs</code></var>.
+is earlier than the time point represented by <code><var>rhs</var></code>.
</dd>
</dl>
</blockquote>
-<pre><code>bool operator<=(const system_time& rhs) const;</code></pre>
+<pre><code>bool operator<=(const system_time& <var>rhs</var>) const;</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
True if the time pointrepresented by <code>*this</code>
-is earlier or the same as the time point represented by <var><code>rhs</code></var>.
+is earlier or the same as the time point represented by <code><var>rhs</var></code>.
</dd>
</dl>
@@ -4375,20 +4375,20 @@
<dt>Remarks:</dt>
<dd>
-If <code>*this < rhs</code>, the result will be negative.
+If <code>*this < <var>rhs</var></code>, the result will be negative.
</dd>
</dl>
</blockquote>
<pre><code>template<typename Duration>
- system_time operator+(const Duration& td) const;</code></pre>
+ system_time operator+(const Duration& <var>td</var>) const;</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
-The sum of <code>td</code> converted to nanosecond resolution
+The sum of <code><var>td</var></code> converted to nanosecond resolution
and the time represented by <code>*this</code>.
</dd>
@@ -4396,13 +4396,13 @@
</blockquote>
<pre><code>template<typename Duration>
- system_time& operator+=(const Duration& td);</code></pre>
+ system_time& operator+=(const Duration& <var>td</var>);</code></pre>
<blockquote>
<dl>
<dt>Effects:</dt>
<dd>
-Converts <code>td</code> to nanosecond resolution
+Converts <code><var>td</var></code> to nanosecond resolution
and adds it to the time represented by <code>*this</code>.
</dd>
@@ -4414,27 +4414,27 @@
</blockquote>
<pre><code>template<typename Duration>
- system_time operator-(const Duration& td) const;</code></pre>
+ system_time operator-(const Duration& <var>td</var>) const;</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
The difference between the time represented by <code>*this</code> converted to nanosecond resolution
-and <code>td</code>.
+and <code><var>td</var></code>.
</dd>
</dl>
</blockquote>
<pre><code>template<typename Duration>
- system_time& operator-=(const Duration& td)</code></pre>
+ system_time& operator-=(const Duration& <var>td</var>)</code></pre>
<blockquote>
<dl>
<dt>Effects:</dt>
<dd>
-Converts <code>td</code> to nanosecond resolution
+Converts <code><var>td</var></code> to nanosecond resolution
and subtracts it from the time represented by <code>*this</code>.
</dd>
@@ -4472,169 +4472,169 @@
<pre><code>template<typename Duration>
- system_time operator+(const Duration& td, const system_time& rhs);</code></pre>
+ system_time operator+(const Duration& <var>td</var>, const system_time& <var>rhs</var>);</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
-The sum of <code>td</code> converted to nanosecond resolution
-and the time represented by <code>rhs</code>. </dd>
+The sum of <code><var>td</var></code> converted to nanosecond resolution
+and the time represented by <code><var>rhs</var></code>. </dd>
</dl>
</blockquote>
<pre><code>template <class LhsDuration, class RhsDuration>
- bool operator==(const LhsDuration& lhs, const RhsDuration& rhs);</code></pre>
+ bool operator==(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
If the resolution of <code>LhsDuration</code> is the same as the resolution of
-<code>RhsDuration</code>, <code>lhs.count()==rhs.count()</code>.
+<code>RhsDuration</code>, <code><var>lhs</var>.count()==<var>rhs</var>.count()</code>.
Otherwise, if the resolution of <code>LhsDuration</code> is finer than the
-resolution of <code>RhsDuration</code>, <code>lhs.count()==x, where x is
-rhs.count() </code>converted to the resolution of <code>LhsDuration</code>.
-Otherwise, <code>x==rhs.count(), where x is lhs.count() </code>
+resolution of <code>RhsDuration</code>, <code><var>lhs</var>.count()==x, where x is
+<var>rhs</var>.count() </code>converted to the resolution of <code>LhsDuration</code>.
+Otherwise, <code>x==<var>rhs</var>.count(), where x is <var>lhs</var>.count() </code>
converted to the resolution of <code>RhsDuration</code>.</dd>
</dl>
</blockquote>
<pre><code>template <class LhsDuration, class RhsDuration>
- bool operator!=(const LhsDuration& lhs, const RhsDuration& rhs);</code></pre>
+ bool operator!=(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
-<code>!(lhs==rhs)</code>.</dd>
+<code>!(<var>lhs</var>==<var>rhs</var>)</code>.</dd>
</dl>
</blockquote>
<pre><code>template <class LhsDuration, class RhsDuration>
- bool operator< (const LhsDuration& lhs, const RhsDuration& rhs);</code></pre>
+ bool operator< (const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
If the resolution of <code>LhsDuration</code> is the same as the resolution of
-<code>RhsDuration</code>, <code>lhs.count()<rhs.count()</code>.
+<code>RhsDuration</code>, <code><var>lhs</var>.count()<<var>rhs</var>.count()</code>.
Otherwise, if the resolution of <code>LhsDuration</code> is finer than the
-resolution of <code>RhsDuration</code>, <code>lhs.count()<x, where x is
-rhs.count() </code>converted to the resolution of <code>LhsDuration</code>.
-Otherwise, <code>x<rhs.count(), where x is lhs.count() </code>
+resolution of <code>RhsDuration</code>, <code><var>lhs</var>.count()<x, where x is
+<var>rhs</var>.count() </code>converted to the resolution of <code>LhsDuration</code>.
+Otherwise, <code>x<<var>rhs</var>.count(), where x is <var>lhs</var>.count() </code>
converted to the resolution of <code>RhsDuration</code>.</dd>
</dl>
</blockquote>
<pre><code>template <class LhsDuration, class RhsDuration>
- bool operator<=(const LhsDuration& lhs, const RhsDuration& rhs);</code></pre>
+ bool operator<=(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
-<code>!(rhs<lhs)</code>.</dd>
+<code>!(<var>rhs</var><<var>lhs</var>)</code>.</dd>
</dl>
</blockquote>
<pre><code>template <class LhsDuration, class RhsDuration>
- bool operator> (const LhsDuration& lhs, const RhsDuration& rhs);</code></pre>
+ bool operator> (const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
-<code>rhs<lhs)</code>.</dd>
+<code><var>rhs</var><<var>lhs</var>)</code>.</dd>
</dl>
</blockquote>
<pre><code>template <class LhsDuration, class RhsDuration>
- bool operator>=(const LhsDuration& lhs, const RhsDuration& rhs);</code></pre>
+ bool operator>=(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>);</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
-<code>!(lhs<rhs)</code>.</dd>
+<code>!(<var>lhs</var><<var>rhs</var>)</code>.</dd>
</dl>
</blockquote>
<pre><code>template <class LhsDuration, class RhsDuration>
- <i>FRDuration</i> operator+(const LhsDuration& lhs, const RhsDuration& rhs)</code></pre>
+ <i>FRDuration</i> operator+(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>)</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
If the resolution of <code>LhsDuration</code> is the same as the resolution of
-<code>RhsDuration</code>, <code>LhsDuration(lhs.count()+rhs.count())</code>.
+<code>RhsDuration</code>, <code>LhsDuration(<var>lhs</var>.count()+<var>rhs</var>.count())</code>.
Otherwise, if the resolution of <code>LhsDuration</code> is finer than the
-resolution of <code>RhsDuration</code>, <code>LhsDuration(lhs.count()+x),
-where x is rhs.count() </code>converted to the resolution of <code>
-LhsDuration</code>. Otherwise, <code>RhsDuration(x+rhs.count()), where
-x is lhs.count() </code>converted to the resolution of <code>RhsDuration</code>.</dd>
+resolution of <code>RhsDuration</code>, <code>LhsDuration(<var>lhs</var>.count()+x),
+where x is <var>rhs</var>.count() </code>converted to the resolution of <code>
+LhsDuration</code>. Otherwise, <code>RhsDuration(x+<var>rhs</var>.count()), where
+x is <var>lhs</var>.count() </code>converted to the resolution of <code>RhsDuration</code>.</dd>
</dl>
</blockquote>
<pre><code>template <class LhsDuration, class RhsDuration>
- <i>FRDuration</i> operator-(const LhsDuration& lhs, const RhsDuration& rhs)</code></pre>
+ <i>FRDuration</i> operator-(const LhsDuration& <var>lhs</var>, const RhsDuration& <var>rhs</var>)</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
If the resolution of <code>LhsDuration</code> is the same as the resolution of
-<code>RhsDuration</code>, <code>LhsDuration(lhs.count()-rhs.count())</code>.
+<code>RhsDuration</code>, <code>LhsDuration(<var>lhs</var>.count()-<var>rhs</var>.count())</code>.
Otherwise, if the resolution of <code>LhsDuration</code> is finer than the
-resolution of <code>RhsDuration</code>, <code>LhsDuration(lhs.count()-x),
-where x is rhs.count() </code>converted to the resolution of <code>
-LhsDuration</code>. Otherwise, <code>RhsDuration(x-rhs.count()), where
-x is lhs.count() </code>converted to the resolution of <code>RhsDuration</code>.</dd>
+resolution of <code>RhsDuration</code>, <code>LhsDuration(<var>lhs</var>.count()-x),
+where x is <var>rhs</var>.count() </code>converted to the resolution of <code>
+LhsDuration</code>. Otherwise, <code>RhsDuration(x-<var>rhs</var>.count()), where
+x is <var>lhs</var>.count() </code>converted to the resolution of <code>RhsDuration</code>.</dd>
</dl>
</blockquote>
<pre><code>template <class Duration>
- Duration operator*(Duration lhs, long rhs)
+ Duration operator*(Duration <var>lhs</var>, long <var>rhs</var>)
</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
-<code>lhs *= rhs</code>.
+<code><var>lhs</var> *= <var>rhs</var></code>.
</dd>
</dl>
</blockquote>
<pre><code>template <class Duration>
- Duration operator*(long lhs, Duration rhs)
+ Duration operator*(long <var>lhs</var>, Duration <var>rhs</var>)
</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
-<code>rhs *= lhs</code>.
+<code><var>rhs</var> *= <var>lhs</var></code>.
</dd>
</dl>
</blockquote>
<pre><code>template <class Duration>
- Duration operator/(Duration lhs, long rhs)
+ Duration operator/(Duration <var>lhs</var>, long <var>rhs</var>)
</code></pre>
<blockquote>
<dl>
<dt>Returns:</dt>
<dd>
-<code>lhs /= rhs</code>.
+<code><var>lhs</var> /= <var>rhs</var></code>.
</dd>
</dl>
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