Boost-Commit mailing page: [Boost-commit] svn:boost r64112 - in sandbox/chrono/libs/chrono/doc: . html html/boost_chrono/appendices html/boost_chrono/reference html/boost_chrono/users

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r64112 - in sandbox/chrono/libs/chrono/doc: . html html/boost_chrono/appendices html/boost_chrono/reference html/boost_chrono/users_guide
From: vicente.botet_at_[hidden]
Date: 2010-07-17 15:58:25

Author: viboes
Date: 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
New Revision: 64112
URL: http://svn.boost.org/trac/boost/changeset/64112

Log:
Update doc
Text files modified:
   sandbox/chrono/libs/chrono/doc/chrono.qbk | 535 ++++++++++++++++++++++++---------------
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/faq.html | 12
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html | 4
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html | 8
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tickets.html | 32 ++
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html | 4
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html | 301 ++++++++--------------
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated.html | 9
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/formatters.html | 23 +
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/reporters.html | 107 +++++--
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html | 302 ++++++++++++----------
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/examples.html | 15
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/tutorial.html | 24 +
   sandbox/chrono/libs/chrono/doc/html/index.html | 2
   14 files changed, 772 insertions(+), 606 deletions(-)

Modified: sandbox/chrono/libs/chrono/doc/chrono.qbk
==============================================================================
--- sandbox/chrono/libs/chrono/doc/chrono.qbk (original)
+++ sandbox/chrono/libs/chrono/doc/chrono.qbk 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -148,6 +148,9 @@
[/==================]
[def __treat_as_floating_point__ [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.treat_as_floating_point `treat_as_floating_point`]]
[def __duration_values__ [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values `duration_values`]]
+[def __zero__ [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values.zero `zero`]]
+[def __max__ [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values.max `max`]]
+[def __min__ [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values.min `min`]]

[/==================]
@@ -628,16 +631,24 @@

[*Example:]

- typedef __ratio__<5, 3> five_thirds; // five_thirds::num == 5, five_thirds::den == 3
- typedef __ratio__<25, 15> also_five_thirds; // also_five_thirds::num == 5, also_five_thirds::den == 3
- typedef ratio_divide<five_thirds, also_five_thirds>::type one; // one::num == 1, one::den == 1
+ typedef __ratio__<5, 3> five_thirds;
+ // five_thirds::num == 5, five_thirds::den == 3
+
+ typedef __ratio__<25, 15> also_five_thirds;
+ // also_five_thirds::num == 5, also_five_thirds::den == 3
+
+ typedef ratio_divide<five_thirds, also_five_thirds>::type one;
+ // one::num == 1, one::den == 1

This facility also includes convenience typedefs for the SI prefixes __atto through __exa corresponding to their internationally recognized definitions (in terms of __ratio__). This is a tremendous syntactic convenience. It will prevent errors in specifying constants as one no longer has to double count the number of zeros when trying to write million or billion.

[*Example:]

- typedef ratio_multiply<__ratio__<5>, giga>::type _5giga; // _5giga::num == 5000000000, _5giga::den == 1
- typedef ratio_multiply<__ratio__<5>, nano>::type _5nano; // _5nano::num == 1, _5nano::den == 200000000
+ typedef ratio_multiply<__ratio__<5>, giga>::type _5giga;
+ // _5giga::num == 5000000000, _5giga::den == 1
+
+ typedef ratio_multiply<__ratio__<5>, nano>::type _5nano;
+ // _5nano::num == 1, _5nano::den == 200000000

[endsect]

@@ -1510,7 +1521,8 @@
Quantity arithmetics

 template <class R1, class R2, class R3, class R4>
- quantity<typename boost::ratio_subtract<R1, R3>::type, typename boost::ratio_subtract<R2, R4>::type>
+ quantity<typename boost::ratio_subtract<R1, R3>::type,
+ typename boost::ratio_subtract<R2, R4>::type>
 operator/(const quantity<R1, R2>& x, const quantity<R3, R4>& y)
 {
 typedef quantity<typename boost::ratio_subtract<R1, R3>::type,
@@ -1521,7 +1533,8 @@
 }

 template <class R1, class R2, class R3, class R4>
- quantity<typename boost::ratio_add<R1, R3>::type, typename boost::ratio_add<R2, R4>::type>
+ quantity<typename boost::ratio_add<R1, R3>::type,
+ typename boost::ratio_add<R2, R4>::type>
 operator*(const quantity<R1, R2>& x, const quantity<R3, R4>& y)
 {
 typedef quantity<typename boost::ratio_add<R1, R3>::type,
@@ -1592,11 +1605,13 @@
 std::cout << "Acceleration = " << a.get() << " meters/sec^2\n";
 User1::Distance df = compute_distance(s, User1::Time( User1::seconds(0.5) ), a);
 std::cout << "Distance = " << df.get() << " meters\n";
- std::cout << "There are " << User1::mile::ratio::den << '/' << User1::mile::ratio::num << " miles/meter";
+ std::cout << "There are "
+ << User1::mile::ratio::den << '/' << User1::mile::ratio::num << " miles/meter";
 User1::meter mt = 1;
 User1::mile mi = mt;
 std::cout << " which is approximately " << mi.count() << '\n';
- std::cout << "There are " << User1::mile::ratio::num << '/' << User1::mile::ratio::den << " meters/mile";
+ std::cout << "There are "
+ << User1::mile::ratio::num << '/' << User1::mile::ratio::den << " meters/mile";
 mi = 1;
 mt = mi;
 std::cout << " which is approximately " << mt.count() << '\n';
@@ -1775,7 +1790,8 @@
 template <long long speed>
 struct cycle_count
 {
- typedef typename boost::__ratio_multiply__<boost::__ratio__<speed>, boost::__mega>::type frequency; // Mhz
+ typedef typename boost::__ratio_multiply__<boost::__ratio__<speed>, boost::__mega>::type
+ frequency; // Mhz
 typedef typename boost::__ratio_divide__<boost::__ratio__<1>, frequency>::type period;
 typedef long long rep;
 typedef boost::chrono::__duration__<rep, period> duration;
@@ -2540,22 +2556,22 @@
 template <class R1, class R2> struct __ratio_greater_equal;

 // convenience SI typedefs
- typedef __ratio__<1LL, 1000000000000000000LL> __atto;
- typedef __ratio__<1LL, 1000000000000000LL> __femto;
- typedef __ratio__<1LL, 1000000000000LL> __pico;
- typedef __ratio__<1LL, 1000000000LL> __nano;
- typedef __ratio__<1LL, 1000000LL> __micro;
- typedef __ratio__<1LL, 1000LL> __milli;
- typedef __ratio__<1LL, 100LL> __centi;
- typedef __ratio__<1LL, 10LL> __deci;
- typedef __ratio__< 10LL, 1LL> __deca;
- typedef __ratio__< 100LL, 1LL> __hecto;
- typedef __ratio__< 1000LL, 1LL> __kilo;
- typedef __ratio__< 1000000LL, 1LL> __mega;
- typedef __ratio__< 1000000000LL, 1LL> __giga;
- typedef __ratio__< 1000000000000LL, 1LL> __tera;
- typedef __ratio__< 1000000000000000LL, 1LL> __peta;
- typedef __ratio__<1000000000000000000LL, 1LL> __exa;
+ typedef ratio<1LL, 1000000000000000000LL> __atto;
+ typedef ratio<1LL, 1000000000000000LL> __femto;
+ typedef ratio<1LL, 1000000000000LL> __pico;
+ typedef ratio<1LL, 1000000000LL> __nano;
+ typedef ratio<1LL, 1000000LL> __micro;
+ typedef ratio<1LL, 1000LL> __milli;
+ typedef ratio<1LL, 100LL> __centi;
+ typedef ratio<1LL, 10LL> __deci;
+ typedef ratio< 10LL, 1LL> __deca;
+ typedef ratio< 100LL, 1LL> __hecto;
+ typedef ratio< 1000LL, 1LL> __kilo;
+ typedef ratio< 1000000LL, 1LL> __mega;
+ typedef ratio< 1000000000LL, 1LL> __giga;
+ typedef ratio< 1000000000000LL, 1LL> __tera;
+ typedef ratio< 1000000000000000LL, 1LL> __peta;
+ typedef ratio<1000000000000000000LL, 1LL> __exa;
 }

@@ -2589,15 +2605,15 @@
 public:
 static const boost::intmax_t num;
 static const boost::intmax_t den;
- typedef __ratio__<num, den> type;
+ typedef ratio<num, den> type;

 ratio() = default;

 template <intmax_t _N2, intmax_t _D2>
- ratio(const __ratio__<_N2, _D2>&);
+ ratio(const ratio<_N2, _D2>&);

 template <intmax_t _N2, intmax_t _D2>
- __ratio__& operator=(const __ratio__<_N2, _D2>&) {return *this;}
+ ratio& operator=(const ratio<_N2, _D2>&) {return *this;}
 };

A diagnostic will be emitted if __ratio__ is instantiated with `D == 0`, or if the absolute value of `N` or `D` can not be represented. [*Note:] These rules ensure that infinite ratios are avoided and that for any negative input, there exists a representable value of its absolute value which is positive. In a two's complement representation, this excludes the most negative value.
@@ -2612,7 +2628,7 @@

Two __ratio__ classes `__ratio__<N1,D1>` and `__ratio__<N2,D2>` have the same normalized form if `__ratio__<N1,D1>::type` is the same type as `__ratio__<N2,D2>::type`

-[section Construction and assignment]
+[section:ca Construction and assignment]

 template <intmax_t N2, intmax_t D2>
 ratio(const __ratio__<N2, D2>& r);
@@ -2730,7 +2746,7 @@
[section:chrono_hpp Header `<boost/chrono.hpp>`]
[/=============================================]

-This file is a redirection to `boost/chrono/chrono.hpp` including in addition registration for __duration__ and __timepoint__ class templates to Boost.Typeof.
+This file is a redirection to `boost/chrono/chrono.hpp` including in addition registration for __duration__ and __time_point__ class templates to Boost.Typeof.

 #include <boost/chrono/chrono.hpp>
@@ -2773,48 +2789,48 @@

 // duration arithmetic
 template <class Rep1, class Period1, class Rep2, class Period2>
- typename __common_type__<__duration__<Rep1, Period1>, __duration__<Rep2, Period2> >::type
- operator+(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+ operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Rep2, class Period2>
- typename __common_type__<__duration__<Rep1, Period1>, __duration__<Rep2, Period2> >::type
- operator-(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+ operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period, class Rep2>
- __duration__<typename __common_type__<Rep1, Rep2>::type, Period>
- operator*(const __duration__<Rep1, Period>& d, const Rep2& s);
+ duration<typename common_type<Rep1, Rep2>::type, Period>
+ operator*(const duration<Rep1, Period>& d, const Rep2& s);

 template <class Rep1, class Period, class Rep2>
- __duration__<typename __common_type__<Rep1, Rep2>::type, Period>
- operator*(const Rep1& s, const __duration__<Rep2, Period>& d);
+ duration<typename common_type<Rep1, Rep2>::type, Period>
+ operator*(const Rep1& s, const duration<Rep2, Period>& d);

 template <class Rep1, class Period, class Rep2>
- __duration__<typename __common_type__<Rep1, Rep2>::type, Period>
- operator/(const __duration__<Rep1, Period>& d, const Rep2& s);
+ duration<typename common_type<Rep1, Rep2>::type, Period>
+ operator/(const duration<Rep1, Period>& d, const Rep2& s);

 template <class Rep1, class Period1, class Rep2, class Period2>
- typename __common_type__<Rep1, Rep2>::type
- operator/(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ typename common_type<Rep1, Rep2>::type
+ operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Rep2, class Period>
- double operator/(const Rep1& s, const __duration__<Rep2, Period>& d);
+ double operator/(const Rep1& s, const duration<Rep2, Period>& d);

 // duration comparisons
 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator==(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator!=(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator< (const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator<=(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator> (const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator>=(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 // duration_cast

@@ -2822,54 +2838,54 @@
 ToDuration __duration_cast__(const __duration__<Rep, Period>& d);

 // convenience typedefs
- typedef __duration__<boost::int_least64_t, nano> __nanoseconds__; // at least 64 bits needed
- typedef __duration__<boost::int_least64_t, micro> __microseconds__; // at least 55 bits needed
- typedef __duration__<boost::int_least64_t, milli> __milliseconds__; // at least 45 bits needed
- typedef __duration__<boost::int_least64_t> __seconds__; // at least 35 bits needed
- typedef __duration__<boost::int_least32_t, __ratio__< 60> > __minutes__; // at least 29 bits needed
- typedef __duration__<boost::int_least32_t, __ratio__<3600> > __hours__; // at least 23 bits needed
+ typedef duration<boost::int_least64_t, nano> __nanoseconds__; // at least 64 bits needed
+ typedef duration<boost::int_least64_t, micro> __microseconds__; // at least 55 bits needed
+ typedef duration<boost::int_least64_t, milli> __milliseconds__; // at least 45 bits needed
+ typedef duration<boost::int_least64_t> __seconds__; // at least 35 bits needed
+ typedef duration<boost::int_least32_t, ratio< 60> > __minutes__; // at least 29 bits needed
+ typedef duration<boost::int_least32_t, ratio<3600> > __hours__; // at least 23 bits needed

 // time_point arithmetic
 template <class Clock, class Duration1, class Rep2, class Period2>
- __time_point__<Clock, typename __common_type__<Duration1, __duration__<Rep2, Period2> >::type>
- operator+(const __time_point__<Clock, Duration1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
+ operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Clock, class Duration2>
- __time_point__<Clock, typename __common_type__<__duration__<Rep1, Period1>, Duration2>::type>
- operator+(const __duration__<Rep1, Period1>& lhs, const __time_point__<Clock, Duration2>& rhs);
+ time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
+ operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);

 template <class Clock, class Duration1, class Rep2, class Period2>
- __time_point__<Clock, typename __common_type__<Duration1, __duration__<Rep2, Period2> >::type>
- operator-(const __time_point__<Clock, Duration1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
+ operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Clock, class Duration1, class Duration2>
- typename __common_type__<Duration1, Duration2>::type
- operator-(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock,
+ typename common_type<Duration1, Duration2>::type
+ operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock,
 Duration2>& rhs);

 // time_point comparisons
 template <class Clock, class Duration1, class Duration2>
- bool operator==(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock,
- Duration2>& rhs);
+ bool operator==(const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator!=(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock,
- Duration2>& rhs);
+ bool operator!=(const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator< (const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock,
- Duration2>& rhs);
+ bool operator< (const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator<=(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock,
- Duration2>& rhs);
+ bool operator<=(const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator> (const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock,
- Duration2>& rhs);
+ bool operator> (const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator>=(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock,
- Duration2>& rhs);
+ bool operator>=(const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);

 // time_point_cast
 template <class ToDuration, class Clock, class Duration>
- __time_point__<Clock, ToDuration> __time_point_cast__(const __time_point__<Clock, Duration>& t);
+ time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);

 // Clocks
 class __system_clock__;
@@ -2917,7 +2933,7 @@
 [[`C1::period`] [`ratio`] [The tick period of the clock in seconds.]]
 [[`C1::duration`] [`chrono::duration<C1::rep, C1::period>`] [The native __duration__ type of the `clock`.]]
 [[`C1::time_point`] [`chrono::time_point<C1> or chrono::time_point<C2, C1::duration>`] [The native __time_point__ type of the `clock`. Different clocks are permitted to share a __time_point__ definition if it is valid to compare their time_points by comparing their respective __duration_s__. `C1` and `C2` must refer to the same epoch.]]
- [[`C1::is_monotonic`] [`const bool`] [`true` if `t1 <= t2` is always `true`, else `false`. [*Note: A `clock` that can be adjusted backwards is not monotonic]]]
+ [[`C1::is_monotonic`] [`const bool`] [`true` if `t1 <= t2` is always `true`, else `false`. *Note*: A `clock` that can be adjusted backwards is not monotonic]]
 [[`C1::now()`] [`C1::time_point`] [Returns a __time_point__ representing the current point in time.]]
]

@@ -2950,9 +2966,9 @@
 struct duration_values
 {
 public:
- static BOOST_CHRONO_CONSTEXPR Rep zero();
- static BOOST_CHRONO_CONSTEXPR Rep max();
- static BOOST_CHRONO_CONSTEXPR Rep min();
+ static BOOST_CHRONO_CONSTEXPR Rep __zero__();
+ static BOOST_CHRONO_CONSTEXPR Rep __max__();
+ static BOOST_CHRONO_CONSTEXPR Rep __min__();
 };

The __duration__ template uses the __duration_values__ trait to construct special values of the __duration_s__ representation (`Rep`). This is done because the representation might be a class type with behavior which requires some other implementation to return these special values. In that case, the author of that class type should specialize __duration_values__ to return the indicated values.
@@ -3336,7 +3352,8 @@

 template <class Rep1, class Period1, class Rep2, class Period2>
 typename __common_type__<__duration__<Rep1, Period1>, __duration__<Rep2, Period2> >::type
- operator%(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ operator%(const __duration__<Rep1, Period1>& lhs,
+ const __duration__<Rep2, Period2>& rhs);

[*Remarks] This function will not participate in overload resolution unless

@@ -3350,7 +3367,8 @@
[section:duration_operator_eq_1 Non-Member function `operator==(duration,duration)`]

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator==(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator==(const __duration__<Rep1, Period1>& lhs,
+ const __duration__<Rep2, Period2>& rhs);

[*Returns:] Let `CD` represent the __common_type__ of the two __duration__ arguments. Returns `CD(lhs).count() == CD(rhs).count()`

@@ -3358,7 +3376,8 @@
[section:duration_operator_neq_1 Non-Member function `operator!=(duration,duration)`]

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator!=(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator!=(const __duration__<Rep1, Period1>& lhs,
+ const __duration__<Rep2, Period2>& rhs);

[*Returns:] `!(lhs == rhs)`.

@@ -3366,7 +3385,8 @@
[section:duration_operator_lt_1 Non-Member function `operator<(duration,duration)`]

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator< (const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator< (const __duration__<Rep1, Period1>& lhs,
+ const __duration__<Rep2, Period2>& rhs);

[*Returns:] Let `CD` represent the __common_type__ of the two __duration__ arguments. Returns `CD(lhs).count() < CD(rhs).count()`

@@ -3374,7 +3394,8 @@
[section:duration_operator_leq_1 Non-Member function `operator<=(duration,duration)`]

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator<=(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator<=(const __duration__<Rep1, Period1>& lhs,
+ const __duration__<Rep2, Period2>& rhs);

[*Returns:] `!(rhs < lhs)`.

@@ -3382,7 +3403,8 @@
[section:duration_operator_gt_1 Non-Member function `operator>(duration,duration)`]

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator> (const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator> (const __duration__<Rep1, Period1>& lhs,
+ const __duration__<Rep2, Period2>& rhs);

[*Returns:] `rhs < lhs`.

@@ -3390,7 +3412,8 @@
[section:duration_operator_gteq_1 Non-Member function `operator>=(duration,duration)`]

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator>=(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);
+ bool operator>=(const __duration__<Rep1, Period1>& lhs,
+ const __duration__<Rep2, Period2>& rhs);

[*Returns:] `!(lhs < rhs)`.

@@ -3537,7 +3560,8 @@

 template <class Clock, class Duration1, class Rep2, class Period2>
 __time_point__<Clock, typename __common_type__<Duration1, duration<Rep2, Period2> >::type>
- operator+(const __time_point__<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
+ operator+(const __time_point__<Clock, Duration1>& lhs,
+ const duration<Rep2, Period2>& rhs);

[*Returns:] `CT(lhs) += rhs` where `CT` is the type of the return value.

@@ -3546,7 +3570,8 @@

 template <class Rep1, class Period1, class Clock, class Duration2>
 __time_point__<Clock, typename __common_type__<duration<Rep1, Period1>, Duration2>::type>
- operator+(const duration<Rep1, Period1>& lhs, const __time_point__<Clock, Duration2>& rhs);
+ operator+(const duration<Rep1, Period1>& lhs,
+ const __time_point__<Clock, Duration2>& rhs);

[*Returns:] `rhs + lhs`.

@@ -3555,7 +3580,8 @@

 template <class Clock, class Duration1, class Rep2, class Period2>
 __time_point__<Clock, typename __common_type__<Duration1, duration<Rep2, Period2> >::type>
- operator-(const __time_point__<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
+ operator-(const __time_point__<Clock, Duration1>& lhs,
+ const duration<Rep2, Period2>& rhs);

[*Returns:] `lhs + (-rhs)`.

@@ -3564,7 +3590,8 @@

 template <class Clock, class Duration1, class Duration2>
 typename __common_type__<Duration1, Duration2>::type
- operator-(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock, Duration2>& rhs);
+ operator-(const __time_point__<Clock, Duration1>& lhs,
+ const __time_point__<Clock, Duration2>& rhs);

[*Returns:] `lhs.time_since_epoch() - rhs.time_since_epoch()`.

@@ -3575,7 +3602,8 @@
[section:time_point_operator_eq Non-Member function `operator==(time_point,time_point)`]

 template <class Clock, class Duration1, class Duration2>
- bool operator==(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock, Duration2>& rhs);
+ bool operator==(const __time_point__<Clock, Duration1>& lhs,
+ const __time_point__<Clock, Duration2>& rhs);

[*Returns:] `lhs.time_since_epoch() == rhs.time_since_epoch()`.

@@ -3583,7 +3611,8 @@
[section:time_point_operator_neq Non-Member function `operator!=(time_point,time_point)`]

template <class Clock, class Duration1, class Duration2>
- bool operator!=(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock, Duration2>& rhs);
+ bool operator!=(const __time_point__<Clock, Duration1>& lhs,
+ const __time_point__<Clock, Duration2>& rhs);

[*Returns:] `!(lhs == rhs)`.

@@ -3591,7 +3620,8 @@
[section:time_point_operator_lt Non-Member function `operator<(time_point,time_point)`]

 template <class Clock, class Duration1, class Duration2>
- bool operator< (const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock, Duration2>& rhs);
+ bool operator< (const __time_point__<Clock, Duration1>& lhs,
+ const __time_point__<Clock, Duration2>& rhs);

[*Returns:] lhs.time_since_epoch() < rhs.time_since_epoch().

@@ -3599,7 +3629,8 @@
[section:time_point_operator_leq Non-Member function `operator<=(time_point,time_point)`]

 template <class Clock, class Duration1, class Duration2>
- bool operator<=(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock, Duration2>& rhs);
+ bool operator<=(const __time_point__<Clock, Duration1>& lhs,
+ const __time_point__<Clock, Duration2>& rhs);

[*Returns:] `!(rhs < lhs)`.

@@ -3607,7 +3638,8 @@
[section:time_point_operator_gt Non-Member function `operator>(time_point,time_point)`]

template <class Clock, class Duration1, class Duration2>
- bool operator> (const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock, Duration2>& rhs);
+ bool operator>(const __time_point__<Clock, Duration1>& lhs,
+ const __time_point__<Clock, Duration2>& rhs);

[*Returns:] `rhs < lhs`.

@@ -3615,7 +3647,8 @@
[section:time_point_operator_geq Non-Member function `operator>=(time_point,time_point)`]

 template <class Clock, class Duration1, class Duration2>
- bool operator>=(const __time_point__<Clock, Duration1>& lhs, const __time_point__<Clock, Duration2>& rhs);
+ bool operator>=(const __time_point__<Clock, Duration1>& lhs,
+ const __time_point__<Clock, Duration2>& rhs);

[*Returns:] `!(lhs < rhs)`.

@@ -4113,11 +4146,9 @@

[section:stopwatch_req `Stopwatch` Requirements]

-A Stopwatch measure the amount of time elapsed from a start point in time to the stop point time or the accumulation of them.
-
-A Stopwatch must meet the requirements in the following Table.
+A Stopwatch measure the amount of time elapsed from a start point in time to the stop point time or the accumulation of them. Stopwatches can in addition be restarted, suspended and resumed.

-In this table `S`, `S1` and `S2` denote stopwatches types. `s` is an instance of `S`.
+A Stopwatch must meet the requirements in the following table. In this table `S`, `S1` and `S2` denote stopwatches types. `s` is an instance of `S`.

[table Stopwatch Requirements
 [[expression] [return type] [operational semantics]]
@@ -4131,7 +4162,7 @@
 [[`s.start()`] [`S::time_point`] [starts a Stopwatch.]]
 [[`s.restart()`] [`std::pair<S::duration,S::time_point>`] [restarts a Stopwatch.]]
 [[`s.stop()`] [`S::duration`] [stops a Stopwatch.]]
- [[`s.resume()`] [`S::time_point`] [resule a Stopwatch.]]
+ [[`s.resume()`] [`S::time_point`] [resume a Stopwatch.]]
 [[`s.suspend()`] [`S::duration`] [suspends a Stopwatch.]]
 [[`s.elapsed()`] [`S::duration`] [the elapsed time while the Stopwatch was running.]]
]
@@ -4145,7 +4176,7 @@

[*Returns:] the starting time point.

-[*Throw:] Any exception the Clock::now function can throw.
+[*Throw:] Any exception the `Clock::now` function can throw when `ec` is `system::throws`

[endsect]
[section:stopwatch_stop Member Function `stop()`]
@@ -4156,7 +4187,7 @@

[*Returns:] The cummulated elapsed time.

-[*Throw:] Any exception the Clock::now function can throw.
+[*Throw:] Any exception the `Clock::now` function can throw when `ec` is `system::throws`

[endsect]
[section:stopwatch_suspend Member Function `suspend()`]
@@ -4165,7 +4196,7 @@

[*Effect:] Suspends the stopwatch.

-[*Throw:] Any exception the Clock::now function can throw.
+[*Throw:] Any exception the `Clock::now` function can throw when `ec` is `system::throws`

[endsect]
[section:stopwatch_resume Member Function `resume()`]
@@ -4188,7 +4219,7 @@

[*Returns:] the starting time point.

-[*Throw:] Any exception the `Clock::now()` function can throw.
+[*Throw:] Any exception the `Clock::now` function can throw when `ec` is `system::throws`

[endsect]

@@ -4220,7 +4251,7 @@
 };

 typedef <see above> system_stopwatch;
- #ifdef __
+ #ifdef __BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef <see above> monotonic_stopwatch;
 #endif
 typedef <see above> high_resolution_stopwatch;
@@ -4231,6 +4262,8 @@

[section:dont_start_t Class `dont_start_t`]

+Structure used to don't start a `stopwatch` at construction time.
+
 struct dont_start_t;
 static const dont_start_t dont_start;

@@ -4273,31 +4306,76 @@

 };

+[section:c1 Constructor `stopwatch( system::error_code &)`]
+
+ explicit stopwatch( system::error_code & ec = system::throws );
+
+[*Effect:] constructs and starts the stopwatch.
+
+[*Throw:] Any exception the `Clock::now` function can throw when `ec` is `system::throws`
+
+[endsect]
+
+[section:c2 Constructor `stopwatch( dont_start_t &)`]
+
+ explicit stopwatch( const dont_start_t& t );
+
+[*Effect:] constructs the stopwatch without starting it.
+
+[*Throw:] Nothing.
+
+[endsect]
+
+
[section:stopwatch_elapsed Member Function `elapsed()`]

 duration elapsed(system::error_code & ec = system::throws) const;

[*Returns:] the elapsed time from the last call to start.

-[*Throw:] Nothing.
+[*Throw:] Any exception the `Clock::now` function can throw when `ec` is `system::throws`

-[*Note:] the system::error_code & parameter is here to conform to the Stopwatch concept.
+[endsect]

[endsect]

+[section:spec `stopwatch_reporter_default_formatter` Specialization]
+
+The `stopwatch_reporter_default_formatter` of a `stopwatch<Clock>` is a `stopwatch_formatter`.
+
+ template <class Clock>
+ struct stopwatch_reporter_default_formatter<stopwatch<Clock> > {
+ typedef stopwatch_formatter type;
+ };
+
+The `wstopwatch_reporter_default_formatter` of a `stopwatch<Clock>` is a `wstopwatch_formatter`.
+
+ template <class Clock>
+ struct wstopwatch_reporter_default_formatter<stopwatch<Clock> > {
+ typedef wstopwatch_formatter type;
+ };
+
[endsect]

[section:stopwatch_typedefs `stopwatch` useful typedefs]

- typedef boost::chrono::stopwatch< boost::chrono::system_clock > system_stopwatch;
+The library provides stopwatch short cuts for all the models of __Clock__, replacing clock by stopwatch.
+
+ typedef boost::chrono::stopwatch< boost::chrono::system_clock >
+ system_stopwatch;
 #ifdef __BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef boost::chrono::stopwatch< boost::chrono::monotonic_clock > monotonic_stopwatch;
+ typedef boost::chrono::stopwatch< boost::chrono::monotonic_clock >
+ monotonic_stopwatch;
 #endif
- typedef boost::chrono::stopwatch< boost::chrono::high_resolution_clock > high_resolution_stopwatch;
+ typedef boost::chrono::stopwatch< boost::chrono::high_resolution_clock >
+ high_resolution_stopwatch;

- typedef boost::chrono::stopwatch< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch;
- typedef boost::chrono::stopwatch< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch;
- typedef boost::chrono::stopwatch< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch;
+ typedef boost::chrono::stopwatch< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_stopwatch;
+ typedef boost::chrono::stopwatch< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_stopwatch;
+ typedef boost::chrono::stopwatch< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_stopwatch;

[endsect]
[endsect]
@@ -4370,60 +4448,6 @@
[*Effect:] Initialize the elapsed duration and the times counter to 0.

[endsect]
-[section:stopwatch_accumulator_start Member Function `start()`]
-
- time_point start( system::error_code & ec = system::throws );
-
-[*Effect:] Starts running the stopwatch.
-
-[*Returns:] the starting time point.
-
-[*Throw:] Any exception the Clock::now function can throw.
-
-[endsect]
-[section:stopwatch_accumulator_stop Member Function `stop()`]
-
- duration stop( system::error_code & ec = system::throws );
-
-[*Effect:] Stops running the stopwatch. Accumulates the elapsed time since the last start-like operation + the partial accumulated by resume/suspend operation.
-
-[*Returns:] The cummulated elapsed time.
-
-[*Throw:] Any exception the Clock::now function can throw.
-
-[endsect]
-[section:stopwatch_accumulator_suspend Member Function `suspend()`]
-
- duration suspend( system::error_code & ec = system::throws );
-
-[*Effect:] Suspends the stopwatch. Accumulates the elapsed time since the last start-like operation on a partial duration.
-
-[*Throw:] Any exception the Clock::now function can throw.
-
-[endsect]
-[section:stopwatch_accumulator_resume Member Function `resume()`]
-
- time_point resume( system::error_code & ec = system::throws );
-
-[*Effect:] Resumes the stopwatch.
-
-[*Returns:] the starting time point.
-
-[*Throw:] Any exception the Clock::now function can throw.
-
-[endsect]
-
-[section:stopwatch_accumulator_restart Member Function `restart()`]
-
- time_point restart( system::error_code & ec = system::throws );
-
-[*Effect:] Stop/Start the stopwatch.
-
-[*Returns:] the starting time point.
-
-[*Throw:] Any exception the Clock::now function can throw.
-
-[endsect]
[section:stopwatch_accumulator_reset Member Function `reset()`]

 void reset( );
@@ -4455,17 +4479,44 @@

[endsect]

+[section:spec `stopwatch_reporter_default_formatter` Specialization]
+
+The `stopwatch_reporter_default_formatter` of a `stopwatch_accumulator<Clock>` is a `stopwatch_accumulator_formatter`.
+
+ template <class Clock, class Accumulator>
+ struct stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock, Accumulator> > {
+ typedef stopwatch_accumulator_formatter type;
+ };
+
+The `wstopwatch_reporter_default_formatter` of a `stopwatch_accumulator<Clock>` is a `wstopwatch_accumulator_formatter`.
+
+ template <class Clock, class Accumulator>
+ struct wstopwatch_reporter_default_formatter<stopwatch_accumulator<Clock, Accumulator> > {
+ typedef wstopwatch_accumulator_formatter type;
+ };
+
+[endsect]
+
+
[section:stopwatch_accumulator_typedefs `stopwatch_accumulator` useful typedefs]

- typedef boost::chrono::stopwatch_accumulator< boost::chrono::system_clock > system_stopwatch_accumulator;
+The library provides stopwatch_accumulator shortcuts for all the models of __Clock__, replacing clock by stopwatch_accumulator.
+
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::system_clock >
+ system_stopwatch_accumulator;
 #ifdef __BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef boost::chrono::stopwatch_accumulator< boost::chrono::monotonic_clock > monotonic_stopwatch_accumulator;
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::monotonic_clock >
+ monotonic_stopwatch_accumulator;
 #endif
- typedef boost::chrono::stopwatch_accumulator< boost::chrono::high_resolution_clock > high_resolution_stopwatch_accumulator;
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::high_resolution_clock >
+ high_resolution_stopwatch_accumulator;

- typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch_accumulator;
- typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch_accumulator;
- typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch_accumulator;
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_stopwatch_accumulator;
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_stopwatch_accumulator;
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_stopwatch_accumulator;

[endsect]
[endsect]
@@ -4623,13 +4674,15 @@
 template <class Stopwatch>
 struct stopwatch_reporter_default_formatter;

- template <class Stopwatch, class Formatter=typename stopwatch_reporter_default_formatter<Stopwatch>::type>
+ template <class Stopwatch,
+ class Formatter=typename stopwatch_reporter_default_formatter<Stopwatch>::type>
 class stopwatch_reporter;

 template <class Stopwatch>
 struct wstopwatch_reporter_default_formatter;

- template <class Stopwatch, class Formatter=typename wstopwatch_reporter_default_formatter<Stopwatch>::type>
+ template <class Stopwatch,
+ class Formatter=typename wstopwatch_reporter_default_formatter<Stopwatch>::type>
 class wstopwatch_reporter;
 }}

@@ -4951,14 +5004,22 @@
[endsect]
[section:stopclock_typedefs `stopclock` useful typedefs]

- typedef boost::chrono::stopclock< boost::chrono::system_clock > system_stopwatch_stopclock;
+The library provides stopclock shortcuts for all the models of __Clock__, replacing clock by stopclock.
+
+ typedef boost::chrono::stopclock< boost::chrono::system_clock >
+ system_stopwatch_stopclock;
 #ifdef __BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef boost::chrono::stopclock< boost::chrono::monotonic_clock > monotonic_stopwatch_stopclock;
+ typedef boost::chrono::stopclock< boost::chrono::monotonic_clock >
+ monotonic_stopwatch_stopclock;
 #endif
- typedef boost::chrono::stopclock< boost::chrono::high_resolution_clock > high_resolution_stopclock;
- typedef boost::chrono::stopclock< boost::chrono::process_real_cpu_clock > process_real_cpu_stopclock;
- typedef boost::chrono::stopclock< boost::chrono::process_user_cpu_clock > process_user_cpu_stopclock;
- typedef boost::chrono::stopclock< boost::chrono::process_system_cpu_clock > process_system_cpu_stopclock;
+ typedef boost::chrono::stopclock< boost::chrono::high_resolution_clock >
+ high_resolution_stopclock;
+ typedef boost::chrono::stopclock< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_stopclock;
+ typedef boost::chrono::stopclock< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_stopclock;
+ typedef boost::chrono::stopclock< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_stopclock;

[endsect]

@@ -5009,14 +5070,22 @@
[endsect]
[section:wstopclock_typedefs `wstopclock` useful typedefs]

- typedef boost::chrono::wstopclock< boost::chrono::system_clock > system_stopwatch_wstopclock;
+The library provides wstopclock shortcuts for all the models of __Clock__, replacing clock by wstopclock.
+
+ typedef boost::chrono::wstopclock< boost::chrono::system_clock >
+ system_wstopclock;
 #ifdef __BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef boost::chrono::wstopclock< boost::chrono::monotonic_clock > monotonic_stopwatch_wstopclock;
+ typedef boost::chrono::wstopclock< boost::chrono::monotonic_clock >
+ monotonic_wstopclock;
 #endif
- typedef boost::chrono::wstopclock< boost::chrono::high_resolution_clock > high_resolution_wstopclock;
- typedef boost::chrono::wstopclock< boost::chrono::process_real_cpu_clock > process_real_cpu_wstopclock;
- typedef boost::chrono::wstopclock< boost::chrono::process_user_cpu_clock > process_user_cpu_wstopclock;
- typedef boost::chrono::wstopclock< boost::chrono::process_system_cpu_clock > process_system_cpu_wstopclock;
+ typedef boost::chrono::wstopclock< boost::chrono::high_resolution_clock >
+ high_resolution_wstopclock;
+ typedef boost::chrono::wstopclock< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_wstopclock;
+ typedef boost::chrono::wstopclock< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_wstopclock;
+ typedef boost::chrono::wstopclock< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_wstopclock;

[endsect]

@@ -5060,7 +5129,8 @@

 template
 < class Clock=high_resolution_clock
- , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+ , class Formatter=
+ typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
> class basic_stopclock_accumulator
 : public basic_stopwatch_reporter<stopwatch_accumulator<Clock>, Formatter> {
 public:
@@ -5107,7 +5177,8 @@

 template
 < class Clock=high_resolution_clock
- , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+ , class Formatter=
+ typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
> class stopclock_accumulator
 : public basic_stopclock_accumulator<Clock, Formatter> {
 public:
@@ -5149,14 +5220,23 @@
[endsect]
[section:stopclock_accumulator_typedefs `stopclock_accumulator` useful typedefs]

- typedef boost::chrono::stopclock_accumulator< boost::chrono::system_clock > system_stopclock_accumulator;
+The library provides stopclock_accumulator shortcuts for all the models of __Clock__, replacing clock by stopclock_accumulator.
+
+
+ typedef boost::chrono::stopclock_accumulator< boost::chrono::system_clock >
+ system_stopclock_accumulator;
 #ifdef __BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef boost::chrono::stopclock_accumulator< boost::chrono::monotonic_clock > monotonic_stopclock_accumulator;
+ typedef boost::chrono::stopclock_accumulator< boost::chrono::monotonic_clock >
+ monotonic_stopclock_accumulator;
 #endif
- typedef boost::chrono::stopclock_accumulator< boost::chrono::high_resolution_clock > high_resolution_stopclock_accumulator;
- typedef boost::chrono::stopclock_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_stopclock_accumulator;
- typedef boost::chrono::stopclock_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_stopclock_accumulator;
- typedef boost::chrono::stopclock_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_stopclock_accumulator;
+ typedef boost::chrono::stopclock_accumulator< boost::chrono::high_resolution_clock >
+ high_resolution_stopclock_accumulator;
+ typedef boost::chrono::stopclock_accumulator< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_stopclock_accumulator;
+ typedef boost::chrono::stopclock_accumulator< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_stopclock_accumulator;
+ typedef boost::chrono::stopclock_accumulator< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_stopclock_accumulator;

[endsect]
[section:wstopclock_accumulator Template Class `wstopclock_accumulator<>`]
@@ -5165,7 +5245,8 @@

 template
 < class Clock=high_resolution_clock
- , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+ , class Formatter=
+ typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
> class wstopclock_accumulator
 : public basic_wstopclock_accumulator<Clock, Formatter> {
 public:
@@ -5207,14 +5288,22 @@
[endsect]
[section:wstopclock_accumulator_typedefs `wstopclock_accumulator` useful typedefs]

- typedef boost::chrono::wstopclock_accumulator< boost::chrono::system_clock > system_wstopclock_accumulator;
+The library provides wstopclock_accumulator shortcuts for all the models of __Clock__, replacing clock by wstopclock_accumulator.
+
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::system_clock >
+ system_wstopclock_accumulator;
 #ifdef __BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef boost::chrono::wstopclock_accumulator< boost::chrono::monotonic_clock > monotonic_wstopclock_accumulator;
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::monotonic_clock >
+ monotonic_wstopclock_accumulator;
 #endif
- typedef boost::chrono::wstopclock_accumulator< boost::chrono::high_resolution_clock > high_resolution_wstopclock_accumulator;
- typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_wstopclock_accumulator;
- typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_wstopclock_accumulator;
- typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_wstopclock_accumulator;
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::high_resolution_clock >
+ high_resolution_wstopclock_accumulator;
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_wstopclock_accumulator;
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_wstopclock_accumulator;
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_wstopclock_accumulator;

[endsect]
[endsect]
@@ -5343,7 +5432,8 @@
 static int default_places();

 template < class Stopwatch >
- static void show_time( Stopwatch & stopwatch_, const char * format, int places, std::ostream & os, system::error_code & ec);
+ static void show_time( Stopwatch & stopwatch_, const char * format, int places,
+ std::ostream & os, system::error_code & ec);
 };

The default places is given by default_places and is 3.
@@ -5389,7 +5479,8 @@
 static int default_places();

 template <class Stopwatch >
- static void show_time( Stopwatch & stopwatch_, const char * format, int places, std::ostream & os, system::error_code & ec);
+ static void show_time( Stopwatch & stopwatch_, const char * format, int places,
+ std::ostream & os, system::error_code & ec);
 };

The default places is given by default_places and is 3.
@@ -5411,8 +5502,12 @@

[section:typedefs `basic_stopwatch_accumulator_formatter` useful typedefs]

- typedef basic_stopwatch_accumulator_formatter<char> stopwatch_accumulator_formatter;
- typedef basic_stopwatch_accumulator_formatter<wchar_t> wstopwatch_accumulator_formatter;
+The library provides basic_stopwatch_accumulator_formatter shortcuts for char and wchar_t.
+
+ typedef basic_stopwatch_accumulator_formatter<char>
+ stopwatch_accumulator_formatter;
+ typedef basic_stopwatch_accumulator_formatter<wchar_t>
+ wstopwatch_accumulator_formatter;

[endsect]
@@ -5476,6 +5571,8 @@

[section:typedefs `basic_time_formatter` useful typedefs]

+The library provides basic_time_formatter shortcuts for char and wchar_t.
+
 typedef basic_time_formatter<char> time_formatter;
 typedef basic_time_formatter<wchar_t> wtime_formatter;

@@ -5591,6 +5688,8 @@

[section:typedefs `basic_24_hours_formatter` useful typedefs]

+The library provides basic_24_hours_formatter shortcuts for char and wchar_t.
+
 typedef basic_24_hours_formatter<char> t24_hours_formatter;
 typedef basic_24_hours_formatter<wchar_t> wt24_hours_formatter;

@@ -5647,11 +5746,14 @@

[section:timer_typedefs `timer` useful typedefs]

- typedef boost::chrono::timer< boost::chrono::system_clock > system_timer;
+ typedef boost::chrono::timer< boost::chrono::system_clock >
+ system_timer;
 #ifdef __BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef boost::chrono::timer< boost::chrono::monotonic_clock > monotonic_timer;
+ typedef boost::chrono::timer< boost::chrono::monotonic_clock >
+ monotonic_timer;
 #endif
- typedef boost::chrono::timer< boost::chrono::high_resolution_clock > high_resolution_timer;
+ typedef boost::chrono::timer< boost::chrono::high_resolution_clock >
+ high_resolution_timer;

[/
 typedef boost::chrono::timer< boost::chrono::process_real_cpu_clock > process_real_cpu_timer;
@@ -6316,6 +6418,10 @@
 [[7] [min/max macros intrussion] [Take care of Boost min/max recommendations] [Closed]]
 [[8] [declaration of 'typedef class boost::chrono::duration<..> changes meaning of 'duration'] [complete qualification when defining nested typedef duration on clocks to avoid the following compile error:] [Closed]]
 [[9] [VC++ warnings] [disable VC++ foolishness] [Closed]]
+]
+[table
+ [[Ticket] [Description] [Resolution] [State]]
+
 [[10] [conversion warning in test_duration] [removal of conversion warning in test_duration] [Closed]]
 [[11] [MSVC reports a warning instead of an error when there is an integral constant overflow] [manage with MSVC reporting a warning instead of an error when there is an integral constant overflow] [Closed]]
 [[12] [ambiguities with MSVC when using detail:: namespace] [Qualify with boost::detail boost::chrono::detail ] [Closed]]
@@ -6326,7 +6432,10 @@
 [[17] [suspend doesn't works: bad use of system::error_code & ec] [replace by system::error_code ec] [Closed]]
 [[18] [warnings on mingw-gcc.4.4:

-..\..\../boost/chrono/chrono.hpp: In copy constructor 'boost::chrono::time_point<boost::chrono::process_cpu_clock, boost::chrono::duration<boost::chrono::process_cpu_clock::times, boost::ratio<1ll, 1000000000ll> > >::time_point(const boost::chrono::time_point<boost::chrono::process_cpu_clock, boost::chrono::duration<boost::chrono::process_cpu_clock::times, boost::ratio<1ll, 1000000000ll> > >&)':
+..\..\../boost/chrono/chrono.hpp: In copy constructor 'boost::chrono::time_point<boost::chrono::process_cpu_clock,
+boost::chrono::duration<boost::chrono::process_cpu_clock::times, boost::ratio<1ll, 1000000000ll> >
+>::time_point(const boost::chrono::time_point<boost::chrono::process_cpu_clock,
+boost::chrono::duration<boost::chrono::process_cpu_clock::times, boost::ratio<1ll, 1000000000ll> > >&)':
..\..\../boost/chrono/chrono.hpp:816: warning: suggest parentheses around '&&' within '||'
..\..\../boost/chrono/chrono.hpp:816: warning: suggest parentheses around '&&' within '||'

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/faq.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/faq.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/faq.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -29,7 +29,7 @@
<a name="boost_chrono.appendices.faq"></a> Appendix D: FAQ
</h3></div></div></div>
<a name="boost_chrono.appendices.faq.how_important_is_the_order_of_the___link_linkend__boost_chrono_reference_cpp0x_common_type_hpp_common_type___code__phrase_role__identifier__common_type__phrase___code___link__lt__gt__template_arguments_"></a><h4>
-<a name="id4947304"></a>
+<a name="id4947219"></a>
 <a href="faq.html#boost_chrono.appendices.faq.how_important_is_the_order_of_the___link_linkend__boost_chrono_reference_cpp0x_common_type_hpp_common_type___code__phrase_role__identifier__common_type__phrase___code___link__lt__gt__template_arguments_">How
 important is the order of the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
 Class Template common_type<>"><code class="computeroutput">common_type</code></a><> template arguments?</a>
@@ -70,7 +70,7 @@
 also undefined.
 
<a name="boost_chrono.appendices.faq.why_does_stopwatch_reporter_only_display_millisecond_place_precision_when_the_underlying_clock_has_nanosecond_precision_"></a><h4>
-<a name="id4947858"></a>
+<a name="id4947772"></a>
 <a href="faq.html#boost_chrono.appendices.faq.why_does_stopwatch_reporter_only_display_millisecond_place_precision_when_the_underlying_clock_has_nanosecond_precision_">Why
 does stopwatch_reporter only display millisecond place precision when the
 underlying Clock has nanosecond precision?</a>
@@ -81,7 +81,7 @@
 dangerously.
 
<a name="boost_chrono.appendices.faq.why_does_stopwatch_reporter_sometimes_report_more_cpu_seconds_than_real_seconds_"></a><h4>
-<a name="id4947900"></a>
+<a name="id4947814"></a>
 <a href="faq.html#boost_chrono.appendices.faq.why_does_stopwatch_reporter_sometimes_report_more_cpu_seconds_than_real_seconds_">Why
 does stopwatch_reporter sometimes report more cpu seconds than real seconds?</a>
 </h4>
@@ -91,7 +91,7 @@
 be reporting at times.
 
<a name="boost_chrono.appendices.faq.can_i_obtain_statistics_of_the_time_elapsed_between_calls_to_a_function_"></a><h4>
-<a name="id4947933"></a>
+<a name="id4947848"></a>
 <a href="faq.html#boost_chrono.appendices.faq.can_i_obtain_statistics_of_the_time_elapsed_between_calls_to_a_function_">Can
 I obtain statistics of the time elapsed between calls to a function?</a>
 </h4>
@@ -99,13 +99,13 @@
 The library do not provides this feature.
 
<a name="boost_chrono.appendices.faq.what_happens_if_i_press_ctrl_c_and_program_terminates__what_log_would_boost_chrono_output_"></a><h4>
-<a name="id4947962"></a>
+<a name="id4947876"></a>
 <a href="faq.html#boost_chrono.appendices.faq.what_happens_if_i_press_ctrl_c_and_program_terminates__what_log_would_boost_chrono_output_">What
 happens if I press Ctrl+C and program terminates? What log would Boost.chrono
 output?</a>
 </h4>
<a name="boost_chrono.appendices.faq.can_you_explain_the_pros_cons_of___link_linkend__boost_chrono_reference_cpp0x_common_type_hpp_common_type___code__phrase_role__identifier__common_type__phrase___code___link__against_boost_typeof_"></a><h4>
-<a name="id4947991"></a>
+<a name="id4947905"></a>
 <a href="faq.html#boost_chrono.appendices.faq.can_you_explain_the_pros_cons_of___link_linkend__boost_chrono_reference_cpp0x_common_type_hpp_common_type___code__phrase_role__identifier__common_type__phrase___code___link__against_boost_typeof_">Can
 you explain the pros/cons of <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
 Class Template common_type<>"><code class="computeroutput">common_type</code></a> against Boost.Typeof?</a>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -69,7 +69,7 @@
 with a variable lifetime.
 
<a name="boost_chrono.appendices.perf.single_threaded_recursive_function"></a><h4>
-<a name="id4951793"></a>
+<a name="id4951750"></a>
 <a href="perf.html#boost_chrono.appendices.perf.single_threaded_recursive_function">Single-Threaded
 Recursive function</a>
 </h4>
@@ -92,7 +92,7 @@
 and thread_clock.
 
<a name="boost_chrono.appendices.perf.multi_threaded_recursive_function"></a><h4>
-<a name="id4951843"></a>
+<a name="id4951801"></a>
 <a href="perf.html#boost_chrono.appendices.perf.multi_threaded_recursive_function">Multi-Threaded
 Recursive function</a>
 </h4>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -33,7 +33,7 @@
 are an extract from this document.
 
<a name="boost_chrono.appendices.rationale.is_it_possible_for_the_user_to_pass_a___link_linkend__boost_chrono_reference_cpp0x_chrono_chrono_hpp_duration___code__phrase_role__identifier__duration__phrase___code___link__to_a_function_with_the_units_being_ambiguous_"></a><h4>
-<a name="id4945935"></a>
+<a name="id4945849"></a>
 <a href="rationale.html#boost_chrono.appendices.rationale.is_it_possible_for_the_user_to_pass_a___link_linkend__boost_chrono_reference_cpp0x_chrono_chrono_hpp_duration___code__phrase_role__identifier__duration__phrase___code___link__to_a_function_with_the_units_being_ambiguous_">Is
 it possible for the user to pass a <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a> to a function with the
@@ -46,7 +46,7 @@
<pre class="programlisting">f(3); // Will not compile, 3 is not implicitly convertible to any __duration__
</pre>
<a name="boost_chrono.appendices.rationale.why_duration_needs_operator_"></a><h4>
-<a name="id4946035"></a>
+<a name="id4945949"></a>
 <a href="rationale.html#boost_chrono.appendices.rationale.why_duration_needs_operator_">Why
 duration needs operator%</a>
 </h4>
@@ -74,7 +74,7 @@
};
</pre>
<a name="boost_chrono.appendices.rationale.why_ratio_needs_copyconstruction_and_assignment_from_ratios_having_the_same_normalized_form"></a><h4>
-<a name="id4946615"></a>
+<a name="id4946529"></a>
 <a href="rationale.html#boost_chrono.appendices.rationale.why_ratio_needs_copyconstruction_and_assignment_from_ratios_having_the_same_normalized_form">Why
 ratio needs CopyConstruction and Assignment from ratios having the same normalized
 form</a>
@@ -109,7 +109,7 @@
 succeeds.
 
<a name="boost_chrono.appendices.rationale.why_ratio_needs_the_nested_normalizer_typedef_type"></a><h4>
-<a name="id4947024"></a>
+<a name="id4946939"></a>
 <a href="rationale.html#boost_chrono.appendices.rationale.why_ratio_needs_the_nested_normalizer_typedef_type">Why
 ratio needs the nested normalizer typedef type</a>
 </h4>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tickets.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tickets.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tickets.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -303,6 +303,38 @@
 
 </td>
</tr>
+</tbody>
+</table></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Ticket
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Resolution
+ 
+ </th>
+<th>
+ 
+ State
+ 
+ </th>
+</tr></thead>
+<tbody>
<tr>
<td>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -26,7 +26,7 @@
<a name="boost_chrono.appendices.todo"></a> Appendix I: Future plans
</h3></div></div></div>
<a name="boost_chrono.appendices.todo.tasks_to_do_before_review"></a><h4>
-<a name="id4951910"></a>
+<a name="id4951867"></a>
 <a href="todo.html#boost_chrono.appendices.todo.tasks_to_do_before_review">Tasks
 to do before review</a>
 </h4>
@@ -42,7 +42,7 @@
 </li>
</ul></div>
<a name="boost_chrono.appendices.todo.for_later_releases"></a><h4>
-<a name="id4951949"></a>
+<a name="id4951906"></a>
 <a href="todo.html#boost_chrono.appendices.todo.for_later_releases">For later
 releases</a>
 </h4>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -288,53 +288,37 @@
 ratio comparison"><code class="computeroutput">ratio_greater_equal</code></a>;

 // convenience SI typedefs
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><1LL, 1000000000000000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio<1LL, 1000000000000000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">atto</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><1LL, 1000000000000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio<1LL, 1000000000000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">femto</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><1LL, 1000000000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio<1LL, 1000000000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">pico</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><1LL, 1000000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio<1LL, 1000000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">nano</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><1LL, 1000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio<1LL, 1000000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">micro</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><1LL, 1000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio<1LL, 1000LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">milli</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><1LL, 100LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio<1LL, 100LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">centi</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><1LL, 10LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio<1LL, 10LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">deci</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a>< 10LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio< 10LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">deca</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a>< 100LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio< 100LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">hecto</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a>< 1000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio< 1000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">kilo</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a>< 1000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio< 1000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">mega</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a>< 1000000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio< 1000000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">giga</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a>< 1000000000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio< 1000000000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">tera</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a>< 1000000000000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio< 1000000000000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">peta</code></a>;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><1000000000000000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
+ typedef ratio<1000000000000000000LL, 1LL> <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
 SI typedefs"><code class="computeroutput">exa</code></a>;
}
</pre>
@@ -387,26 +371,22 @@
 Template ratio<>"> Class
 Template <code class="computeroutput">ratio<></code></a>
</h5></div></div></div>
-<div class="toc"><dl><dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio.construction_and_assignment">Construction
- and assignment</a></dt></dl></div>
+<div class="toc"><dl><dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio.ca">
+ Construction and assignment</a></dt></dl></div>
<pre class="programlisting">template <boost::intmax_t N, boost::intmax_t D>
class ratio {
public:
 static const boost::intmax_t num;
 static const boost::intmax_t den;
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><num, den> type;
+ typedef ratio<num, den> type;

 ratio() = default;

 template <intmax_t _N2, intmax_t _D2>
- ratio(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><_N2, _D2>&);
+ ratio(const ratio<_N2, _D2>&);

 template <intmax_t _N2, intmax_t _D2>
- <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a>& operator=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><_N2, _D2>&) {return *this;}
+ ratio& operator=(const ratio<_N2, _D2>&) {return *this;}
};
</pre>

@@ -455,9 +435,9 @@
 
<div class="section" lang="en">
<div class="titlepage"><div><div><h6 class="title">
-<a name="boost_chrono.reference.cpp0x.ratio_hpp.ratio.construction_and_assignment"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio.construction_and_assignment" title="Construction
- and assignment">Construction
- and assignment</a>
+<a name="boost_chrono.reference.cpp0x.ratio_hpp.ratio.ca"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio.ca" title="
+ Construction and assignment">
+ Construction and assignment</a>
</h6></div></div></div>
<pre class="programlisting">template <intmax_t N2, intmax_t D2>
 ratio(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
@@ -637,8 +617,9 @@

 This file is a redirection to <code class="computeroutput">boost/chrono/chrono.hpp</code>
 including in addition registration for <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a> and _timepoint_
- class templates to Boost.Typeof.
+ Class template duration<>"><code class="computeroutput">duration</code></a> and <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a> class templates to
+ Boost.Typeof.
 
<pre class="programlisting">#include <boost/chrono/chrono.hpp>
#include <boost/chrono/typeof/boost/chrono/chrono.hpp>
@@ -728,83 +709,48 @@

 // duration arithmetic
 template <class Rep1, class Period1, class Rep2, class Period2>
- typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a>< <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>, <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2> >::type
- operator+(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+ operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Rep2, class Period2>
- typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a>< <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>, <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2> >::type
- operator-(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+ operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period, class Rep2>
- <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a><Rep1, Rep2>::type, Period>
- operator*(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period>& d, const Rep2& s);
+ duration<typename common_type<Rep1, Rep2>::type, Period>
+ operator*(const duration<Rep1, Period>& d, const Rep2& s);

 template <class Rep1, class Period, class Rep2>
- <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a><Rep1, Rep2>::type, Period>
- operator*(const Rep1& s, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period>& d);
+ duration<typename common_type<Rep1, Rep2>::type, Period>
+ operator*(const Rep1& s, const duration<Rep2, Period>& d);

 template <class Rep1, class Period, class Rep2>
- <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a><Rep1, Rep2>::type, Period>
- operator/(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period>& d, const Rep2& s);
+ duration<typename common_type<Rep1, Rep2>::type, Period>
+ operator/(const duration<Rep1, Period>& d, const Rep2& s);

 template <class Rep1, class Period1, class Rep2, class Period2>
- typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a><Rep1, Rep2>::type
- operator/(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ typename common_type<Rep1, Rep2>::type
+ operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Rep2, class Period>
- double operator/(const Rep1& s, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period>& d);
+ double operator/(const Rep1& s, const duration<Rep2, Period>& d);

 // duration comparisons
 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator==(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator!=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator< (const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator<=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator> (const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Rep2, class Period2>
- bool operator>=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

 // duration_cast

@@ -814,101 +760,60 @@
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep, Period>& d);

 // convenience typedefs
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><boost::int_least64_t, nano> <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
+ typedef duration<boost::int_least64_t, nano> <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
 duration typedefs"><code class="computeroutput">nanoseconds</code></a>; // at least 64 bits needed
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><boost::int_least64_t, micro> <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
+ typedef duration<boost::int_least64_t, micro> <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
 duration typedefs"><code class="computeroutput">microseconds</code></a>; // at least 55 bits needed
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><boost::int_least64_t, milli> <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
+ typedef duration<boost::int_least64_t, milli> <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
 duration typedefs"><code class="computeroutput">milliseconds</code></a>; // at least 45 bits needed
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><boost::int_least64_t> <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
+ typedef duration<boost::int_least64_t> <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
 duration typedefs"><code class="computeroutput">seconds</code></a>; // at least 35 bits needed
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><boost::int_least32_t, <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a>< 60> > <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
+ typedef duration<boost::int_least32_t, ratio< 60> > <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
 duration typedefs"><code class="computeroutput">minutes</code></a>; // at least 29 bits needed
- typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><boost::int_least32_t, <a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><3600> > <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
+ typedef duration<boost::int_least32_t, ratio<3600> > <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
 duration typedefs"><code class="computeroutput">hours</code></a>; // at least 23 bits needed

 // time_point arithmetic
 template <class Clock, class Duration1, class Rep2, class Period2>
- <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a><Duration1, <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2> >::type>
- operator+(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
+ operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Rep1, class Period1, class Clock, class Duration2>
- <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a>< <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>, Duration2>::type>
- operator+(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2>& rhs);
+ time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
+ operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);

 template <class Clock, class Duration1, class Rep2, class Period2>
- <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a><Duration1, <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2> >::type>
- operator-(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
+ time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
+ operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);

 template <class Clock, class Duration1, class Duration2>
- typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput">common_type</code></a><Duration1, Duration2>::type
- operator-(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock,
+ typename common_type<Duration1, Duration2>::type
+ operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock,
 Duration2>& rhs);

 // time_point comparisons
 template <class Clock, class Duration1, class Duration2>
- bool operator==(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock,
- Duration2>& rhs);
+ bool operator==(const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator!=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock,
- Duration2>& rhs);
+ bool operator!=(const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator< (const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock,
- Duration2>& rhs);
+ bool operator< (const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator<=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock,
- Duration2>& rhs);
+ bool operator<=(const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator> (const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock,
- Duration2>& rhs);
+ bool operator> (const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- bool operator>=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock,
- Duration2>& rhs);
+ bool operator>=(const time_point<Clock, Duration1>& lhs,
+ const time_point<Clock, Duration2>& rhs);

 // time_point_cast
 template <class ToDuration, class Clock, class Duration>
- <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, ToDuration> <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point_cast" title="
- Non-Member function time_point_cast(time_point)"><code class="computeroutput">time_point_cast</code></a>(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration>& t);
+ time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);

 // Clocks
 class <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.system_clock" title="
@@ -1112,8 +1017,8 @@
 
 <code class="computeroutput">true</code> if <code class="computeroutput">t1 <=
 t2</code> is always <code class="computeroutput">true</code>, else <code class="computeroutput">false</code>.
- Note: A <code class="computeroutput">clock</code>
- that can be adjusted backwards is not monotonic
+ Note: A <code class="computeroutput">clock</code>
+ that can be adjusted backwards is not monotonic
 
 </td>
</tr>
@@ -1224,9 +1129,12 @@
struct duration_values
{
public:
- static BOOST_CHRONO_CONSTEXPR Rep zero();
- static BOOST_CHRONO_CONSTEXPR Rep max();
- static BOOST_CHRONO_CONSTEXPR Rep min();
+ static BOOST_CHRONO_CONSTEXPR Rep <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values.zero" title="
+ Static member Function zero()"><code class="computeroutput">zero</code></a>();
+ static BOOST_CHRONO_CONSTEXPR Rep <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values.max" title="
+ Static member function max()"><code class="computeroutput">max</code></a>();
+ static BOOST_CHRONO_CONSTEXPR Rep <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values.min" title="
+ Static member function min()"><code class="computeroutput">min</code></a>();
};
</pre>

@@ -2062,7 +1970,8 @@
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>, <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2> >::type
operator%(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
</pre>

@@ -2100,7 +2009,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
bool operator==(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
</pre>

@@ -2120,7 +2030,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
bool operator!=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
</pre>

@@ -2136,7 +2047,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
bool operator< (const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
</pre>

@@ -2156,7 +2068,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
bool operator<=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
</pre>

@@ -2172,7 +2085,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
bool operator> (const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
</pre>

@@ -2188,7 +2102,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
bool operator>=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
</pre>

@@ -2481,7 +2396,8 @@
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
 Class Template common_type<>"><code class="computeroutput">common_type</code></a><Duration1, duration<Rep2, Period2> >::type>
operator+(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs,
+ const duration<Rep2, Period2>& rhs);
</pre>

 Returns: <code class="computeroutput">CT(lhs) += rhs</code> where <code class="computeroutput">CT</code>
@@ -2498,7 +2414,8 @@
 <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
 Class Template common_type<>"><code class="computeroutput">common_type</code></a><duration<Rep1, Period1>, Duration2>::type>
-operator+(const duration<Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+operator+(const duration<Rep1, Period1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2>& rhs);
</pre>

@@ -2517,7 +2434,8 @@
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
 Class Template common_type<>"><code class="computeroutput">common_type</code></a><Duration1, duration<Rep2, Period2> >::type>
operator-(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs,
+ const duration<Rep2, Period2>& rhs);
</pre>

 Returns: <code class="computeroutput">lhs
@@ -2534,7 +2452,8 @@
typename <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
 Class Template common_type<>"><code class="computeroutput">common_type</code></a><Duration1, Duration2>::type
operator-(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2>& rhs);
</pre>

@@ -2568,7 +2487,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
bool operator==(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2>& rhs);
</pre>

@@ -2602,7 +2522,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
bool operator< (const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2>& rhs);
</pre>

@@ -2618,7 +2539,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
bool operator<=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2>& rhs);
</pre>

@@ -2634,7 +2556,7 @@
</h6></div></div></div>

 template <class Clock, class Duration1, class Duration2> bool
- operator> (const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ operator>(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>&
 lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2>&
@@ -2653,7 +2575,8 @@
</h6></div></div></div>
<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
bool operator>=(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs,
+ const <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2>& rhs);
</pre>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -114,12 +114,15 @@
 timer useful typedefs">
 <code class="computeroutput">timer</code> useful typedefs</a>
</h5></div></div></div>
-<pre class="programlisting">typedef boost::chrono::timer< boost::chrono::system_clock > system_timer;
+<pre class="programlisting">typedef boost::chrono::timer< boost::chrono::system_clock >
+ system_timer;
#ifdef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.BOOST_CHRONO_HAS_CLOCK_MONOTONIC" title="
 Macro BOOST_CHRONO_HAS_CLOCK_MONOTONIC"><code class="computeroutput">BOOST_CHRONO_HAS_CLOCK_MONOTONIC</code></a>
-typedef boost::chrono::timer< boost::chrono::monotonic_clock > monotonic_timer;
+typedef boost::chrono::timer< boost::chrono::monotonic_clock >
+ monotonic_timer;
#endif
-typedef boost::chrono::timer< boost::chrono::high_resolution_clock > high_resolution_timer;
+typedef boost::chrono::timer< boost::chrono::high_resolution_clock >
+ high_resolution_timer;
</pre>
</div>
</div>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/formatters.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/formatters.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/formatters.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -111,7 +111,8 @@
 static int default_places();

 template < class Stopwatch >
- static void show_time( Stopwatch & stopwatch_, const char * format, int places, std::ostream & os, system::error_code & ec);
+ static void show_time( Stopwatch & stopwatch_, const char * format, int places,
+ std::ostream & os, system::error_code & ec);
};
</pre>

@@ -177,7 +178,8 @@
 static int default_places();

 template <class Stopwatch >
- static void show_time( Stopwatch & stopwatch_, const char * format, int places, std::ostream & os, system::error_code & ec);
+ static void show_time( Stopwatch & stopwatch_, const char * format, int places,
+ std::ostream & os, system::error_code & ec);
};
</pre>

@@ -236,8 +238,14 @@
 <code class="computeroutput">basic_stopwatch_accumulator_formatter</code>
 useful typedefs</a>
</h5></div></div></div>
-<pre class="programlisting">typedef basic_stopwatch_accumulator_formatter<char> stopwatch_accumulator_formatter;
-typedef basic_stopwatch_accumulator_formatter<wchar_t> wstopwatch_accumulator_formatter;
+
+ The library provides basic_stopwatch_accumulator_formatter shortcuts
+ for char and wchar_t.
+ 
+<pre class="programlisting">typedef basic_stopwatch_accumulator_formatter<char>
+ stopwatch_accumulator_formatter;
+typedef basic_stopwatch_accumulator_formatter<wchar_t>
+ wstopwatch_accumulator_formatter;
</pre>
</div>
</div>
@@ -344,6 +352,9 @@
 <code class="computeroutput">basic_time_formatter</code> useful
 typedefs</a>
</h5></div></div></div>
+
+ The library provides basic_time_formatter shortcuts for char and wchar_t.
+ 
<pre class="programlisting">typedef basic_time_formatter<char> time_formatter;
typedef basic_time_formatter<wchar_t> wtime_formatter;
</pre>
@@ -510,6 +521,10 @@
 <code class="computeroutput">basic_24_hours_formatter</code>
 useful typedefs</a>
</h5></div></div></div>
+
+ The library provides basic_24_hours_formatter shortcuts for char and
+ wchar_t.
+ 
<pre class="programlisting">typedef basic_24_hours_formatter<char> t24_hours_formatter;
typedef basic_24_hours_formatter<wchar_t> wt24_hours_formatter;
</pre>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/reporters.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/reporters.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/reporters.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -245,13 +245,15 @@
 template <class Stopwatch>
 struct stopwatch_reporter_default_formatter;

- template <class Stopwatch, class Formatter=typename stopwatch_reporter_default_formatter<Stopwatch>::type>
+ template <class Stopwatch,
+ class Formatter=typename stopwatch_reporter_default_formatter<Stopwatch>::type>
 class stopwatch_reporter;

 template <class Stopwatch>
 struct wstopwatch_reporter_default_formatter;

- template <class Stopwatch, class Formatter=typename wstopwatch_reporter_default_formatter<Stopwatch>::type>
+ template <class Stopwatch,
+ class Formatter=typename wstopwatch_reporter_default_formatter<Stopwatch>::type>
 class wstopwatch_reporter;
}}
</pre>
@@ -648,15 +650,25 @@
 stopclock useful typedefs">
 <code class="computeroutput">stopclock</code> useful typedefs</a>
</h5></div></div></div>
-<pre class="programlisting">typedef boost::chrono::stopclock< boost::chrono::system_clock > system_stopwatch_stopclock;
+
+ The library provides stopclock shortcuts for all the models of <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
+ Clock Requirements"><code class="computeroutput">Clock</code></a>, replacing clock by stopclock.
+ 
+<pre class="programlisting">typedef boost::chrono::stopclock< boost::chrono::system_clock >
+ system_stopwatch_stopclock;
#ifdef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.BOOST_CHRONO_HAS_CLOCK_MONOTONIC" title="
 Macro BOOST_CHRONO_HAS_CLOCK_MONOTONIC"><code class="computeroutput">BOOST_CHRONO_HAS_CLOCK_MONOTONIC</code></a>
-typedef boost::chrono::stopclock< boost::chrono::monotonic_clock > monotonic_stopwatch_stopclock;
+typedef boost::chrono::stopclock< boost::chrono::monotonic_clock >
+ monotonic_stopwatch_stopclock;
#endif
-typedef boost::chrono::stopclock< boost::chrono::high_resolution_clock > high_resolution_stopclock;
-typedef boost::chrono::stopclock< boost::chrono::process_real_cpu_clock > process_real_cpu_stopclock;
-typedef boost::chrono::stopclock< boost::chrono::process_user_cpu_clock > process_user_cpu_stopclock;
-typedef boost::chrono::stopclock< boost::chrono::process_system_cpu_clock > process_system_cpu_stopclock;
+typedef boost::chrono::stopclock< boost::chrono::high_resolution_clock >
+ high_resolution_stopclock;
+typedef boost::chrono::stopclock< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_stopclock;
+typedef boost::chrono::stopclock< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_stopclock;
+typedef boost::chrono::stopclock< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_stopclock;
</pre>
</div>
<div class="section" lang="en">
@@ -716,15 +728,25 @@
 wstopclock useful typedefs">
 <code class="computeroutput">wstopclock</code> useful typedefs</a>
</h5></div></div></div>
-<pre class="programlisting">typedef boost::chrono::wstopclock< boost::chrono::system_clock > system_stopwatch_wstopclock;
+
+ The library provides wstopclock shortcuts for all the models of <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
+ Clock Requirements"><code class="computeroutput">Clock</code></a>, replacing clock by wstopclock.
+ 
+<pre class="programlisting">typedef boost::chrono::wstopclock< boost::chrono::system_clock >
+ system_wstopclock;
#ifdef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.BOOST_CHRONO_HAS_CLOCK_MONOTONIC" title="
 Macro BOOST_CHRONO_HAS_CLOCK_MONOTONIC"><code class="computeroutput">BOOST_CHRONO_HAS_CLOCK_MONOTONIC</code></a>
-typedef boost::chrono::wstopclock< boost::chrono::monotonic_clock > monotonic_stopwatch_wstopclock;
+typedef boost::chrono::wstopclock< boost::chrono::monotonic_clock >
+ monotonic_wstopclock;
#endif
-typedef boost::chrono::wstopclock< boost::chrono::high_resolution_clock > high_resolution_wstopclock;
-typedef boost::chrono::wstopclock< boost::chrono::process_real_cpu_clock > process_real_cpu_wstopclock;
-typedef boost::chrono::wstopclock< boost::chrono::process_user_cpu_clock > process_user_cpu_wstopclock;
-typedef boost::chrono::wstopclock< boost::chrono::process_system_cpu_clock > process_system_cpu_wstopclock;
+typedef boost::chrono::wstopclock< boost::chrono::high_resolution_clock >
+ high_resolution_wstopclock;
+typedef boost::chrono::wstopclock< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_wstopclock;
+typedef boost::chrono::wstopclock< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_wstopclock;
+typedef boost::chrono::wstopclock< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_wstopclock;
</pre>
</div>
</div>
@@ -790,7 +812,8 @@
 
<pre class="programlisting">template
 < class Clock=high_resolution_clock
- , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+ , class Formatter=
+ typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
> class basic_stopclock_accumulator
 : public basic_stopwatch_reporter<stopwatch_accumulator<Clock>, Formatter> {
public:
@@ -843,7 +866,8 @@
 
<pre class="programlisting">template
 < class Clock=high_resolution_clock
- , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+ , class Formatter=
+ typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
> class stopclock_accumulator
 : public basic_stopclock_accumulator<Clock, Formatter> {
public:
@@ -891,15 +915,26 @@
 <code class="computeroutput">stopclock_accumulator</code> useful
 typedefs</a>
</h5></div></div></div>
-<pre class="programlisting">typedef boost::chrono::stopclock_accumulator< boost::chrono::system_clock > system_stopclock_accumulator;
+
+ The library provides stopclock_accumulator shortcuts for all the models
+ of <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
+ Clock Requirements"><code class="computeroutput">Clock</code></a>, replacing clock by stopclock_accumulator.
+ 
+<pre class="programlisting">typedef boost::chrono::stopclock_accumulator< boost::chrono::system_clock >
+ system_stopclock_accumulator;
#ifdef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.BOOST_CHRONO_HAS_CLOCK_MONOTONIC" title="
 Macro BOOST_CHRONO_HAS_CLOCK_MONOTONIC"><code class="computeroutput">BOOST_CHRONO_HAS_CLOCK_MONOTONIC</code></a>
-typedef boost::chrono::stopclock_accumulator< boost::chrono::monotonic_clock > monotonic_stopclock_accumulator;
+typedef boost::chrono::stopclock_accumulator< boost::chrono::monotonic_clock >
+ monotonic_stopclock_accumulator;
#endif
-typedef boost::chrono::stopclock_accumulator< boost::chrono::high_resolution_clock > high_resolution_stopclock_accumulator;
-typedef boost::chrono::stopclock_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_stopclock_accumulator;
-typedef boost::chrono::stopclock_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_stopclock_accumulator;
-typedef boost::chrono::stopclock_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_stopclock_accumulator;
+typedef boost::chrono::stopclock_accumulator< boost::chrono::high_resolution_clock >
+ high_resolution_stopclock_accumulator;
+typedef boost::chrono::stopclock_accumulator< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_stopclock_accumulator;
+typedef boost::chrono::stopclock_accumulator< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_stopclock_accumulator;
+typedef boost::chrono::stopclock_accumulator< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_stopclock_accumulator;
</pre>
</div>
<div class="section" lang="en">
@@ -915,7 +950,8 @@
 
<pre class="programlisting">template
 < class Clock=high_resolution_clock
- , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+ , class Formatter=
+ typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
> class wstopclock_accumulator
 : public basic_wstopclock_accumulator<Clock, Formatter> {
public:
@@ -963,15 +999,26 @@
 <code class="computeroutput">wstopclock_accumulator</code>
 useful typedefs</a>
</h5></div></div></div>
-<pre class="programlisting">typedef boost::chrono::wstopclock_accumulator< boost::chrono::system_clock > system_wstopclock_accumulator;
+
+ The library provides wstopclock_accumulator shortcuts for all the models
+ of <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
+ Clock Requirements"><code class="computeroutput">Clock</code></a>, replacing clock by wstopclock_accumulator.
+ 
+<pre class="programlisting">typedef boost::chrono::wstopclock_accumulator< boost::chrono::system_clock >
+ system_wstopclock_accumulator;
#ifdef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.BOOST_CHRONO_HAS_CLOCK_MONOTONIC" title="
 Macro BOOST_CHRONO_HAS_CLOCK_MONOTONIC"><code class="computeroutput">BOOST_CHRONO_HAS_CLOCK_MONOTONIC</code></a>
-typedef boost::chrono::wstopclock_accumulator< boost::chrono::monotonic_clock > monotonic_wstopclock_accumulator;
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::monotonic_clock >
+ monotonic_wstopclock_accumulator;
#endif
-typedef boost::chrono::wstopclock_accumulator< boost::chrono::high_resolution_clock > high_resolution_wstopclock_accumulator;
-typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_wstopclock_accumulator;
-typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_wstopclock_accumulator;
-typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_wstopclock_accumulator;
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::high_resolution_clock >
+ high_resolution_wstopclock_accumulator;
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_wstopclock_accumulator;
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_wstopclock_accumulator;
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_wstopclock_accumulator;
</pre>
</div>
</div>
@@ -1020,7 +1067,7 @@
}
</pre>
<a name="boost_chrono.reference.reporters.scoped_stopclock_hpp.scoped_stopclock.synopsis"></a><h6>
-<a name="id4930555"></a>
+<a name="id4930454"></a>
 <a href="reporters.html#boost_chrono.reference.reporters.scoped_stopclock_hpp.scoped_stopclock.synopsis">Synopsis</a>
 </h6>
<pre class="programlisting">template < class Clock=process_cpu_clock

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -52,6 +52,9 @@
 Class <code class="computeroutput">dont_start_t</code></a></dt>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch">
 Template Class <code class="computeroutput">stopwatch<></code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.spec">
+ <code class="computeroutput">stopwatch_reporter_default_formatter</code>
+ Specialization</a></dt>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch_typedefs">
 <code class="computeroutput">stopwatch</code> useful typedefs</a></dt>
</dl></dd>
@@ -60,6 +63,9 @@
<dd><dl>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator">
 Template Class <code class="computeroutput">stopwatch_accumulator<></code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.spec">
+ <code class="computeroutput">stopwatch_reporter_default_formatter</code>
+ Specialization</a></dt>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator_typedefs">
 <code class="computeroutput">stopwatch_accumulator</code> useful
 typedefs</a></dt>
@@ -131,13 +137,12 @@
</dl></div>

 A Stopwatch measure the amount of time elapsed from a start point in time
- to the stop point time or the accumulation of them.
+ to the stop point time or the accumulation of them. Stopwatches can in
+ addition be restarted, suspended and resumed.
 

- A Stopwatch must meet the requirements in the following Table.
- 
-
- In this table <code class="computeroutput">S</code>, <code class="computeroutput">S1</code> and <code class="computeroutput">S2</code>
+ A Stopwatch must meet the requirements in the following table. In this
+ table <code class="computeroutput">S</code>, <code class="computeroutput">S1</code> and <code class="computeroutput">S2</code>
 denote stopwatches types. <code class="computeroutput">s</code>
 is an instance of <code class="computeroutput">S</code>.
 
@@ -355,7 +360,7 @@
 </td>
<td>
 
- resule a Stopwatch.
+ resume a Stopwatch.
 
 </td>
</tr>
@@ -411,8 +416,7 @@
 Returns: the starting time point.
 

- Throw: Any exception the Clock::now
- function can throw.
+ Throw: Any exception the <code class="computeroutput">Clock::now</code> function can throw when <code class="computeroutput">ec</code> is <code class="computeroutput">system::throws</code>
 
</div>
<div class="section" lang="en">
@@ -430,8 +434,7 @@
 Returns: The cummulated elapsed time.
 

- Throw: Any exception the Clock::now
- function can throw.
+ Throw: Any exception the <code class="computeroutput">Clock::now</code> function can throw when <code class="computeroutput">ec</code> is <code class="computeroutput">system::throws</code>
 
</div>
<div class="section" lang="en">
@@ -446,8 +449,7 @@
 Effect: Suspends the stopwatch.
 

- Throw: Any exception the Clock::now
- function can throw.
+ Throw: Any exception the <code class="computeroutput">Clock::now</code> function can throw when <code class="computeroutput">ec</code> is <code class="computeroutput">system::throws</code>
 
</div>
<div class="section" lang="en">
@@ -484,8 +486,7 @@
 Returns: the starting time point.
 

- Throw: Any exception the <code class="computeroutput">Clock::now()</code>
- function can throw.
+ Throw: Any exception the <code class="computeroutput">Clock::now</code> function can throw when <code class="computeroutput">ec</code> is <code class="computeroutput">system::throws</code>
 
</div>

@@ -509,6 +510,9 @@
 Class <code class="computeroutput">dont_start_t</code></a></dt>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch">
 Template Class <code class="computeroutput">stopwatch<></code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.spec">
+ <code class="computeroutput">stopwatch_reporter_default_formatter</code>
+ Specialization</a></dt>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch_typedefs">
 <code class="computeroutput">stopwatch</code> useful typedefs</a></dt>
</dl></div>
@@ -529,7 +533,8 @@
 };

 typedef <see above> system_stopwatch;
- #ifdef __
+ #ifdef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.BOOST_CHRONO_HAS_CLOCK_MONOTONIC" title="
+ Macro BOOST_CHRONO_HAS_CLOCK_MONOTONIC"><code class="computeroutput">BOOST_CHRONO_HAS_CLOCK_MONOTONIC</code></a>
 typedef <see above> monotonic_stopwatch;
 #endif
 typedef <see above> high_resolution_stopwatch;
@@ -544,6 +549,10 @@
 Class dont_start_t">
 Class <code class="computeroutput">dont_start_t</code></a>
</h5></div></div></div>
+
+ Structure used to don't start a <code class="computeroutput">stopwatch</code>
+ at construction time.
+ 
<pre class="programlisting">struct dont_start_t;
static const dont_start_t dont_start;
</pre>
@@ -554,8 +563,16 @@
 Template Class stopwatch<>">
 Template Class <code class="computeroutput">stopwatch<></code></a>
</h5></div></div></div>
-<div class="toc"><dl><dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.stopwatch_elapsed">
- Member Function <code class="computeroutput">elapsed()</code></a></dt></dl></div>
+<div class="toc"><dl>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.c1">
+ Constructor <code class="computeroutput">stopwatch( system::error_code
+ &)</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.c2">
+ Constructor <code class="computeroutput">stopwatch( dont_start_t
+ &)</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.stopwatch_elapsed">
+ Member Function <code class="computeroutput">elapsed()</code></a></dt>
+</dl></div>

 <code class="computeroutput">stopwatch<></code>
 is a model of a <a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
@@ -604,6 +621,42 @@
</pre>
<div class="section" lang="en">
<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.c1"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.c1" title="
+ Constructor stopwatch( system::error_code
+ &)">
+ Constructor <code class="computeroutput">stopwatch( system::error_code
+ &)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">explicit stopwatch( system::error_code & ec = system::throws );
+</pre>
+
+ Effect: constructs and starts the
+ stopwatch.
+ 
+
+ Throw: Any exception the <code class="computeroutput">Clock::now</code> function can throw when <code class="computeroutput">ec</code> is <code class="computeroutput">system::throws</code>
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.c2"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.c2" title="
+ Constructor stopwatch( dont_start_t
+ &)">
+ Constructor <code class="computeroutput">stopwatch( dont_start_t
+ &)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">explicit stopwatch( const dont_start_t& t );
+</pre>
+
+ Effect: constructs the stopwatch without
+ starting it.
+ 
+
+ Throw: Nothing.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
<a name="boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.stopwatch_elapsed"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch.stopwatch_elapsed" title="
 Member Function elapsed()">
 Member Function <code class="computeroutput">elapsed()</code></a>
@@ -615,30 +668,65 @@
 last call to start.
 

- Throw: Nothing.
- 
-
- Note: the system::error_code &
- parameter is here to conform to the Stopwatch concept.
+ Throw: Any exception the <code class="computeroutput">Clock::now</code> function can throw when <code class="computeroutput">ec</code> is <code class="computeroutput">system::throws</code>
 
</div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_hpp.spec"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.spec" title="
+ stopwatch_reporter_default_formatter
+ Specialization">
+ <code class="computeroutput">stopwatch_reporter_default_formatter</code>
+ Specialization</a>
+</h5></div></div></div>
+
+ The <code class="computeroutput">stopwatch_reporter_default_formatter</code>
+ of a <code class="computeroutput">stopwatch<Clock></code>
+ is a <code class="computeroutput">stopwatch_formatter</code>.
+ 
+<pre class="programlisting">template <class Clock>
+struct stopwatch_reporter_default_formatter<stopwatch<Clock> > {
+ typedef stopwatch_formatter type;
+};
+</pre>
+
+ The <code class="computeroutput">wstopwatch_reporter_default_formatter</code>
+ of a <code class="computeroutput">stopwatch<Clock></code>
+ is a <code class="computeroutput">wstopwatch_formatter</code>.
+ 
+<pre class="programlisting">template <class Clock>
+struct wstopwatch_reporter_default_formatter<stopwatch<Clock> > {
+ typedef wstopwatch_formatter type;
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
<a name="boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch_typedefs"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch_typedefs" title="
 stopwatch useful typedefs">
 <code class="computeroutput">stopwatch</code> useful typedefs</a>
</h5></div></div></div>
-<pre class="programlisting">typedef boost::chrono::stopwatch< boost::chrono::system_clock > system_stopwatch;
+
+ The library provides stopwatch short cuts for all the models of <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
+ Clock Requirements"><code class="computeroutput">Clock</code></a>, replacing clock by stopwatch.
+ 
+<pre class="programlisting">typedef boost::chrono::stopwatch< boost::chrono::system_clock >
+ system_stopwatch;
#ifdef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.BOOST_CHRONO_HAS_CLOCK_MONOTONIC" title="
 Macro BOOST_CHRONO_HAS_CLOCK_MONOTONIC"><code class="computeroutput">BOOST_CHRONO_HAS_CLOCK_MONOTONIC</code></a>
-typedef boost::chrono::stopwatch< boost::chrono::monotonic_clock > monotonic_stopwatch;
+typedef boost::chrono::stopwatch< boost::chrono::monotonic_clock >
+ monotonic_stopwatch;
#endif
-typedef boost::chrono::stopwatch< boost::chrono::high_resolution_clock > high_resolution_stopwatch;
+typedef boost::chrono::stopwatch< boost::chrono::high_resolution_clock >
+ high_resolution_stopwatch;

-typedef boost::chrono::stopwatch< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch;
-typedef boost::chrono::stopwatch< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch;
-typedef boost::chrono::stopwatch< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch;
+typedef boost::chrono::stopwatch< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_stopwatch;
+typedef boost::chrono::stopwatch< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_stopwatch;
+typedef boost::chrono::stopwatch< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_stopwatch;
</pre>
</div>
</div>
@@ -651,6 +739,9 @@
<div class="toc"><dl>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator">
 Template Class <code class="computeroutput">stopwatch_accumulator<></code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.spec">
+ <code class="computeroutput">stopwatch_reporter_default_formatter</code>
+ Specialization</a></dt>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator_typedefs">
 <code class="computeroutput">stopwatch_accumulator</code> useful
 typedefs</a></dt>
@@ -690,16 +781,6 @@
<div class="toc"><dl>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_c">
 Constructor <code class="computeroutput">stopwatch_accumulator()</code></a></dt>
-<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_start">
- Member Function <code class="computeroutput">start()</code></a></dt>
-<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_stop">
- Member Function <code class="computeroutput">stop()</code></a></dt>
-<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_suspend">
- Member Function <code class="computeroutput">suspend()</code></a></dt>
-<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_resume">
- Member Function <code class="computeroutput">resume()</code></a></dt>
-<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_restart">
- Member Function <code class="computeroutput">restart()</code></a></dt>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_reset">
 Member Function <code class="computeroutput">reset()</code></a></dt>
<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_elapsed">
@@ -756,101 +837,6 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h6 class="title">
-<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_start"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_start" title="
- Member Function start()">
- Member Function <code class="computeroutput">start()</code></a>
-</h6></div></div></div>
-<pre class="programlisting">time_point start( system::error_code & ec = system::throws );
-</pre>
-
- Effect: Starts running the stopwatch.
- 
-
- Returns: the starting time point.
- 
-
- Throw: Any exception the Clock::now
- function can throw.
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h6 class="title">
-<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_stop"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_stop" title="
- Member Function stop()">
- Member Function <code class="computeroutput">stop()</code></a>
-</h6></div></div></div>
-<pre class="programlisting">duration stop( system::error_code & ec = system::throws );
-</pre>
-
- Effect: Stops running the stopwatch.
- Accumulates the elapsed time since the last start-like operation +
- the partial accumulated by resume/suspend operation.
- 
-
- Returns: The cummulated elapsed time.
- 
-
- Throw: Any exception the Clock::now
- function can throw.
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h6 class="title">
-<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_suspend"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_suspend" title="
- Member Function suspend()">
- Member Function <code class="computeroutput">suspend()</code></a>
-</h6></div></div></div>
-<pre class="programlisting">duration suspend( system::error_code & ec = system::throws );
-</pre>
-
- Effect: Suspends the stopwatch. Accumulates
- the elapsed time since the last start-like operation on a partial duration.
- 
-
- Throw: Any exception the Clock::now
- function can throw.
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h6 class="title">
-<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_resume"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_resume" title="
- Member Function resume()">
- Member Function <code class="computeroutput">resume()</code></a>
-</h6></div></div></div>
-<pre class="programlisting">time_point resume( system::error_code & ec = system::throws );
-</pre>
-
- Effect: Resumes the stopwatch.
- 
-
- Returns: the starting time point.
- 
-
- Throw: Any exception the Clock::now
- function can throw.
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h6 class="title">
-<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_restart"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_restart" title="
- Member Function restart()">
- Member Function <code class="computeroutput">restart()</code></a>
-</h6></div></div></div>
-<pre class="programlisting">time_point restart( system::error_code & ec = system::throws );
-</pre>
-
- Effect: Stop/Start the stopwatch.
- 
-
- Returns: the starting time point.
- 
-
- Throw: Any exception the Clock::now
- function can throw.
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h6 class="title">
<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_reset"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator.stopwatch_accumulator_reset" title="
 Member Function reset()">
 Member Function <code class="computeroutput">reset()</code></a>
@@ -898,22 +884,60 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.spec"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.spec" title="
+ stopwatch_reporter_default_formatter
+ Specialization">
+ <code class="computeroutput">stopwatch_reporter_default_formatter</code>
+ Specialization</a>
+</h5></div></div></div>
+
+ The <code class="computeroutput">stopwatch_reporter_default_formatter</code>
+ of a <code class="computeroutput">stopwatch_accumulator<Clock></code> is a <code class="computeroutput">stopwatch_accumulator_formatter</code>.
+ 
+<pre class="programlisting">template <class Clock, class Accumulator>
+struct stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock, Accumulator> > {
+ typedef stopwatch_accumulator_formatter type;
+};
+</pre>
+
+ The <code class="computeroutput">wstopwatch_reporter_default_formatter</code>
+ of a <code class="computeroutput">stopwatch_accumulator<Clock></code> is a <code class="computeroutput">wstopwatch_accumulator_formatter</code>.
+ 
+<pre class="programlisting">template <class Clock, class Accumulator>
+struct wstopwatch_reporter_default_formatter<stopwatch_accumulator<Clock, Accumulator> > {
+ typedef wstopwatch_accumulator_formatter type;
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator_typedefs"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator_typedefs" title="
 stopwatch_accumulator useful
 typedefs">
 <code class="computeroutput">stopwatch_accumulator</code> useful
 typedefs</a>
</h5></div></div></div>
-<pre class="programlisting">typedef boost::chrono::stopwatch_accumulator< boost::chrono::system_clock > system_stopwatch_accumulator;
+
+ The library provides stopwatch_accumulator shortcuts for all the models
+ of <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
+ Clock Requirements"><code class="computeroutput">Clock</code></a>, replacing clock by stopwatch_accumulator.
+ 
+<pre class="programlisting">typedef boost::chrono::stopwatch_accumulator< boost::chrono::system_clock >
+ system_stopwatch_accumulator;
#ifdef <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.BOOST_CHRONO_HAS_CLOCK_MONOTONIC" title="
 Macro BOOST_CHRONO_HAS_CLOCK_MONOTONIC"><code class="computeroutput">BOOST_CHRONO_HAS_CLOCK_MONOTONIC</code></a>
-typedef boost::chrono::stopwatch_accumulator< boost::chrono::monotonic_clock > monotonic_stopwatch_accumulator;
+typedef boost::chrono::stopwatch_accumulator< boost::chrono::monotonic_clock >
+ monotonic_stopwatch_accumulator;
#endif
-typedef boost::chrono::stopwatch_accumulator< boost::chrono::high_resolution_clock > high_resolution_stopwatch_accumulator;
+typedef boost::chrono::stopwatch_accumulator< boost::chrono::high_resolution_clock >
+ high_resolution_stopwatch_accumulator;

-typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch_accumulator;
-typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch_accumulator;
-typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch_accumulator;
+typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_real_cpu_clock >
+ process_real_cpu_stopwatch_accumulator;
+typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_user_cpu_clock >
+ process_user_cpu_stopwatch_accumulator;
+typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_system_cpu_clock >
+ process_system_cpu_stopwatch_accumulator;
</pre>
</div>
</div>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/examples.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/examples.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/examples.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -279,7 +279,8 @@
 Quantity arithmetics
 
<pre class="programlisting">template <class R1, class R2, class R3, class R4>
-quantity<typename boost::ratio_subtract<R1, R3>::type, typename boost::ratio_subtract<R2, R4>::type>
+quantity<typename boost::ratio_subtract<R1, R3>::type,
+ typename boost::ratio_subtract<R2, R4>::type>
operator/(const quantity<R1, R2>& x, const quantity<R3, R4>& y)
{
 typedef quantity<typename boost::ratio_subtract<R1, R3>::type,
@@ -290,7 +291,8 @@
}

template <class R1, class R2, class R3, class R4>
-quantity<typename boost::ratio_add<R1, R3>::type, typename boost::ratio_add<R2, R4>::type>
+quantity<typename boost::ratio_add<R1, R3>::type,
+ typename boost::ratio_add<R2, R4>::type>
operator*(const quantity<R1, R2>& x, const quantity<R3, R4>& y)
{
 typedef quantity<typename boost::ratio_add<R1, R3>::type,
@@ -368,11 +370,13 @@
 std::cout << "Acceleration = " << a.get() << " meters/sec^2\n";
 User1::Distance df = compute_distance(s, User1::Time( User1::seconds(0.5) ), a);
 std::cout << "Distance = " << df.get() << " meters\n";
- std::cout << "There are " << User1::mile::ratio::den << '/' << User1::mile::ratio::num << " miles/meter";
+ std::cout << "There are "
+ << User1::mile::ratio::den << '/' << User1::mile::ratio::num << " miles/meter";
 User1::meter mt = 1;
 User1::mile mi = mt;
 std::cout << " which is approximately " << mi.count() << '\n';
- std::cout << "There are " << User1::mile::ratio::num << '/' << User1::mile::ratio::den << " meters/mile";
+ std::cout << "There are "
+ << User1::mile::ratio::num << '/' << User1::mile::ratio::den << " meters/mile";
 mi = 1;
 mt = mi;
 std::cout << " which is approximately " << mt.count() << '\n';
@@ -605,7 +609,8 @@
{
 typedef typename boost::__ratio_multiply__<boost::<a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
 Template ratio<>"><code class="computeroutput">ratio</code></a><speed>, boost:: <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
- SI typedefs"><code class="computeroutput">mega</code></a>>::type frequency; // Mhz
+ SI typedefs"><code class="computeroutput">mega</code></a>>::type
+ frequency; // Mhz
 typedef typename boost::__ratio_divide__<boost::<a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
 Template ratio<>"><code class="computeroutput">ratio</code></a><1>, frequency>::type period;
 typedef long long rep;

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/tutorial.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/tutorial.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/tutorial.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -223,10 +223,15 @@
 Example:
 
<pre class="programlisting">typedef <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><5, 3> five_thirds; // five_thirds::num == 5, five_thirds::den == 3
-typedef <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><25, 15> also_five_thirds; // also_five_thirds::num == 5, also_five_thirds::den == 3
-typedef ratio_divide<five_thirds, also_five_thirds>::type one; // one::num == 1, one::den == 1
+ Template ratio<>"><code class="computeroutput">ratio</code></a><5, 3> five_thirds;
+// five_thirds::num == 5, five_thirds::den == 3
+
+typedef <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
+ Template ratio<>"><code class="computeroutput">ratio</code></a><25, 15> also_five_thirds;
+// also_five_thirds::num == 5, also_five_thirds::den == 3
+
+typedef ratio_divide<five_thirds, also_five_thirds>::type one;
+// one::num == 1, one::den == 1
</pre>

 This facility also includes convenience typedefs for the SI prefixes <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_si_typedefs" title="
@@ -242,9 +247,12 @@
 Example:
 
<pre class="programlisting">typedef ratio_multiply<<a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><5>, giga>::type _5giga; // _5giga::num == 5000000000, _5giga::den == 1
-typedef ratio_multiply<<a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput">ratio</code></a><5>, nano>::type _5nano; // _5nano::num == 1, _5nano::den == 200000000
+ Template ratio<>"><code class="computeroutput">ratio</code></a><5>, giga>::type _5giga;
+// _5giga::num == 5000000000, _5giga::den == 1
+
+typedef ratio_multiply<<a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
+ Template ratio<>"><code class="computeroutput">ratio</code></a><5>, nano>::type _5nano;
+// _5nano::num == 1, _5nano::den == 200000000
</pre>
</div>
<div class="section" lang="en">
@@ -469,7 +477,7 @@
 fractional part gets silently discarded.
 
<a name="boost_chrono.users_guide.tutorial.duration.what_happens_if_i_assign__m3___us3__to__minutes__instead_of__microseconds__.but_what_if_the_truncation_behavior_is_what_i_want_to_do_"></a><h6>
-<a name="id4816125"></a>
+<a name="id4816133"></a>
 <a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.what_happens_if_i_assign__m3___us3__to__minutes__instead_of__microseconds__.but_what_if_the_truncation_behavior_is_what_i_want_to_do_">But
 what if the truncation behavior is what I want to do?</a>
 </h6>

Modified: sandbox/chrono/libs/chrono/doc/html/index.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/index.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/index.html 2010-07-17 15:58:21 EDT (Sat, 17 Jul 2010)
@@ -95,7 +95,7 @@
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: July 17, 2010 at 12:36:31 GMT</td>
+<td align="left">Last revised: July 17, 2010 at 17:56:48 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Date view	Thread view	Subject view	Author view