Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r66280 - in sandbox/chrono/libs/chrono/doc: . html html/boost_chrono html/boost_chrono/appendices html/boost_chrono/overview html/boost_chrono/reference html/boost_chrono/users_guide
From: vicente.botet_at_[hidden]
Date: 2010-10-30 12:24:08

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r66281 - sandbox/chrono/libs/chrono/example"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r66279 - sandbox/chrono/boost/chrono"

Author: viboes
Date: 2010-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
New Revision: 66280
URL: http://svn.boost.org/trac/boost/changeset/66280

Log:
Chrono: Update doc for 0.7

Text files modified:
   sandbox/chrono/libs/chrono/doc/chrono.qbk | 540 +++++++++++++++++++++++++++------------
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/faq.html | 2
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html | 13
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html | 2
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html | 2
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/description.html | 41 ++-
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html | 7
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html | 102 ++++---
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/io.html | 373 +++++++++++++++++++++++++++
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/other_clocks.html | 14
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide.html | 4
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/examples.html | 168 +----------
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html | 49 ++-
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/tutorial.html | 192 ++++++-------
   sandbox/chrono/libs/chrono/doc/html/index.html | 4
   15 files changed, 992 insertions(+), 521 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-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -32,21 +32,19 @@
[def __header [*Header:]]
[def __compat [*Compiler Compatibility:]]
[def __examples [*Examples:]]
+[def __example [*Example:]]
[def __type [*type:]]
+[def __returns [*Returns:]]
+[def __throws [*Throws:]]
+[def __remarks [*Remarks:]]
+[def __effects [*Effects:]]
+[def __post_conditions [*PostConditions:]]
+[def __pre_conditions [*PreConditions:]]
+[def __requires [*Requires:]]

-[template common_type_link[link_text] [link_text]]
-[def __common_type__ [common_type_link `common_type`]]

-[template common_type_macros[link_text] [link_text]]
-
-[template common_type_pp[link_text] [link_text]]
-
-[def __common_type__BOOST_COMMON_TYPE_USES_STATIC_ASSERT [common_type_macros `BOOST_COMMON_TYPE_USES_STATIC_ASSERT`]]
-[def __common_type__BOOST_COMMON_TYPE_USES_MPL_ASSERT [common_type_macros `BOOST_COMMON_TYPE_USES_MPL_ASSERT`]]
-[def __common_type__BOOST_COMMON_TYPE_USES_ARRAY_ASSERT [common_type_macros `BOOST_COMMON_TYPE_USES_ARRAY_ASSERT`]]
-[def __common_type__BOOST_COMMON_TYPE_ARITY [common_type_pp `BOOST_COMMON_TYPE_ARITY`]]
-[def __common_type__BOOST_COMMON_TYPE_DONT_USE_TYPEOF [common_type_pp `BOOST_COMMON_TYPE_DONT_USE_TYPEOF`]]
+[def __common_type__ `common_type`]

[/===============================================]
@@ -101,6 +99,7 @@

[template chrono_conf[link_text] [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.conf [link_text]]]

+[def __BOOST_CHRONO_INLINED [link boost_chrono.reference.cpp0x.chrono_hpp.conf.header_only `BOOST_CHRONO_INLINED`]]

[def __BOOST_CHRONO_USES_STATIC_ASSERT [chrono_conf `BOOST_CHRONO_USES_STATIC_ASSERT`]]
[def __BOOST_CHRONO_USES_MPL_ASSERT [chrono_conf `BOOST_CHRONO_USES_MPL_ASSERT`]]
@@ -183,6 +182,7 @@
[template thread_clock_link[link_text] [link boost_chrono.reference.other_clocks.thread_clock_hpp.thread_clock [link_text]]]
[def __thread_clock__ [thread_clock_link `thread_clock`]]

+[def __duration_punct__ [link boost_chrono.reference.io.chrono_io_hpp.duration_punct `duration_punct`]]

[warning Chrono is not part of the Boost libraries.]
@@ -241,7 +241,7 @@

[heading Wall clock versus system and user time]

-To make the timing facilities of Boost.Chrono more generally useful, the library provides a number of clocks that are thin wrappers around the operating system's process time API, thereby allowing the extraction of read (wall clock) time, user CPU time, and system CPU time. (On POSIX-like systems, this relies on times(). On Windows, it relies on GetProcessTimes().)
+To make the timing facilities of Boost.Chrono more generally useful, the library provides a number of clocks that are thin wrappers around the operating system's process time API, thereby allowing the extraction of read (wall clock) time, user CPU time, and system CPU time. (On POSIX-like systems, this relies on `times()`. On Windows, it relies on `GetProcessTimes()`.)

[/
It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests.
@@ -273,18 +273,21 @@

The __Boost_Chrono__ library provides:

+[heading Standard]
+
* A means to represent time durations: managed by the generic __duration__ class . Examples of time durations include __days__, __minutes__, __seconds__ and __nanoseconds__, which can be represented with a fixed number of clock ticks per unit. All of these units of time duration are united with a generic interface by the __duration__ facility.
* A type for representing points in time: __time_point__. A __time_point__ represents an epoch plus or minus a __duration__. The library leaves epochs unspecified. A __time_point__ is associated with a /clock/.
* Several clocks, some of which may not be available on a particular platform: __system_clock__, __monotonic_clock__ and __high_resolution_clock__. A clock is a pairing of a __time_point__ and __duration__, and a function which returns a __time_point__ representing ['now].

+[heading Other clocks]

To make the timing facilities more generally useful, __Boost_Chrono__ provides a number of clocks that are thin wrappers around the operating system's time APIs, thereby allowing the extraction of read (wall clock) time, user CPU time, system CPU time,

* __process_real_cpu_clock__, captures real (wall clock) CPU times.
* __process_user_cpu_clock__, captures user-CPU times.
* __process_system_cpu_clock__, captures system-CPU times.
-* A tuple-like class `process_cpu_clock`, that captures real, user-CPU, and system-CPU times together.
-* Thread clocks, when supported by a platform.
+* A tuple-like class __process_cpu_clock__, that captures real, user-CPU, and system-CPU times together.
+* A __thread_clock__ thread monotonic clock, when supported by a platform.

[/It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests. process clocks provide a thin wrapper around the operating system's process timer API. For POSIX-like systems, that's the times() function, while for Windows, it's the GetProcessTimes() function.
@@ -292,14 +295,15 @@

Lastly, __Boost_Chrono__ includes [@http://www.boost.org/libs/typeof typeof] registration for __duration__ and __time_point__ to permit using emulated auto with C++03 compilers.

+[heading I/O]
+
+It provides I/O for __duration__ and __time_point__. It builds on `<boost/ratio/ratio_io.hpp>` to provide readable and flexible formatting and parsing for types in `<boost/chrono.hpp>`. The __duration__ unit names can be customized through a new facet: __duration_punct__.
+

[heading Caveat emptor]

The underlying clocks provided by operating systems are subject to many seemingly arbitrary policies and implementation irregularities. That's a polite way of saying they tend to be flakey, and each operating system or even each clock has its own cruel and unusual forms of flakiness. Don't bet the farm on their accuracy, unless you have become deeply familiar with exactly what the specific operating system is guaranteeing, which is often very little.

-[heading I/O]
-
-It provides I/O for `duration` and `time_point`. It builds on <boost/ratio/ratio_io.hpp> to provide readable and flexible formatting and parsing for types in <boost/chrono.hpp>. The `duration` unit names can be customized through a new facet: `duration_punct`.

[endsect]

@@ -331,17 +335,17 @@
[heading Where to install __Boost_Chrono__? ]
[/==========================================]

-The simple way is to decompress (or checkout from SVN) the file in your BOOST_ROOT directory.
+The simple way is to decompress (or checkout from SVN) the file in your `BOOST_ROOT` directory.

[note If you are using the trunk, don't decompress the type_traits directory.]

-Othesewise, if you decompress in a different directory, you will need to comment some lines, and uncomment and change others in the build/Jamfile and test/Jamfile. Sorry for this, but I have not reached yet to write a Jamfile that is able to work in both environements and use the BOOST_ROOT variable. Any help is welcome.
+Othesewise, if you decompress in a different directory, you will need to comment some lines, and uncomment and change others in the `build/Jamfile` and `test/Jamfile`. Sorry for this, but I have not reached yet to write a `Jamfile` that is able to work in both environements and use the `BOOST_ROOT` variable. Any help is welcome.

[/=================================]
[heading Building __Boost_Chrono__ ]
[/=================================]

-__Boost_Chrono__ can be configured as a header only library. When BOOST_CHRONO_INLINED is defined the lib is header only library. Otherwise is not a header only library and you need to compile it before use.
+__Boost_Chrono__ can be configured as a header only library. When __BOOST_CHRONO_INLINED is defined the lib is header only library. Otherwise is not a header only library and you need to compile it before use.

 bjam libs/chrono/build

@@ -349,7 +353,7 @@
[heading Requirements]
[/===================]

-[*Boost.Chrono] depends on some new traits in Boost.TypeTraits. For these specific parts you must use either the Boost.TypeTraits.Ext or the version in SVN trunk. In addition it depends on the not yet accepted Boost.Ratio library. Except these new dependencies, we have tested with older versions as 1.39.
+__Boost_Chrono__ depends on some new traits in [*Boost.TypeTraits] which have been added on Boost 1.45. For these specific parts you must use either the Boost.TypeTraits.Ext or the version in SVN trunk/release. In addition it depends on the recently accepted [*Boost.Ratio] library. Except these new dependencies, we have tested with older versions as 1.39.

In particular, __Boost_Chrono__ depends on:

@@ -388,8 +392,8 @@
[heading Building an executable that uses __Boost_Chrono__ ]
[/=========================================================]

-In addition to link with the Boost.Chrono library you need also to link with the Boost.System library.
-Once Boost.System will be configurable to be a header only using BOOST_SYSTEM_INLINED you will no need to link with.
+In addition to link with the __Boost_Chrono__ library you need also to link with the [*Boost.System] library.
+Once [*Boost.System] will be configurable to be a header only using __BOOST_SYSTEM_INLINED you will no need to link with.

[/=========================]
@@ -483,7 +487,7 @@

[section Duration]

-The __duration__ is the heart of this library. The interface that the user will see in everyday use is nearly identical to that of Boost.DateTime time __duration_s__ authored by Jeff Garland, both in syntax and in behavior. This has been a very popular boost library for 7 years. There is an enormous positive history with this interface.
+The __duration__ is the heart of this library. The interface that the user will see in everyday use is nearly identical to that of [*Boost.DateTime] time __duration_s__ authored by Jeff Garland, both in syntax and in behavior. This has been a very popular boost library for 7 years. There is an enormous positive history with this interface.

The library consists of six units of time __duration__:

@@ -498,7 +502,7 @@

The only context in which these different types differ is when being converted to one another. At this time, unit-specific compile-time conversion constants are used to convert the source unit to the target unit. Only conversions from coarser units to finer units are allowed (in boost). This restriction ensures that all conversions are always exact. That is, __microseconds__ can always represent any value __minutes__ has.

-In Boost.DateTime, these units are united via inheritance. __Boost_Chrono__ instead unites these units through the class template __duration__. That is, in __Boost_Chrono__ all six of the above units are nothing but typedefs to different instantiations of __duration__. This change from Boost.DateTime has a far reaching positive impact, while not changing the syntax of the everyday use at all.
+In [*Boost.DateTime], these units are united via inheritance. __Boost_Chrono__ instead unites these units through the class template __duration__. That is, in __Boost_Chrono__ all six of the above units are nothing but typedefs to different instantiations of __duration__. This change from Boost.DateTime has a far reaching positive impact, while not changing the syntax of the everyday use at all.

The most immediate positive impact is that the library can immediately generate any unit, any precision it needs. This is sometimes necessary when doing comparisons or arithmetic between __duration_s__ of differing precision, assuming one wants the comparison and arithmetic to be exactly correct.

@@ -517,7 +521,7 @@

The representation is simply any arithmetic type, or an emulation of such a type. The representation stores a count of ticks. This count is the only data member stored in a __duration__. If the representation is floating point, it can store fractions of a tick to the precision of the representation. The tick period is represented by a __ratio__ and is encoded into the __duration__'s type, instead of stored. The tick period only has an impact on the behavior of the __duration__ when a conversion between different __duration__'s is attempted. The tick period is completely ignored when simply doing arithmetic among like __duration_s__.

-[*Example:]
+__example

 typedef __duration__<long, __ratio__<60> > minutes;
 minutes m1(3); // m1 stores 3
@@ -557,7 +561,9 @@

[endsect]

-[section I'm trafficking in floating point `duration`s. I don't want to deal with writing `duration_cast` all over the place. I'm content with the precision of my floating point representation]
+[section Trafficking in floating point durations]
+
+I don't want to deal with writing `duration_cast` all over the place. I'm content with the precision of my floating point representation

Not a problem. When the destination of a conversion has floating point representation, all conversions are allowed to happen implicitly.

@@ -650,9 +656,9 @@

__Boost_Chrono__ provides the standard concrete clocks:

-# system_clock
-# monotonic_clock
-# high_precision_clock
+# __system_clock__
+# __monotonic_clock__
+# __high_precision_clock__

A given platform may not be able to supply all three of these clocks. The user is also able to easily create more clocks.

@@ -722,7 +728,7 @@
 cout << "f() took " << sec.count() << " seconds\n";
 }

-Note that if one is using the __duration__ between two clock __time_point_s__ in a way where the precision of the __duration__ matters, it is good practice to convert the clock's __duration__ to a known __duration__. This insulates the code from future changes which may be made to the clock's precision in the future. For example monotonic_clock could easily be based on the clock speed of the cpu. When you upgrade to a faster machine, you do not want your code that assumed a certain tick period of this clock to start experiencing run time failures because your timing code has silently changed meaning.
+Note that if one is using the __duration__ between two clock __time_point_s__ in a way where the precision of the __duration__ matters, it is good practice to convert the clock's __duration__ to a known __duration__. This insulates the code from future changes which may be made to the clock's precision in the future. For example __monotonic_clock__ could easily be based on the clock speed of the cpu. When you upgrade to a faster machine, you do not want your code that assumed a certain tick period of this clock to start experiencing run time failures because your timing code has silently changed meaning.

A delay loop example:

@@ -731,7 +737,7 @@
 while (monotonic_clock::now() < go)
 ;

-The above code will delay as close as possible to half a microsecond, no matter what the precision of monotonic_clock is. The more precise __monotonic_clock__ becomes, the more accurate will be the delay to 500 nanoseconds.
+The above code will delay as close as possible to half a microsecond, no matter what the precision of __monotonic_clock__ is. The more precise __monotonic_clock__ becomes, the more accurate will be the delay to 500 nanoseconds.

[endsect]
@@ -844,13 +850,13 @@

[section I/O]

-Any `duration` can be streamed out to a `basic_ostream`. The run time value of the `duration` is formatted according to the rules and current format settings for `duration::rep`. This is followed by a single space and then the compile time unit name of the `duration`. This unit name is built on the string returned from `ratio_string` and the data used to construct the `duration_punct` which was inserted into the stream's locale. If a `duration_punct` has not been inserted into the stream's locale, a default constructed `duration_punct` will be added to the stream's locale.
+Any __duration__ can be streamed out to a `basic_ostream`. The run time value of the __duration__ is formatted according to the rules and current format settings for __duration__`::rep`. This is followed by a single space and then the compile time unit name of the __duration__. This unit name is built on the string returned from `ratio_string<>` and the data used to construct the __duration_punct__ which was inserted into the stream's locale. If a __duration_punct__ has not been inserted into the stream's locale, a default constructed __duration_punct__ will be added to the stream's locale.

-`duration` unit names come in two varieties: long and short. The default constructed `duration_punct` provides names in the long format. These names are English descriptions. Other languages are supported by constructing a `duration_punct` with the proper spellings for "hours", "minutes" and "seconds", and their abbreviations (for the short format). The short or long format can be easily chosen by streaming a `duration_short` or `duration_long` manipulator respectively.
+__duration__ unit names come in two varieties: long and short. The default constructed __duration_punct__ provides names in the long format. These names are English descriptions. Other languages are supported by constructing a __duration_punct__ with the proper spellings for hours, "minutes" and "seconds", and their abbreviations (for the short format). The short or long format can be easily chosen by streaming a `duration_short` or `duration_long` manipulator respectively.

-A `time_point` is formatted by outputting its internal `duration` followed by a string that describes the `time_point::clock` epoch. This string will vary for each distinct clock, and for each implementation of the supplied clocks.
+A __time_point__ is formatted by outputting its internal __duration__ followed by a string that describes the __time_point__`::clock` epoch. This string will vary for each distinct clock, and for each implementation of the supplied clocks.

-[*Example:]
+__example

 #include <iostream>
 #include <boost/chrono/chrono_io.hpp>
@@ -913,38 +919,38 @@

For example a stream containing "5000 milliseconds" can be parsed into seconds, but if the stream contains "5001 milliseconds", parsing into `seconds` will cause `failbit` to be set.

-[*Example:]
+__example

-#include <boost/chrono/chrono_io.hpp>
-#include <sstream>
-#include <cassert>
-
-int main()
-{
- using namespace std;
- using namespace boost::chrono;
+ #include <boost/chrono/chrono_io.hpp>
+ #include <sstream>
+ #include <cassert>
+
+ int main()
+ {
+ using namespace std;
+ using namespace boost::chrono;

- istringstream in("5000 milliseconds 4000 ms 3001 ms");
- seconds d(0);
- in >> d;
- assert(in.good());
- assert(d == seconds(5));
- in >> d;
- assert(in.good());
- assert(d == seconds(4));
- in >> d;
- assert(in.fail());
- assert(d == seconds(4));
+ istringstream in("5000 milliseconds 4000 ms 3001 ms");
+ seconds d(0);
+ in >> d;
+ assert(in.good());
+ assert(d == seconds(5));
+ in >> d;
+ assert(in.good());
+ assert(d == seconds(4));
+ in >> d;
+ assert(in.fail());
+ assert(d == seconds(4));

- return 0;
-}
+ return 0;
+ }

Note that a `duration` failure may occur late in the parsing process. This means that the characters making up the failed parse in the stream are usually consumed despite the failure to successfully parse.

Parsing a `time_point` involves first parsing a `duration` and then parsing the epoch string. If the epoch string does not match that associated with `time_point::clock` then failbit will be set.

-[*Example:]
+__example

 #include <boost/chrono/chrono_io.hpp>
 #include <sstream>
@@ -1546,6 +1552,7 @@

[endsect]

+[/
[/===============================================================]
[section time command]

@@ -1591,6 +1598,7 @@
['See the source file [@../../example/timex.cpp example/timex.cpp]]

[endsect]
+]

[section 24 hours display]

@@ -1694,7 +1702,7 @@

The C++0x standard library's multi-threading library requires the ability to deal with the representation of time in a manner consistent with modern C++ practices. Next follows a simaulation of this interface.

-Free sleep functions
+The non-member sleep functions can be emulated as follows:

 namespace boost { namespace this_thread {

@@ -1729,7 +1737,7 @@
 }}

-timed_mutex modified fuctions
+Next follows the `boost::thread::timed_mutex` modified fuctions

 namespace boost {
 struct timed_mutex {
@@ -1766,7 +1774,7 @@
 };
 }

-condition_variable modified fuctions
+`boost::thread::condition_variable` time related function are modified as follows:

 namespace boost {
 struct condition_variable
@@ -1801,7 +1809,7 @@
 };
 }

-Usage
+Next follows how how sumple is the usage of this functions:

 boost::mutex m;
 boost::timed_mutex mut;
@@ -1883,14 +1891,13 @@

Next follows limitation respect to the C++0x recomendations:

-* [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3135.html#1121 Ratio values should be constexpr]: `constexpr` don't used as no compiler supports it today. `const` is used instead when appropiated.
-
-* [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3134.html#921 Rational Arithmetic should use template aliases]: In the absence of compiler support of template aliases the C++03 emulation define a nested typedef `type`.
+* `constexpr` don't used for `min()`, `max()` and `zero()` __duration_values__ class as no compiler supports it today. `const` is used instead when appropiated.

The current implementation provides in addition:

* clock error handling as specified in [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3135.html#3155 clock error handling needs to be specified].
-
+* process and thread clocks.
+

[endsect]

@@ -1898,15 +1905,15 @@

[section:assert How Assert behaves?]

-When BOOST_NO_STATIC_ASSERT is defined, the user can select the way static assertions are reported. Define
+When `BOOST_NO_STATIC_ASSERT` is defined, the user can select the way static assertions are reported. Define

-* BOOST_CHRONO_USES_STATIC_ASSERT: define it if you want to use Boost.StaticAssert
-* BOOST_CHRONO_USES_MPL_ASSERT: define it if you want to use Boost.MPL static asertions
-* BOOST_CHRONO_USES_ARRAY_ASSERT: define it if you want to use internal static asertions
+* `BOOST_CHRONO_USES_STATIC_ASSERT`: define it if you want to use Boost.StaticAssert
+* `BOOST_CHRONO_USES_MPL_ASSERT`: define it if you want to use Boost.MPL static asertions
+* `BOOST_CHRONO_USES_ARRAY_ASSERT`: define it if you want to use internal static asertions

-The default vaule behavior is as BOOST_CHRONO_USES_ARRAY_ASSERT was defined.
+The default vaule behavior is as `BOOST_CHRONO_USES_ARRAY_ASSERT` was defined.

-When BOOST_CHRONO_USES_MPL_ASSERT is not defined the following symbols are defined as
+When `BOOST_CHRONO_USES_MPL_ASSERT` is not defined the following symbols are defined as

 #define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION \
 "A duration representation can not be a duration"
@@ -1918,9 +1925,10 @@
 "Second template parameter of time_point must be a boost::chrono::duration"

Depending on the static assertion used system you will have an hint of the failing assertion either through the symbol or through the texte.
+
[endsect]

-[section:header_only How to build __Boost_Chrono__ as a header only lib?]
+[section:header_only How to build __Boost_Chrono__ as a header only library?]

When `BOOST_CHRONO_INLINED` is defined the lib is header-only.

@@ -1939,6 +1947,8 @@
[section:duration_hpp Header `<boost/chrono/duration.hpp>`]
[/=============================================]

+This file contains duration specific classes and non-member function.
+
 namespace boost {
 namespace chrono {

@@ -2045,27 +2055,27 @@

 static BOOST_CHRONO_CONSTEXPR Rep zero();

-[*Returns:] `Rep(0)`. [*Note:] `Rep(0)` is specified instead of `Rep()` since `Rep()` may have some other meaning, such as an uninitialized value.
+__returns `Rep(0)`. [*Note:] `Rep(0)` is specified instead of `Rep()` since `Rep()` may have some other meaning, such as an uninitialized value.

-[*Remarks:] The value returned corresponds to the additive identity.
+__remarks The value returned corresponds to the additive identity.

[endsect]
[section:max Static member function `max()`]

 static BOOST_CHRONO_CONSTEXPR Rep max();

-[*Returns:] `numeric_limits<Rep>::max()`.
+__returns `numeric_limits<Rep>::max()`.

-[*Remarks:] The value returned compares greater than zero().
+__remarks The value returned compares greater than zero().

[endsect]
[section:min Static member function `min()`]

 static BOOST_CHRONO_CONSTEXPR Rep min();

-[*Returns:] `numeric_limits<Rep>::lowest()`.
+__returns `numeric_limits<Rep>::lowest()`.

-[*Remarks:] The value returned compares less than or equal to `zero()`.
+__remarks The value returned compares less than or equal to `zero()`.

[endsect]

@@ -2158,21 +2168,21 @@
 template <class Rep2>
 BOOST_CHRONO_CONSTEXPR explicit duration(const Rep2& r);

-[*Remarks:] `Rep2` is implicitly convertible to `rep`, and
+__remarks `Rep2` is implicitly convertible to `rep`, and

* `treat_as_floating_point<rep>::value` is `true`, or
* `!treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value` is `true`.

If these constraints are not met, this constructor will not participate in overload resolution. [*Note:] This requirement prevents construction of an integral-based __duration__ with a floating point representation. Such a construction could easily lead to confusion about the value of the __duration__.

-[*Example:]
+__example

 __duration__<int, milli> d(3.5); // do not compile
 __duration__<int, milli> d(3); // ok

-[*Effects:] Constructs an object of type __duration__.
+__effects Constructs an object of type __duration__.

-[*PostConditions:] `count() == static_cast<rep>(r)`.
+__post_conditions `count() == static_cast<rep>(r)`.

[endsect]
[section:duration_c_2 Constructor `duration(const duration&)`]
@@ -2180,122 +2190,122 @@
 template <class Rep2, class Period2>
 BOOST_CHRONO_CONSTEXPR __duration__(const __duration__<Rep2, Period2>& d);

-[*Remarks:] `treat_as_floating_point<rep>::value`, or `ratio_divide<Period2, period>::type::den == 1`, else this constructor will not participate in overload resolution. [*note] This requirement prevents implicit truncation error when converting between integral-based __duration_s__. Such a construction could easily lead to confusion about the value of the __duration__.
+__remarks `treat_as_floating_point<rep>::value`, or `ratio_divide<Period2, period>::type::den == 1`, else this constructor will not participate in overload resolution. [*note] This requirement prevents implicit truncation error when converting between integral-based __duration_s__. Such a construction could easily lead to confusion about the value of the __duration__.

-[*Example:]
+__example

 __duration__<int, milli> ms(3);
 __duration__<int, micro> us = ms; // ok
 __duration__<int, milli> ms2 = us; // do not compile

-[*Effects:] Constructs an object of type __duration__, constructing `rep_` from `duration_cast<__duration__>(d).count()`.
+__effects Constructs an object of type __duration__, constructing `rep_` from `duration_cast<__duration__>(d).count()`.

[endsect]
[section:count Member function `count() const`]

 BOOST_CHRONO_CONSTEXPR rep count() const;

-[*Returns:] `rep_v.
+__returns `rep_v.

[endsect]
[section:duration_operator_p Member function `operator+() const`]

 BOOST_CHRONO_CONSTEXPR __duration__ operator+() const;

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:duration_operator_m Member function `operator+() const`]

 BOOST_CHRONO_CONSTEXPR __duration__ operator-() const;

-[*Returns:] `__duration__(-rep_)`.
+__returns `__duration__(-rep_)`.

[endsect]
[section:duration_operator_pp Member function `operator++()`]

 __duration__& operator++();

-[*Effects:] `++rep_`.
+__effects `++rep_`.

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:duration_operator_pp2 Member function `operator++(int)`]

 __duration__ operator++(int);

-[*Returns:] `__duration__(rep_++)v.
+__returns `__duration__(rep_++)v.

[endsect]
[section:duration_operator_mm Member function `operator++()`]

 __duration__& operator--();

-[*Effects:] `--rep_`.
+__effects `--rep_`.

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:duration_operator_mm2 Member function `operator++(int)`]

 __duration__ operator--(int);

-[*Returns:] `__duration__(rep_--)`.
+__returns `__duration__(rep_--)`.

[endsect]
[section:duration_operator_pa Member function `operator+=(const duration&)`]

 __duration__& operator+=(const __duration__& d);

-[*Effects:] `rep_ += d.count()`.
+__effects `rep_ += d.count()`.

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:duration_operator_ma Member function `operator-=(const duration&)`]

 __duration__& operator-=(const __duration__& d);

-[*Effects:] `rep_ -= d.count()`.
+__effects `rep_ -= d.count()`.

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:duration_operator_moda Member function `operator%=(const duration&)`]

 __duration__& operator%=(const __duration__& d);

-[*Effects:] `rep_ %= d.count()`.
+__effects `rep_ %= d.count()`.

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:duration_operator_proda Member function `operator*=(const rep&)`]

 __duration__& operator*=(const rep& rhs);

-[*Effects:] `rep_ *= rhs`.
+__effects `rep_ *= rhs`.

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:duration_operator_da Member function `operator/=(const rep&)`]

 __duration__& operator/=(const rep& rhs);

-[*Effects:] `rep_ /= rhs`.
+__effects `rep_ /= rhs`.

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:duration_operator_moda_2 Member function `operator%=(const rep&)`]

 __duration__& operator%=(const rep& rhs);

-[*Effects:] `rep_ %= rhs`.
+__effects `rep_ %= rhs`.

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]

@@ -2304,21 +2314,21 @@

 static __duration__ zero();

-[*Returns:] `__duration__(__duration_values__<rep>::zero())`.
+__returns `__duration__(__duration_values__<rep>::zero())`.

[endsect]
[section:duration_min Static Member function `min()`]

 static __duration__ min();

-[*Returns:] `__duration__(__duration_values__<rep>::min()).`
+__returns `__duration__(__duration_values__<rep>::min()).`

[endsect]
[section:duration_max Static Member function `max()`]

 static constexpr __duration__ max();

-[*Returns:] `__duration__(__duration_values__<rep>::max())`.
+__returns `__duration__(__duration_values__<rep>::max())`.

[endsect]

@@ -2333,7 +2343,7 @@
 typename __common_type__<__duration__<Rep1, Period1>, __duration__<Rep2, Period2> >::type
 operator+(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);

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

[endsect]
[section:duration_operator_m_1 Non-Member function `operator-(duration,duration)`]
@@ -2342,15 +2352,15 @@
 typename __common_type__<__duration__<Rep1, Period1>, __duration__<Rep2, Period2> >::type
 operator-(const __duration__<Rep1, Period1>& lhs, const __duration__<Rep2, Period2>& rhs);

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

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

-[*Requires:] Let `CR` represent the __common_type__ of `Rep1` and `Rep2`. This function will not participate in overload resolution unless both `Rep1` and `Rep2` are implicitly convertible to `CR`.
+__requires Let `CR` represent the __common_type__ of `Rep1` and `Rep2`. This function will not participate in overload resolution unless both `Rep1` and `Rep2` are implicitly convertible to `CR`.

-[*Returns:] `__duration__<CR, Period>(d) *= s`.
+__returns `__duration__<CR, Period>(d) *= s`.

[endsect]
[section:duration_operator_prod_1 Non-Member function `operator*(Rep1,duration)`]
@@ -2359,9 +2369,9 @@
 __duration__<typename __common_type__<Rep1, Rep2>::type, Period>
 operator*(const Rep1& s, const __duration__<Rep2, Period>& d);

-[*Requires:] Let `CR` represent the __common_type__ of `Rep1` and `Rep2`. This function will not participate in overload resolution unless both `Rep1` and `Rep2` are implicitly convertible to `CR`.
+__requires Let `CR` represent the __common_type__ of `Rep1` and `Rep2`. This function will not participate in overload resolution unless both `Rep1` and `Rep2` are implicitly convertible to `CR`.

-[*Returns:] `d * s`.
+__returns `d * s`.

[endsect]
[section:duration_operator_d_1 Non-Member function `operator/(duration,Rep2)`]
@@ -2370,9 +2380,9 @@
 __duration__<typename __common_type__<Rep1, Rep2>::type, Period>
 operator/(const __duration__<Rep1, Period>& d, const Rep2& s);

-[*Requires:] Let `CR` represent the __common_type__ of `Rep1` and `Rep2`. This function will not participate in overload resolution unless both `Rep1` and `Rep2` are implicitly convertible to `CR`, and `Rep2` is not an instantiation of __duration__.
+__requires Let `CR` represent the __common_type__ of `Rep1` and `Rep2`. This function will not participate in overload resolution unless both `Rep1` and `Rep2` are implicitly convertible to `CR`, and `Rep2` is not an instantiation of __duration__.

-[*Returns:] `__duration__<CR, Period>(d) /= s`.
+__returns `__duration__<CR, Period>(d) /= s`.

[endsect]
[section:duration_operator_d_2 Non-Member function `operator/(duration,duration)`]
@@ -2381,7 +2391,7 @@
 typename __common_type__<Rep1, Rep2>::type
 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()`.
+__returns Let `CD` represent the __common_type__ of the two __duration__ arguments. Returns `CD(lhs).count() / CD(rhs).count()`.

[endsect]

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

-[*Remarks:] Let `CR` represent the __common_type__ of `Rep1` and `Rep2`. This function will not participate in overload resolution unless both `Rep1` and `Rep2` are implicitly convertible to `CR`, and `Rep1` is not an instantiation of __duration__.
+__remarks Let `CR` represent the __common_type__ of `Rep1` and `Rep2`. This function will not participate in overload resolution unless both `Rep1` and `Rep2` are implicitly convertible to `CR`, and `Rep1` is not an instantiation of __duration__.

-[*Returns:] `CR(s)/__duration__<CR, Period>(d)`.
+__returns `CR(s)/__duration__<CR, Period>(d)`.

[endsect]

@@ -2405,7 +2415,7 @@

[*Remarks] This function will not participate in overload resolution unless Rep2 must be implicitly convertible to CR(Rep1, Rep2) and Rep2 must not be an instantiation of __duration__.

-[*Returns:] __duration__<CR(Rep1,Rep2), Period>(d) %= s.
+__returns __duration__<CR(Rep1,Rep2), Period>(d) %= s.
[endsect]

[section:duration_operator_mod_2 Non-Member function `operator%(duration,duration)`]
@@ -2417,7 +2427,7 @@

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

-[*Returns:] CD(lhs) %= CD(rhs)
+__returns CD(lhs) %= CD(rhs)

[endsect]
[endsect]
@@ -2430,7 +2440,7 @@
 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()`
+__returns Let `CD` represent the __common_type__ of the two __duration__ arguments. Returns `CD(lhs).count() == CD(rhs).count()`

[endsect]
[section:duration_operator_neq_1 Non-Member function `operator!=(duration,duration)`]
@@ -2439,7 +2449,7 @@
 bool operator!=(const __duration__<Rep1, Period1>& lhs,
 const __duration__<Rep2, Period2>& rhs);

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

[endsect]
[section:duration_operator_lt_1 Non-Member function `operator<(duration,duration)`]
@@ -2448,7 +2458,7 @@
 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()`
+__returns Let `CD` represent the __common_type__ of the two __duration__ arguments. Returns `CD(lhs).count() < CD(rhs).count()`

[endsect]
[section:duration_operator_leq_1 Non-Member function `operator<=(duration,duration)`]
@@ -2457,7 +2467,7 @@
 bool operator<=(const __duration__<Rep1, Period1>& lhs,
 const __duration__<Rep2, Period2>& rhs);

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

[endsect]
[section:duration_operator_gt_1 Non-Member function `operator>(duration,duration)`]
@@ -2466,7 +2476,7 @@
 bool operator> (const __duration__<Rep1, Period1>& lhs,
 const __duration__<Rep2, Period2>& rhs);

-[*Returns:] `rhs < lhs`.
+__returns `rhs < lhs`.

[endsect]
[section:duration_operator_gteq_1 Non-Member function `operator>=(duration,duration)`]
@@ -2475,7 +2485,7 @@
 bool operator>=(const __duration__<Rep1, Period1>& lhs,
 const __duration__<Rep2, Period2>& rhs);

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

[endsect]
[endsect]
@@ -2484,9 +2494,9 @@
 template <class ToDuration, class Rep, class Period>
 ToDuration duration_cast(const __duration__<Rep, Period>& d);

-[*Requires:] This function will not participate in overload resolution unless `ToDuration` is an instantiation of __duration__.
+__requires This function will not participate in overload resolution unless `ToDuration` is an instantiation of __duration__.

-[*Returns:] Forms `CF` which is a __ratio__ resulting from `ratio_divide<Period, typename ToDuration::period>::type`. Let `CR` be the __common_type__ of `ToDuration::rep`, `Rep`, and `intmax_t`.
+__returns Forms `CF` which is a __ratio__ resulting from `ratio_divide<Period, typename ToDuration::period>::type`. Let `CR` be the __common_type__ of `ToDuration::rep`, `Rep`, and `intmax_t`.

* If `CF::num == 1` and `CF::den == 1`, then returns `ToDuration(static_cast<typename ToDuration::rep>(d.count())) `
* else if `CF::num != 1` and `CF::den == 1`, then returns
@@ -2500,7 +2510,7 @@
 static_cast<CR>(CF::num) /
 static_cast<CR>(CF::den)))`

-[*Remarks:] This function does not rely on any implicit conversions. All conversions must be accomplished through `static_cast`. The implementation avoids all multiplications or divisions when it is known at compile time that it can be avoided because one or more arguments are `1`. All intermediate computations are carried out in the widest possible representation and only converted to the destination representation at the final step.
+__remarks This function does not rely on any implicit conversions. All conversions must be accomplished through `static_cast`. The implementation avoids all multiplications or divisions when it is known at compile time that it can be avoided because one or more arguments are `1`. All intermediate computations are carried out in the widest possible representation and only converted to the destination representation at the final step.

[endsect]
@@ -2554,6 +2564,7 @@
[section:time_point_hpp Header `<boost/chrono/time_point.hpp>`]
[/=============================================]

+This file contains time_point specific classes and non-member function.

 namespace boost {
 namespace chrono {
@@ -2669,23 +2680,23 @@

 time_point();

-[*Effects:] Constructs an object of __time_point__, initializing `d_` with `duration::zero()`. This __time_point__ represents the epoch.
+__effects Constructs an object of __time_point__, initializing `d_` with `duration::zero()`. This __time_point__ represents the epoch.

[endsect]
[section:time_point_c_2 Constructor `time_point(const duration&)`]

 time_point(const duration& d);

-[*Effects:] Constructs an object of __time_point__, initializing `d_` with `d`. This __time_point__ represents the epoch `+ d`.
+__effects Constructs an object of __time_point__, initializing `d_` with `d`. This __time_point__ represents the epoch `+ d`.

[endsect]
[section:time_point_c_3 Constructor `time_point(const duration&)`]

 template <class Duration2> time_point(const __time_point__<clock, Duration2>& t);

-[*Requires:] This function will not participate in overload resolution unless `Duration2` is implicitly convertible to __duration__.
+__requires This function will not participate in overload resolution unless `Duration2` is implicitly convertible to __duration__.

-[*Effects:] Constructs an object of __time_point__, initializing `d_` with `t.time_since_epoch()`.
+__effects Constructs an object of __time_point__, initializing `d_` with `t.time_since_epoch()`.

[endsect]

@@ -2693,39 +2704,39 @@

 duration time_since_epoch() const;

-[*Returns:] `d_`.
+__returns `d_`.

[endsect]
[section:time_point_operator_pe Member function `operator+=`]

 time_point& operator+=(const duration& d);

-[*Effects:] `d_ += d`.
+__effects `d_ += d`.

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:time_point_operator_me Member function `operator-=`]

 time_point& operator-=(const duration& d);

-[*Effects:] `d_ -= d`
+__effects `d_ -= d`

-[*Returns:] `*this`.
+__returns `*this`.

[endsect]
[section:time_point_min Static Member function `min`]

 static BOOST_CHRONO_CONSTEXPR time_point min();

-[*Returns:] `time_point(duration::min())`.
+__returns `time_point(duration::min())`.

[endsect]
[section:time_point_max Static Member function `max`]

 static BOOST_CHRONO_CONSTEXPR time_point max();

-[*Returns:] `time_point(duration::max())`.
+__returns `time_point(duration::max())`.

[endsect]
[endsect]
@@ -2741,7 +2752,7 @@
 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.
+__returns `CT(lhs) += rhs` where `CT` is the type of the return value.

[endsect]
[section:time_point_operator_p_2 Non-Member function `operator+(duration,time_point)`]
@@ -2751,7 +2762,7 @@
 operator+(const duration<Rep1, Period1>& lhs,
 const __time_point__<Clock, Duration2>& rhs);

-[*Returns:] `rhs + lhs`.
+__returns `rhs + lhs`.

[endsect]
[section:time_point_operator_m_1 Non-Member function `operator-(time_point,duration)`]
@@ -2761,7 +2772,7 @@
 operator-(const __time_point__<Clock, Duration1>& lhs,
 const duration<Rep2, Period2>& rhs);

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

[endsect]
[section:time_point_operator_m_2 Non-Member function `operator-(duration,time_point)`]
@@ -2771,7 +2782,7 @@
 operator-(const __time_point__<Clock, Duration1>& lhs,
 const __time_point__<Clock, Duration2>& rhs);

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

[endsect]
[endsect]
@@ -2783,7 +2794,7 @@
 bool operator==(const __time_point__<Clock, Duration1>& lhs,
 const __time_point__<Clock, Duration2>& rhs);

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

[endsect]
[section:time_point_operator_neq Non-Member function `operator!=(time_point,time_point)`]
@@ -2792,7 +2803,7 @@
 bool operator!=(const __time_point__<Clock, Duration1>& lhs,
 const __time_point__<Clock, Duration2>& rhs);

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

[endsect]
[section:time_point_operator_lt Non-Member function `operator<(time_point,time_point)`]
@@ -2801,7 +2812,7 @@
 bool operator< (const __time_point__<Clock, Duration1>& lhs,
 const __time_point__<Clock, Duration2>& rhs);

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

[endsect]
[section:time_point_operator_leq Non-Member function `operator<=(time_point,time_point)`]
@@ -2810,7 +2821,7 @@
 bool operator<=(const __time_point__<Clock, Duration1>& lhs,
 const __time_point__<Clock, Duration2>& rhs);

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

[endsect]
[section:time_point_operator_gt Non-Member function `operator>(time_point,time_point)`]
@@ -2819,7 +2830,7 @@
 bool operator>(const __time_point__<Clock, Duration1>& lhs,
 const __time_point__<Clock, Duration2>& rhs);

-[*Returns:] `rhs < lhs`.
+__returns `rhs < lhs`.

[endsect]
[section:time_point_operator_geq Non-Member function `operator>=(time_point,time_point)`]
@@ -2828,7 +2839,7 @@
 bool operator>=(const __time_point__<Clock, Duration1>& lhs,
 const __time_point__<Clock, Duration2>& rhs);

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

[endsect]
[endsect]
@@ -2839,9 +2850,9 @@
 template <class ToDuration, class Clock, class Duration>
 __time_point__<Clock, ToDuration> time_point_cast(const __time_point__<Clock, Duration>& t);

-[*Requires:] This function will not participate in overload resolution unless `ToDuration` is an instantiation of __duration__.
+__requires This function will not participate in overload resolution unless `ToDuration` is an instantiation of __duration__.

-[*Returns:] `__time_point__<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()))`.
+__returns `__time_point__<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()))`.

[endsect]

@@ -2851,6 +2862,8 @@
[section:system_clocks_hpp Header `<boost/chrono/system_clocks.hpp>`]
[/=============================================]

+This file contains the standard clock classes.
+
 namespace boost {
 namespace chrono {

@@ -2891,14 +2904,14 @@

time_t to_time_t(const time_point& t);

-[*Returns:] A `time_t` such that the `time_t` and `t` represent the same point in time, truncated to the courser of the precisions among `time_t` and `t`.
+__returns A `time_t` such that the `time_t` and `t` represent the same point in time, truncated to the courser of the precisions among `time_t` and `t`.

[endsect]
[section:from_time_t Static member function `from_time_t(time_t)`]

 time_point from_time_t(time_t t);

-[*Returns:] A __time_point__ such that the __time_point__ and `t` represent the same point in time, truncated to the courser of the precisions among __time_point__ and `t`.
+__returns A __time_point__ such that the __time_point__ and `t` represent the same point in time, truncated to the courser of the precisions among __time_point__ and `t`.

[endsect]
[endsect]
@@ -2913,7 +2926,7 @@

__monotonic_clock__ satisfy the __clock_req__.

-__monotonic_clock__ class provides access to the system-wide monotonic clock. The current time can be obtained by calling `monotonic_clock::now()`. There is no fixed relationship between values returned by `monotonic_clock::now()` and wall-clock time.
+__monotonic_clock__ class provides access to the system-wide monotonic clock. The current time can be obtained by calling `monotonic_clock::now()`. There is no fixed relationship between values returned by `monotonic_clock::now()` and wall-clock time.

 #ifdef BOOST_HAS_CLOCK_MONOTONIC
 class BOOST_CHRONO_DECL monotonic_clock {
@@ -3000,12 +3013,13 @@
 operator>>(std::basic_istream<CharT, Traits>& is,
 time_point<Clock, Duration>& tp);

- } // chrono
-
+ }
 }

[section:duration_punct Template class `duration_punct<>`]

+The __duration__ unit names can be customized through the facet: __duration_punct__. __duration__ unit names come in two varieties: long and short. The default constructed __duration_punct__ provides names in the long format. These names are English descriptions. Other languages are supported by constructing a __duration_punct__ with the proper spellings for hours, "minutes" and "seconds", and their abbreviations (for the short format).
+
 template <class CharT>
 class duration_punct
 : public std::locale::facet
@@ -3035,6 +3049,196 @@

[endsect]

+[section:clock_string Template class `clock_string<>`]
+
+ template <class Clock, class CharT>
+ struct clock_string;
+
+This template must be specialized for specific clocks. The specialization must define the following functions
+
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+
+`clock_string<>::name()` return the clock name, which usualy corresponds to the class name.
+`clock_string<>::since()` return the textual format of the clock epoch.
+
+
+[endsect]
+
+[section:clock_string_system_clock `clock_string<system_clock>` specialization]
+
+ template <class CharT>
+ struct clock_string<system_clock, CharT>
+ {
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+ };
+
+`clock_string<>::name()` returns "system_clock".
+`clock_string<>::since()` returns " since Jan 1, 1970"
+
+
+[endsect]
+
+[section:clock_string_monotonic_clock `clock_string<monotonic_clock>` specialization]
+
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+
+ template <class CharT>
+ struct clock_string<monotonic_clock, CharT>
+ {
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+ };
+ #endif
+
+`clock_string<>::name()` returns "monotonic_clock".
+`clock_string<>::since()` returns " since boot"
+
+[endsect]
+
+[section:clock_string_thread_clock `clock_string<thread_clock>` specialization]
+
+ #if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
+ template <class CharT>
+ struct clock_string<thread_clock, CharT>
+ {
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+ };
+ #endif
+
+`clock_string<>::name()` returns "thread_clock".
+`clock_string<>::since()` returns " since thread start-up"
+
+
+[endsect]
+
+[section:clock_string_process_real_cpu_clock `clock_string<process_real_cpu_clock>` specialization]
+
+ template <class CharT>
+ struct clock_string<process_real_cpu_clock, CharT>
+ {
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+ };
+
+`clock_string<>::name()` returns "process_real_cpu_clock".
+`clock_string<>::since()` returns " since process start-up"
+
+[endsect]
+
+[section:clock_string_process_user_cpu_clock `clock_string<process_user_cpu_clock>` specialization]
+
+ template <class CharT>
+ struct clock_string<process_user_cpu_clock, CharT>
+ {
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+ };
+
+`clock_string<>::name()` returns "process_user_cpu_clock".
+`clock_string<>::since()` returns " since process start-up"
+
+
+[endsect]
+
+[section:clock_string_process_system_cpu_clock `clock_string<process_system_cpu_clock>` specialization]
+
+ template <class CharT>
+ struct clock_string<process_system_cpu_clock, CharT>
+ {
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+ };
+
+`clock_string<>::name()` returns "process_system_cpu_clock".
+`clock_string<>::since()` returns " since process start-up"
+
+
+[endsect]
+
+[section:clock_string_process_cpu_clock `clock_string<process_cpu_clock>` specialization]
+
+ template <class CharT>
+ struct clock_string<process_cpu_clock, CharT>
+ {
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+ };
+
+`clock_string<>::name()` returns "process_cpu_clock".
+`clock_string<>::since()` returns " since process start-up"
+
+
+[endsect]
+
+[section:manipulators I/O Manipulators]
+
+The short or long format can be easily chosen by streaming a `duration_short` or `duration_long` manipulator respectively.
+
+ template <class CharT, class Traits>
+ std::basic_ostream<CharT, Traits>&
+ duration_short(std::basic_ostream<CharT, Traits>& os);
+
+__effects Set the __duration_punct__ facet to stream durations and time_points as abreviations.
+
+__returns the output stream
+
+ template <class CharT, class Traits>
+ std::basic_ostream<CharT, Traits>&
+ duration_long(std::basic_ostream<CharT, Traits>& os);
+
+
+__effects Set the __duration_punct__ facet to stream durations and time_points as long text.
+
+__returns the output stream
+
+
+[endsect]
+
+[section:streams I/O Streams operations]
+
+Any __duration__ can be streamed out to a `basic_ostream`. The run time value of the __duration__ is formatted according to the rules and current format settings for __duration__`::rep`. This is followed by a single space and then the compile time unit name of the __duration__. This unit name is built on the string returned from `ratio_string<>` and the data used to construct the __duration_punct__ which was inserted into the stream's locale. If a __duration_punct__ has not been inserted into the stream's locale, a default constructed __duration_punct__ will be added to the stream's locale.
+
+A __time_point__ is formatted by outputting its internal __duration__ followed by a string that describes the __time_point__`::clock` epoch. This string will vary for each distinct clock, and for each implementation of the supplied clocks.
+
+ template <class CharT, class Traits, class Rep, class Period>
+ std::basic_ostream<CharT, Traits>&
+ operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d);
+
+__effects outputs the __duration__ as an abrevieated or long text format depending on the state of the __duration_punct__ facet.
+
+__returns the output stream
+
+ template <class CharT, class Traits, class Rep, class Period>
+ std::basic_istream<CharT, Traits>&
+ operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
+
+__effects reads a __duration__ from the input stream. If a format error is found, the input stream state will be set to `failbit`.
+
+__returns the input stream
+
+ template <class CharT, class Traits, class Clock, class Duration>
+ std::basic_ostream<CharT, Traits>&
+ operator<<(std::basic_ostream<CharT, Traits>& os,
+ const time_point<Clock, Duration>& tp);
+
+__effects outputs the __time_point__ as an abrevieated or long text format depending on the state of the __duration_punct__ facet.
+
+__returns the output stream
+
+
+ template <class CharT, class Traits, class Clock, class Duration>
+ std::basic_istream<CharT, Traits>&
+ operator>>(std::basic_istream<CharT, Traits>& is,
+ time_point<Clock, Duration>& tp);
+
+__effects reads a __time_point__ from the input stream. If a format error is found, the input stream state will be set to `failbit`.
+
+__returns the input stream
+
+[endsect]

[endsect]
@@ -3137,20 +3341,20 @@

`process_cpu_clock` can be considered as a `tuple<process_real_cpu_clock, process_user_cpu_clock, process_system_cpu_clock>`.

-`process_cpu_clock` provides a thin wrapper around the operating system's process time API. For POSIX-like systems, that's the times() function, while for Windows, it's the GetProcessTimes() function.
+`process_cpu_clock` provides a thin wrapper around the operating system's process time API. For POSIX-like systems, that's the times() function, while for Windows, it's the `GetProcessTimes()` function.

The process relative real, user and system current time can be obtained at once by calling `process_clocks::now()`.

- class BOOST_CHRONO_DECL process_cpu_clock
+ class process_cpu_clock
 {
 public:
 struct times ;

- typedef duration<times, nano> duration;
- typedef duration::rep rep;
- typedef duration::period period;
- typedef chrono::time_point<process_cpu_clock> time_point;
- static const bool is_monotonic = true;
+ typedef duration<times, nano> duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<process_cpu_clock> time_point;
+ static const bool is_monotonic = true;

 static time_point now( system::error_code & ec = system::throws );
 };

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-10-30 12:24:03 EDT (Sat, 30 Oct 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.why_does_process_cpu_clock_sometimes_gives_more_cpu_seconds_than_real_seconds_"></a><h4>
-<a name="id5069867"></a>
+<a name="id5071453"></a>
 <a href="faq.html#boost_chrono.appendices.faq.why_does_process_cpu_clock_sometimes_gives_more_cpu_seconds_than_real_seconds_">Why
 does process_cpu_clock sometimes gives more cpu seconds than real seconds?</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-10-30 12:24:03 EDT (Sat, 30 Oct 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_duration_hpp_duration___code__phrase_role__identifier__duration__phrase___code___link__to_a_function_with_the_units_being_ambiguous_"></a><h4>
-<a name="id5068428"></a>
+<a name="id5069990"></a>
 <a href="rationale.html#boost_chrono.appendices.rationale.is_it_possible_for_the_user_to_pass_a___link_linkend__boost_chrono_reference_cpp0x_duration_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.duration_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="id5068526"></a>
+<a name="id5070088"></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="id5069107"></a>
+<a name="id5070668"></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>
@@ -105,7 +105,7 @@
 compilation succeeds.
 
<a name="boost_chrono.appendices.rationale.why_ratio_needs_the_nested_normalizer_typedef_type"></a><h4>
-<a name="id5069608"></a>
+<a name="id5071170"></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>
@@ -118,9 +118,8 @@
 

 The meaning of synonym let think that the result should be a normalized ratio
- equivalent to <code class="computeroutput">ratio</code><T1,
- T2>, but there is not an explicit definition of what synonym means in
- this context.
+ equivalent to <code class="computeroutput"><code class="computeroutput">ratio</code><T1, T2></code>,
+ but there is not an explicit definition of what synonym means in this context.
 

 If the CopyConstruction and Assignment ([LWG 1281) is not added we need a typedef for

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-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -27,7 +27,7 @@
<a name="boost_chrono.appendices.todo"></a> Appendix F: Future plans
</h3></div></div></div>
<a name="boost_chrono.appendices.todo.for_later_releases"></a><h4>
-<a name="id5070006"></a>
+<a name="id5071592"></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/overview.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html 2010-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -38,7 +38,7 @@
 -- Augustine 
 </blockquote></div>
<a name="boost_chrono.overview.how_to_use_this_documentation"></a><h3>
-<a name="id4948681"></a>
+<a name="id4948651"></a>
 <a href="overview.html#boost_chrono.overview.how_to_use_this_documentation">How to
 Use This Documentation</a>
 </h3>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/description.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/description.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/description.html 2010-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -29,6 +29,10 @@

 The Boost.Chrono library provides:
 
+<a name="boost_chrono.overview.description.standard"></a><h4>
+<a name="id4987212"></a>
+ Standard
+ </h4>
<div class="itemizedlist"><ul type="disc">
<li>
 A means to represent time durations: managed by the generic <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
@@ -65,6 +69,10 @@
 Class template time_point<>"><code class="computeroutput">time_point</code></a> representing now.
 </li>
</ul></div>
+<a name="boost_chrono.overview.description.other_clocks"></a><h4>
+<a name="id4987524"></a>
+ Other clocks
+ </h4>

 To make the timing facilities more generally useful, Boost.Chrono
 provides a number of clocks that are thin wrappers around the operating system's
@@ -88,11 +96,13 @@
 system-CPU times.
 </li>
<li>
- A tuple-like class <code class="computeroutput">process_cpu_clock</code>,
+ A tuple-like class __process_cpuclock_,
 that captures real, user-CPU, and system-CPU times together.
 </li>
<li>
- Thread clocks, when supported by a platform.
+ A <a href="../reference/other_clocks.html#boost_chrono.reference.other_clocks.thread_clock_hpp.thread_clock" title="
+ Class thread_clock"><code class="computeroutput">thread_clock</code></a> thread monotonic
+ clock, when supported by a platform.
 </li>
</ul></div>

@@ -102,8 +112,22 @@
 Class template time_point<>"><code class="computeroutput">time_point</code></a> to permit using emulated
 auto with C++03 compilers.
 
+<a name="boost_chrono.overview.description.i_o"></a><h4>
+<a name="id4987716"></a>
+ I/O
+ </h4>
+
+ It provides I/O for <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> and <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a>. It builds on <code class="computeroutput"><boost/ratio/ratio_io.hpp></code>
+ to provide readable and flexible formatting and parsing for types in <code class="computeroutput"><boost/chrono.hpp></code>.
+ The <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> unit names can be customized
+ through a new facet: <a href="../reference/io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a>.
+ 
<a name="boost_chrono.overview.description.caveat_emptor"></a><h4>
-<a name="id4949515"></a>
+<a name="id4987888"></a>
 <a href="description.html#boost_chrono.overview.description.caveat_emptor">Caveat emptor</a>
 </h4>

@@ -114,17 +138,6 @@
 on their accuracy, unless you have become deeply familiar with exactly what
 the specific operating system is guaranteeing, which is often very little.
 
-<a name="boost_chrono.overview.description.i_o"></a><h4>
-<a name="id4949546"></a>
- I/O
- </h4>
-
- It provides I/O for <code class="computeroutput">duration</code>
- and <code class="computeroutput">time_point</code>. It builds
- on <boost/ratio/ratio_io.hpp> to provide readable and flexible formatting
- and parsing for types in <boost/chrono.hpp>. The <code class="computeroutput">duration</code>
- unit names can be customized through a new facet: <code class="computeroutput">duration_punct</code>.
- 
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html 2010-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -27,7 +27,7 @@
<a name="boost_chrono.overview.motivation"></a>Motivation
</h3></div></div></div>
<a name="boost_chrono.overview.motivation.time"></a><h4>
-<a name="id4948948"></a>
+<a name="id4987071"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.time">Time</a>
 </h4>

@@ -46,7 +46,7 @@
 of a good deal of information in this documentation.
 
<a name="boost_chrono.overview.motivation.wall_clock_versus_system_and_user_time"></a><h4>
-<a name="id4949006"></a>
+<a name="id4987128"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.wall_clock_versus_system_and_user_time">Wall
 clock versus system and user time</a>
 </h4>
@@ -55,7 +55,8 @@
 library provides a number of clocks that are thin wrappers around the operating
 system's process time API, thereby allowing the extraction of read (wall
 clock) time, user CPU time, and system CPU time. (On POSIX-like systems,
- this relies on times(). On Windows, it relies on GetProcessTimes().)
+ this relies on <code class="computeroutput">times()</code>.
+ On Windows, it relies on <code class="computeroutput">GetProcessTimes()</code>.)
 
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

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-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -107,27 +107,28 @@

 Next follows limitation respect to the C++0x recomendations:
 
-<div class="itemizedlist"><ul type="disc">
-<li>
- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3135.html#1121" target="_top">Ratio
- values should be constexpr</a>: <code class="computeroutput">constexpr</code>
- don't used as no compiler supports it today. <code class="computeroutput">const</code>
+<div class="itemizedlist"><ul type="disc"><li>
+ <code class="computeroutput">constexpr</code> don't used
+ for <code class="computeroutput">min()</code>,
+ <code class="computeroutput">max()</code>
+ and <code class="computeroutput">zero()</code>
+ <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.traits.duration_values" title="
+ Class template duration_values"><code class="computeroutput">duration_values</code></a> class as
+ no compiler supports it today. <code class="computeroutput">const</code>
 is used instead when appropiated.
- </li>
-<li>
- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3134.html#921" target="_top">Rational
- Arithmetic should use template aliases</a>: In the absence of
- compiler support of template aliases the C++03 emulation define a
- nested typedef <code class="computeroutput">type</code>.
- </li>
-</ul></div>
+ </li></ul></div>

 The current implementation provides in addition:
 
-<div class="itemizedlist"><ul type="disc"><li>
+<div class="itemizedlist"><ul type="disc">
+<li>
 clock error handling as specified in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3135.html#3155" target="_top">clock
 error handling needs to be specified</a>.
- </li></ul></div>
+ </li>
+<li>
+ process and thread clocks.
+ </li>
+</ul></div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
@@ -140,7 +141,7 @@
 How Assert behaves?</a></dt>
<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.conf.header_only">
 How to build Boost.Chrono as a header
- only lib?</a></dt>
+ only library?</a></dt>
</dl></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h6 class="title">
@@ -149,29 +150,31 @@
 How Assert behaves?</a>
</h6></div></div></div>

- When BOOST_NO_STATIC_ASSERT is defined, the user can select the way
- static assertions are reported. Define
+ When <code class="computeroutput">BOOST_NO_STATIC_ASSERT</code>
+ is defined, the user can select the way static assertions are reported.
+ Define
 
<div class="itemizedlist"><ul type="disc">
<li>
- BOOST_CHRONO_USES_STATIC_ASSERT: define it if you want to use Boost.StaticAssert
+ <code class="computeroutput">BOOST_CHRONO_USES_STATIC_ASSERT</code>:
+ define it if you want to use Boost.StaticAssert
 </li>
<li>
- BOOST_CHRONO_USES_MPL_ASSERT: define it if you want to use Boost.MPL
- static asertions
+ <code class="computeroutput">BOOST_CHRONO_USES_MPL_ASSERT</code>:
+ define it if you want to use Boost.MPL static asertions
 </li>
<li>
- BOOST_CHRONO_USES_ARRAY_ASSERT: define it if you want to use internal
- static asertions
+ <code class="computeroutput">BOOST_CHRONO_USES_ARRAY_ASSERT</code>:
+ define it if you want to use internal static asertions
 </li>
</ul></div>

- The default vaule behavior is as BOOST_CHRONO_USES_ARRAY_ASSERT was
- defined.
+ The default vaule behavior is as <code class="computeroutput">BOOST_CHRONO_USES_ARRAY_ASSERT</code>
+ was defined.
 

- When BOOST_CHRONO_USES_MPL_ASSERT is not defined the following symbols
- are defined as
+ When <code class="computeroutput">BOOST_CHRONO_USES_MPL_ASSERT</code>
+ is not defined the following symbols are defined as
 
<pre class="programlisting">#define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION \
 "A duration representation can not be a duration"
@@ -191,9 +194,9 @@
<div class="titlepage"><div><div><h6 class="title">
<a name="boost_chrono.reference.cpp0x.chrono_hpp.conf.header_only"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.conf.header_only" title="
 How to build Boost.Chrono as a header
- only lib?">
+ only library?">
 How to build Boost.Chrono as a header
- only lib?</a>
+ only library?</a>
</h6></div></div></div>

 When <code class="computeroutput">BOOST_CHRONO_INLINED</code>
@@ -228,6 +231,9 @@
<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration_typedefs">
 <code class="computeroutput">duration</code> typedefs</a></dt>
</dl></div>
+
+ This file contains duration specific classes and non-member function.
+ 
<pre class="programlisting">namespace boost {
 namespace chrono {

@@ -466,12 +472,12 @@
 <code class="computeroutput">common_type</code> specialization</a>
</h5></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
-struct <code class="computeroutput">common_type</code><chrono:: <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+struct <code class="computeroutput">common_type</code><chrono:: <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>, chrono:: <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2> >
{
 typedef chrono:: <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, see below> type;
+ Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, see below> type;
};
</pre>

@@ -1010,7 +1016,7 @@
 Non-Member function <code class="computeroutput">operator+(duration,duration)</code></a>
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
-typename <code class="computeroutput">common_type</code>< <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+typename <code class="computeroutput">common_type</code>< <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>, <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_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.duration_hpp.duration" title="
@@ -1029,7 +1035,7 @@
 Non-Member function <code class="computeroutput">operator-(duration,duration)</code></a>
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
-typename <code class="computeroutput">common_type</code>< <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+typename <code class="computeroutput">common_type</code>< <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>, <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_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.duration_hpp.duration" title="
@@ -1042,7 +1048,7 @@
 
<pre class="programlisting">template <class Rep1, class Period, class Rep2>
 <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, Period>
+ Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, Period>
operator*(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period>& d, const Rep2& s);
</pre>
@@ -1067,7 +1073,7 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period, class Rep2>
 <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, Period>
+ Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, Period>
operator*(const Rep1& s, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period>& d);
</pre>
@@ -1092,7 +1098,7 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period, class Rep2>
 <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, Period>
+ Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, Period>
operator/(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period>& d, const Rep2& s);
</pre>
@@ -1119,7 +1125,7 @@
 Non-Member function <code class="computeroutput">operator/(duration,duration)</code></a>
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
-typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type
+typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type
operator/(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>& lhs, const <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep2, Period2>& rhs);
@@ -1167,7 +1173,7 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period, class Rep2>
 <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, Period>
+ Class template duration<>"><code class="computeroutput">duration</code></a><typename <code class="computeroutput">common_type</code><Rep1, Rep2>::type, Period>
operator%(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period>& d, const Rep2& s);
</pre>
@@ -1190,7 +1196,7 @@
 Non-Member function <code class="computeroutput">operator%(duration,duration)</code></a>
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
-typename <code class="computeroutput">common_type</code>< <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+typename <code class="computeroutput">common_type</code>< <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a><Rep1, Period1>, <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_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.duration_hpp.duration" title="
@@ -1641,6 +1647,9 @@
<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point_cast">
 Non-Member function <code class="computeroutput">time_point_cast(time_point)</code></a></dt>
</dl></div>
+
+ This file contains time_point specific classes and non-member function.
+ 
<pre class="programlisting">namespace boost {
 namespace chrono {

@@ -1709,12 +1718,12 @@
 <code class="computeroutput">common_type</code> specialization</a>
</h5></div></div></div>
<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
-struct <code class="computeroutput">common_type</code><chrono:: <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
+struct <code class="computeroutput">common_type</code><chrono:: <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>, chrono:: <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2> >
{
 typedef chrono:: <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <code class="computeroutput">common_type</code><Duration1, Duration2>::type> type;
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <code class="computeroutput">common_type</code><Duration1, Duration2>::type> type;
};
</pre>

@@ -1943,7 +1952,7 @@
</h6></div></div></div>
<pre class="programlisting">template <class Clock, class Duration1, class Rep2, class Period2>
 <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <code class="computeroutput">common_type</code><Duration1, duration<Rep2, Period2> >::type>
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <code class="computeroutput">common_type</code><Duration1, duration<Rep2, Period2> >::type>
operator+(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs,
 const duration<Rep2, Period2>& rhs);
@@ -1961,7 +1970,7 @@
</h6></div></div></div>
<pre class="programlisting">template <class Rep1, class Period1, class Clock, class Duration2>
 <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <code class="computeroutput">common_type</code><duration<Rep1, Period1>, Duration2>::type>
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <code class="computeroutput">common_type</code><duration<Rep1, Period1>, Duration2>::type>
operator+(const duration<Rep1, Period1>& lhs,
 const <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2>& rhs);
@@ -1979,7 +1988,7 @@
</h6></div></div></div>
<pre class="programlisting">template <class Clock, class Duration1, class Rep2, class Period2>
 <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <code class="computeroutput">common_type</code><Duration1, duration<Rep2, Period2> >::type>
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, typename <code class="computeroutput">common_type</code><Duration1, duration<Rep2, Period2> >::type>
operator-(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>& lhs,
 const duration<Rep2, Period2>& rhs);
@@ -1996,7 +2005,7 @@
 Non-Member function <code class="computeroutput">operator-(duration,time_point)</code></a>
</h6></div></div></div>
<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
-typename <code class="computeroutput">common_type</code><Duration1, Duration2>::type
+typename <code class="computeroutput">common_type</code><Duration1, Duration2>::type
operator-(const <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_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.time_point_hpp.time_point" title="
@@ -2170,6 +2179,9 @@
<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.system_clocks_hpp.high_resolution_clock">
 Class <code class="computeroutput">high_resolution_clock</code></a></dt>
</dl></div>
+
+ This file contains the standard clock classes.
+ 
<pre class="programlisting">namespace boost {
 namespace chrono {

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/io.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/io.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/io.html 2010-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -29,15 +29,73 @@
</h3></div></div></div>
<div class="toc"><dl>
<dt> Header <boost/chrono/chrono_io.hpp></dt>
-<dd><dl><dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct">
- Template class <code class="computeroutput">duration_punct<></code></a></dt></dl></dd>
+<dd><dl>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct">
+ Template class <code class="computeroutput">duration_punct<></code></a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string">
+ Template class <code class="computeroutput">clock_string<></code></a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_system_clock">
+ <code class="computeroutput">clock_string<system_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_monotonic_clock">
+ <code class="computeroutput">clock_string<monotonic_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_thread_clock">
+ <code class="computeroutput">clock_string<thread_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_real_cpu_clock">
+ <code class="computeroutput">clock_string<process_real_cpu_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_user_cpu_clock">
+ <code class="computeroutput">clock_string<process_user_cpu_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_system_cpu_clock">
+ <code class="computeroutput">clock_string<process_system_cpu_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_cpu_clock">
+ <code class="computeroutput">clock_string<process_cpu_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.manipulators">
+ I/O Manipulators</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.streams">
+ I/O Streams operations</a></dt>
+</dl></dd>
</dl></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_chrono.reference.io.chrono_io_hpp"></a> Header <boost/chrono/chrono_io.hpp>
</h4></div></div></div>
-<div class="toc"><dl><dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct">
- Template class <code class="computeroutput">duration_punct<></code></a></dt></dl></div>
+<div class="toc"><dl>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct">
+ Template class <code class="computeroutput">duration_punct<></code></a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string">
+ Template class <code class="computeroutput">clock_string<></code></a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_system_clock">
+ <code class="computeroutput">clock_string<system_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_monotonic_clock">
+ <code class="computeroutput">clock_string<monotonic_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_thread_clock">
+ <code class="computeroutput">clock_string<thread_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_real_cpu_clock">
+ <code class="computeroutput">clock_string<process_real_cpu_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_user_cpu_clock">
+ <code class="computeroutput">clock_string<process_user_cpu_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_system_cpu_clock">
+ <code class="computeroutput">clock_string<process_system_cpu_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_cpu_clock">
+ <code class="computeroutput">clock_string<process_cpu_clock></code>
+ specialization</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.manipulators">
+ I/O Manipulators</a></dt>
+<dt><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.streams">
+ I/O Streams operations</a></dt>
+</dl></div>
<pre class="programlisting">namespace boost {
namespace chrono {

@@ -73,8 +131,7 @@
 operator>>(std::basic_istream<CharT, Traits>& is,
 time_point<Clock, Duration>& tp);

-} // chrono
-
+}
}
</pre>
<div class="section" lang="en">
@@ -83,6 +140,20 @@
 Template class duration_punct<>">
 Template class <code class="computeroutput">duration_punct<></code></a>
</h5></div></div></div>
+
+ The <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> unit names can be customized
+ through the facet: <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a>. <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> unit names come in
+ two varieties: long and short. The default constructed <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> provides names
+ in the long format. These names are English descriptions. Other languages
+ are supported by constructing a <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> with the proper
+ spellings for hours, "minutes" and "seconds", and
+ their abbreviations (for the short format).
+ 
<pre class="programlisting">template <class CharT>
class duration_punct
 : public std::locale::facet
@@ -111,6 +182,296 @@
};
</pre>
</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.clock_string"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string" title="
+ Template class clock_string<>">
+ Template class <code class="computeroutput">clock_string<></code></a>
+</h5></div></div></div>
+<pre class="programlisting">template <class Clock, class CharT>
+struct clock_string;
+</pre>
+
+ This template must be specialized for specific clocks. The specialization
+ must define the following functions
+ 
+<pre class="programlisting">static std::basic_string<CharT> name();
+static std::basic_string<CharT> since();
+</pre>
+
+ <code class="computeroutput">clock_string<>::name()</code>
+ return the clock name, which usualy corresponds to the class name. <code class="computeroutput">clock_string<>::since()</code>
+ return the textual format of the clock epoch.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.clock_string_system_clock"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_system_clock" title="
+ clock_string<system_clock>
+ specialization">
+ <code class="computeroutput">clock_string<system_clock></code>
+ specialization</a>
+</h5></div></div></div>
+<pre class="programlisting">template <class CharT>
+struct clock_string<system_clock, CharT>
+{
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+};
+</pre>
+
+ <code class="computeroutput">clock_string<>::name()</code>
+ returns "system_clock". <code class="computeroutput">clock_string<>::since()</code> returns " since Jan 1, 1970"
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.clock_string_monotonic_clock"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_monotonic_clock" title="
+ clock_string<monotonic_clock>
+ specialization">
+ <code class="computeroutput">clock_string<monotonic_clock></code>
+ specialization</a>
+</h5></div></div></div>
+<pre class="programlisting">#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+
+template <class CharT>
+struct clock_string<monotonic_clock, CharT>
+{
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+};
+#endif
+</pre>
+
+ <code class="computeroutput">clock_string<>::name()</code>
+ returns "monotonic_clock". <code class="computeroutput">clock_string<>::since()</code> returns " since boot"
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.clock_string_thread_clock"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_thread_clock" title="
+ clock_string<thread_clock>
+ specialization">
+ <code class="computeroutput">clock_string<thread_clock></code>
+ specialization</a>
+</h5></div></div></div>
+<pre class="programlisting">#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
+template <class CharT>
+struct clock_string<thread_clock, CharT>
+{
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+};
+#endif
+</pre>
+
+ <code class="computeroutput">clock_string<>::name()</code>
+ returns "thread_clock". <code class="computeroutput">clock_string<>::since()</code> returns " since thread start-up"
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.clock_string_process_real_cpu_clock"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_real_cpu_clock" title="
+ clock_string<process_real_cpu_clock>
+ specialization">
+ <code class="computeroutput">clock_string<process_real_cpu_clock></code>
+ specialization</a>
+</h5></div></div></div>
+<pre class="programlisting">template <class CharT>
+struct clock_string<process_real_cpu_clock, CharT>
+{
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+};
+</pre>
+
+ <code class="computeroutput">clock_string<>::name()</code>
+ returns "process_real_cpu_clock". <code class="computeroutput">clock_string<>::since()</code> returns " since process start-up"
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.clock_string_process_user_cpu_clock"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_user_cpu_clock" title="
+ clock_string<process_user_cpu_clock>
+ specialization">
+ <code class="computeroutput">clock_string<process_user_cpu_clock></code>
+ specialization</a>
+</h5></div></div></div>
+<pre class="programlisting">template <class CharT>
+struct clock_string<process_user_cpu_clock, CharT>
+{
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+};
+</pre>
+
+ <code class="computeroutput">clock_string<>::name()</code>
+ returns "process_user_cpu_clock". <code class="computeroutput">clock_string<>::since()</code> returns " since process start-up"
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.clock_string_process_system_cpu_clock"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_system_cpu_clock" title="
+ clock_string<process_system_cpu_clock>
+ specialization">
+ <code class="computeroutput">clock_string<process_system_cpu_clock></code>
+ specialization</a>
+</h5></div></div></div>
+<pre class="programlisting">template <class CharT>
+struct clock_string<process_system_cpu_clock, CharT>
+{
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+};
+</pre>
+
+ <code class="computeroutput">clock_string<>::name()</code>
+ returns "process_system_cpu_clock". <code class="computeroutput">clock_string<>::since()</code> returns " since process start-up"
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.clock_string_process_cpu_clock"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.clock_string_process_cpu_clock" title="
+ clock_string<process_cpu_clock>
+ specialization">
+ <code class="computeroutput">clock_string<process_cpu_clock></code>
+ specialization</a>
+</h5></div></div></div>
+<pre class="programlisting">template <class CharT>
+struct clock_string<process_cpu_clock, CharT>
+{
+ static std::basic_string<CharT> name();
+ static std::basic_string<CharT> since();
+};
+</pre>
+
+ <code class="computeroutput">clock_string<>::name()</code>
+ returns "process_cpu_clock". <code class="computeroutput">clock_string<>::since()</code> returns " since process start-up"
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.manipulators"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.manipulators" title="
+ I/O Manipulators">
+ I/O Manipulators</a>
+</h5></div></div></div>
+
+ The short or long format can be easily chosen by streaming a <code class="computeroutput">duration_short</code> or <code class="computeroutput">duration_long</code>
+ manipulator respectively.
+ 
+<pre class="programlisting">template <class CharT, class Traits>
+ std::basic_ostream<CharT, Traits>&
+ duration_short(std::basic_ostream<CharT, Traits>& os);
+</pre>
+
+ Effects: Set the <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> facet to stream
+ durations and time_points as abreviations.
+ 
+
+ Returns: the output stream
+ 
+<pre class="programlisting">template <class CharT, class Traits>
+ std::basic_ostream<CharT, Traits>&
+ duration_long(std::basic_ostream<CharT, Traits>& os);
+</pre>
+
+ Effects: Set the <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> facet to stream
+ durations and time_points as long text.
+ 
+
+ Returns: the output stream
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.io.chrono_io_hpp.streams"></a><a href="io.html#boost_chrono.reference.io.chrono_io_hpp.streams" title="
+ I/O Streams operations">
+ I/O Streams operations</a>
+</h5></div></div></div>
+
+ Any <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> can be streamed out
+ to a <code class="computeroutput">basic_ostream</code>. The
+ run time value of the <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> is formatted according
+ to the rules and current format settings for <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a><code class="computeroutput">::rep</code>. This is followed by a single space
+ and then the compile time unit name of the <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a>. This unit name is
+ built on the string returned from <code class="computeroutput">ratio_string<></code> and the data used to construct
+ the <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> which was inserted
+ into the stream's locale. If a <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> has not been
+ inserted into the stream's locale, a default constructed <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> will be added
+ to the stream's locale.
+ 
+
+ A <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a> is formatted by outputting
+ its internal <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> followed by a string
+ that describes the <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><code class="computeroutput">::clock</code> epoch. This string will vary
+ for each distinct clock, and for each implementation of the supplied
+ clocks.
+ 
+<pre class="programlisting">template <class CharT, class Traits, class Rep, class Period>
+ std::basic_ostream<CharT, Traits>&
+ operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d);
+</pre>
+
+ Effects: outputs the <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> as an abrevieated or
+ long text format depending on the state of the <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> facet.
+ 
+
+ Returns: the output stream
+ 
+<pre class="programlisting">template <class CharT, class Traits, class Rep, class Period>
+ std::basic_istream<CharT, Traits>&
+ operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
+</pre>
+
+ Effects: reads a <a href="cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> from the input stream.
+ If a format error is found, the input stream state will be set to <code class="computeroutput">failbit</code>.
+ 
+
+ Returns: the input stream
+ 
+<pre class="programlisting">template <class CharT, class Traits, class Clock, class Duration>
+ std::basic_ostream<CharT, Traits>&
+ operator<<(std::basic_ostream<CharT, Traits>& os,
+ const time_point<Clock, Duration>& tp);
+</pre>
+
+ Effects: outputs the <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a> as an abrevieated
+ or long text format depending on the state of the <a href="io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> facet.
+ 
+
+ Returns: the output stream
+ 
+<pre class="programlisting">template <class CharT, class Traits, class Clock, class Duration>
+ std::basic_istream<CharT, Traits>&
+ operator>>(std::basic_istream<CharT, Traits>& is,
+ time_point<Clock, Duration>& tp);
+</pre>
+
+ Effects: reads a <a href="cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a> from the input stream.
+ If a format error is found, the input stream state will be set to <code class="computeroutput">failbit</code>.
+ 
+
+ Returns: the input stream
+ 
+</div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/other_clocks.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/other_clocks.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/other_clocks.html 2010-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -220,23 +220,23 @@

 <code class="computeroutput">process_cpu_clock</code> provides
 a thin wrapper around the operating system's process time API. For POSIX-like
- systems, that's the times() function, while for Windows, it's the GetProcessTimes()
+ systems, that's the times() function, while for Windows, it's the <code class="computeroutput">GetProcessTimes()</code>
 function.
 

 The process relative real, user and system current time can be obtained
 at once by calling <code class="computeroutput">process_clocks::now()</code>.
 
-<pre class="programlisting">class BOOST_CHRONO_DECL process_cpu_clock
+<pre class="programlisting">class process_cpu_clock
{
public:
 struct times ;

- typedef duration<times, nano> duration;
- typedef duration::rep rep;
- typedef duration::period period;
- typedef chrono::time_point<process_cpu_clock> time_point;
- static const bool is_monotonic = true;
+ typedef duration<times, nano> duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<process_cpu_clock> time_point;
+ static const bool is_monotonic = true;

 static time_point now( system::error_code & ec = system::throws );
};

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide.html 2010-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -44,8 +44,8 @@
</dl></dd>
<dt>Examples</dt>
<dd><dl>
-<dt><a href="users_guide/examples.html#boost_chrono.users_guide.examples.common_type">Common
- type</a></dt>
+<dt><a href="users_guide/examples.html#boost_chrono.users_guide.examples.time_point">Time
+ point</a></dt>
<dt>Duration</dt>
<dt>Clocks</dt>
<dt>Conversions</dt>

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-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -27,15 +27,14 @@
<a name="boost_chrono.users_guide.examples"></a>Examples
</h3></div></div></div>
<div class="toc"><dl>
-<dt><a href="examples.html#boost_chrono.users_guide.examples.common_type">Common
- type</a></dt>
-<dd><dl><dt><a href="examples.html#boost_chrono.users_guide.examples.common_type.min_utility">min
+<dt><a href="examples.html#boost_chrono.users_guide.examples.time_point">Time
+ point</a></dt>
+<dd><dl><dt><a href="examples.html#boost_chrono.users_guide.examples.time_point.min_utility">min
 utility</a></dt></dl></dd>
<dt>Duration</dt>
<dd><dl>
<dt><a href="examples.html#boost_chrono.users_guide.examples.duration.how_you_override_the_duration_s_default_constructor">How
 you override the duration's default constructor</a></dt>
-<dt>runtime_resolution</dt>
<dt>Saturating</dt>
</dl></dd>
<dt>Clocks</dt>
@@ -51,8 +50,6 @@
<dd><dl>
<dt><a href="examples.html#boost_chrono.users_guide.examples.reporting.a_tiny_program_that_times_how_long_until_a_key_is_struck">A
 tiny program that times how long until a key is struck</a></dt>
-<dt><a href="examples.html#boost_chrono.users_guide.examples.reporting.time_command">time
- command</a></dt>
<dt><a href="examples.html#boost_chrono.users_guide.examples.reporting.24_hours_display">24
 hours display</a></dt>
</dl></dd>
@@ -61,23 +58,23 @@
</dl></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_chrono.users_guide.examples.common_type"></a><a href="examples.html#boost_chrono.users_guide.examples.common_type" title="Common
- type">Common
- type</a>
+<a name="boost_chrono.users_guide.examples.time_point"></a><a href="examples.html#boost_chrono.users_guide.examples.time_point" title="Time
+ point">Time
+ point</a>
</h4></div></div></div>
-<div class="toc"><dl><dt><a href="examples.html#boost_chrono.users_guide.examples.common_type.min_utility">min
+<div class="toc"><dl><dt><a href="examples.html#boost_chrono.users_guide.examples.time_point.min_utility">min
 utility</a></dt></dl></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
-<a name="boost_chrono.users_guide.examples.common_type.min_utility"></a><a href="examples.html#boost_chrono.users_guide.examples.common_type.min_utility" title="min
+<a name="boost_chrono.users_guide.examples.time_point.min_utility"></a><a href="examples.html#boost_chrono.users_guide.examples.time_point.min_utility" title="min
 utility">min
 utility</a>
</h5></div></div></div>

- Returns the earliest time_point.
+ The following function returns the earliest time_point.
 
<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
-typename boost:: <code class="computeroutput">common_type</code>< <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
+typename boost::<code class="computeroutput">common_type</code>< <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration1>,
 <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
 Class template time_point<>"><code class="computeroutput">time_point</code></a><Clock, Duration2> >::type
@@ -94,7 +91,7 @@
 
<pre class="programlisting">BOOST_AUTO(t1, system_clock::now() + seconds(3));
BOOST_AUTO(t2, system_clock::now() + nanoseconds(3));
-BOOST_AUTO(t3, (min)(t1, t2));
+BOOST_AUTO(t3, min(t1, t2));
</pre>

 See the source file example/min_time_point.cpp
@@ -108,7 +105,6 @@
<div class="toc"><dl>
<dt><a href="examples.html#boost_chrono.users_guide.examples.duration.how_you_override_the_duration_s_default_constructor">How
 you override the duration's default constructor</a></dt>
-<dt>runtime_resolution</dt>
<dt>Saturating</dt>
</dl></div>
<div class="section" lang="en">
@@ -119,8 +115,8 @@
</h5></div></div></div>

 Next follows how you override the duration's default constructor to do
- anything you want (in this case zero). All we need to do is to change
- the representation
+ anything you want (in this case set it to zero). All we need to do is
+ to change the representation
 
<pre class="programlisting">namespace I_dont_like_the_default_duration_behavior {

@@ -189,71 +185,6 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
-<a name="boost_chrono.users_guide.examples.duration.runtime_resolution"></a>runtime_resolution
-</h5></div></div></div>
-
- Handle duration with resolution not known until run time
- 
-<pre class="programlisting">class duration
-{
-public:
- typedef long long rep;
-private:
- rep rep_;
-
- static const double ticks_per_nanosecond;
-
-public:
- typedef boost::chrono::duration<double, boost::nano> tonanosec;
-
- duration() {} // = default;
- explicit duration(const rep& r) : rep_(r) {}
-
- // conversions
- explicit duration(const tonanosec& d)
- : rep_(static_cast<rep>(d.count() * ticks_per_nanosecond)) {}
-
- // explicit
- operator tonanosec() const {return tonanosec(rep_/ticks_per_nanosecond);}
-
- // observer
-
- rep count() const {return rep_;}
-
- // arithmetic
-
- duration& operator+=(const duration& d) {rep_ += d.rep_; return *this;}
- duration& operator-=(const duration& d) {rep_ += d.rep_; return *this;}
- duration& operator*=(rep rhs) {rep_ *= rhs; return *this;}
- duration& operator/=(rep rhs) {rep_ /= rhs; return *this;}
-
- duration operator+() const {return *this;}
- duration operator-() const {return duration(-rep_);}
- duration& operator++() {++rep_; return *this;}
- duration operator++(int) {return duration(rep_++);}
- duration& operator--() {--rep_; return *this;}
- duration operator--(int) {return duration(rep_--);}
-
- friend duration operator+(duration x, duration y) {return x += y;}
- friend duration operator-(duration x, duration y) {return x -= y;}
- friend duration operator*(duration x, rep y) {return x *= y;}
- friend duration operator*(rep x, duration y) {return y *= x;}
- friend duration operator/(duration x, rep y) {return x /= y;}
-
- friend bool operator==(duration x, duration y) {return x.rep_ == y.rep_;}
- friend bool operator!=(duration x, duration y) {return !(x == y);}
- friend bool operator< (duration x, duration y) {return x.rep_ < y.rep_;}
- friend bool operator<=(duration x, duration y) {return !(y < x);}
- friend bool operator> (duration x, duration y) {return y < x;}
- friend bool operator>=(duration x, duration y) {return !(x < y);}
-};
-</pre>
-
- See the source file here
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h5 class="title">
<a name="boost_chrono.users_guide.examples.duration.saturating"></a>Saturating
</h5></div></div></div>

@@ -447,10 +378,8 @@
public:
 typedef xtime rep;
 typedef boost::micro period;
- typedef boost::chrono:: <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
- Class template duration<>"><code class="computeroutput">duration</code></a><rep, period> duration;
- typedef boost::chrono:: <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput">time_point</code></a><xtime_clock> time_point;
+ typedef boost::chrono::duration<rep, period> duration;
+ typedef boost::chrono::time_point<xtime_clock> time_point;

 static time_point now()
 {
@@ -615,8 +544,6 @@
<div class="toc"><dl>
<dt><a href="examples.html#boost_chrono.users_guide.examples.reporting.a_tiny_program_that_times_how_long_until_a_key_is_struck">A
 tiny program that times how long until a key is struck</a></dt>
-<dt><a href="examples.html#boost_chrono.users_guide.examples.reporting.time_command">time
- command</a></dt>
<dt><a href="examples.html#boost_chrono.users_guide.examples.reporting.24_hours_display">24
 hours display</a></dt>
</dl></div>
@@ -717,55 +644,6 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
-<a name="boost_chrono.users_guide.examples.reporting.time_command"></a><a href="examples.html#boost_chrono.users_guide.examples.reporting.time_command" title="time
- command">time
- command</a>
-</h5></div></div></div>
-<pre class="programlisting">#include <boost/chrono/stopclock.hpp>
-#include <cstdlib>
-#include <string>
-#include <iostream>
-
-int main( int argc, char * argv[] )
-{
- if ( argc == 1 )
- {
- std::cout << "invoke: timex [-v] command [args...]\n"
- " command will be executed and timings displayed\n"
- " -v option causes command and args to be displayed\n";
- return 1;
- }
-
- std::string s;
-
- bool verbose = false;
- if ( argc > 1 && *argv[1] == '-' && *(argv[1]+1) == 'v' )
- {
- verbose = true;
- ++argv;
- --argc;
- }
-
- for ( int i = 1; i < argc; ++i )
- {
- if ( i > 1 ) s += ' ';
- s += argv[i];
- }
-
- if ( verbose )
- { std::cout << "command: \"" << s.c_str() << "\"\n"; }
-
- boost::chrono::__stopclock__<> t;
-
- return std::system( s.c_str() );
-}
-</pre>
-
- See the source file example/timex.cpp
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h5 class="title">
<a name="boost_chrono.users_guide.examples.reporting.24_hours_display"></a><a href="examples.html#boost_chrono.users_guide.examples.reporting.24_hours_display" title="24
 hours display">24
 hours display</a>
@@ -903,7 +781,7 @@
 C++ practices. Next follows a simaulation of this interface.
 

- Free sleep functions
+ The non-member sleep functions can be emulated as follows:
 
<pre class="programlisting">namespace boost { namespace this_thread {

@@ -930,7 +808,7 @@
 typedef <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.system_clocks_hpp.system_clock" title="
 Class system_clock"><code class="computeroutput">system_clock</code></a>::time_point SysTime;
 if (t > Clock::now()) {
- typedef typename <code class="computeroutput">common_type</code><typename Time::duration,
+ typedef typename <code class="computeroutput">common_type</code><typename Time::duration,
 typename SysTime::duration>::type D;
 /* auto */ D d = t - Clock::now();
 microseconds us = <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration_cast" title="
@@ -950,7 +828,8 @@
}}
</pre>

- timed_mutex modified fuctions
+ Next follows the <code class="computeroutput">boost::thread::timed_mutex</code>
+ modified fuctions
 
<pre class="programlisting">namespace boost {
struct timed_mutex {
@@ -981,7 +860,7 @@
 Class system_clock"><code class="computeroutput">system_clock</code></a>::time_point SysTime;
 if (t <= Clock::now())
 return try_lock();
- typedef typename <code class="computeroutput">common_type</code><typename Time::duration,
+ typedef typename <code class="computeroutput">common_type</code><typename Time::duration,
 typename Clock::duration>::type D;
 /* auto */ D d = t - Clock::now();
 microseconds us = <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration_cast" title="
@@ -1000,7 +879,8 @@
}
</pre>

- condition_variable modified fuctions
+ <code class="computeroutput">boost::thread::condition_variable</code> time related function
+ are modified as follows:
 
<pre class="programlisting">namespace boost {
struct condition_variable
@@ -1026,7 +906,7 @@
 Class system_clock"><code class="computeroutput">system_clock</code></a>::time_point SysTime;
 if (t <= Clock::now())
 return false;
- typedef typename <code class="computeroutput">common_type</code><typename Time::duration,
+ typedef typename <code class="computeroutput">common_type</code><typename Time::duration,
 typename Clock::duration>::type D;
 /* auto */ D d = t - Clock::now();
 microseconds us = <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration_cast" title="
@@ -1045,7 +925,7 @@
}
</pre>

- Usage
+ Next follows how how sumple is the usage of this functions:
 
<pre class="programlisting">boost::mutex m;
boost::timed_mutex mut;

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html 2010-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -39,7 +39,7 @@
 Installing Chrono</a>
</h4></div></div></div>
<a name="boost_chrono.users_guide.getting_started.install.getting__emphasis_role__bold__boost_chrono__emphasis__"></a><h5>
-<a name="id4949661"></a>
+<a name="id4987965"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.getting__emphasis_role__bold__boost_chrono__emphasis__">Getting
 Boost.Chrono </a>
 </h5>
@@ -54,13 +54,13 @@
 and follow the instructions there for anonymous SVN access.
 
<a name="boost_chrono.users_guide.getting_started.install.where_to_install__emphasis_role__bold__boost_chrono__emphasis___"></a><h5>
-<a name="id4949732"></a>
+<a name="id4988037"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.where_to_install__emphasis_role__bold__boost_chrono__emphasis___">Where
 to install Boost.Chrono? </a>
 </h5>

 The simple way is to decompress (or checkout from SVN) the file in your
- BOOST_ROOT directory.
+ <code class="computeroutput">BOOST_ROOT</code> directory.
 
<div class="note"><table border="0" summary="Note">
<tr>
@@ -73,34 +73,37 @@
</table></div>

 Othesewise, if you decompress in a different directory, you will need to
- comment some lines, and uncomment and change others in the build/Jamfile
- and test/Jamfile. Sorry for this, but I have not reached yet to write a
- Jamfile that is able to work in both environements and use the BOOST_ROOT
+ comment some lines, and uncomment and change others in the <code class="computeroutput">build/Jamfile</code> and <code class="computeroutput">test/Jamfile</code>.
+ Sorry for this, but I have not reached yet to write a <code class="computeroutput">Jamfile</code>
+ that is able to work in both environements and use the <code class="computeroutput">BOOST_ROOT</code>
 variable. Any help is welcome.
 
<a name="boost_chrono.users_guide.getting_started.install.building__emphasis_role__bold__boost_chrono__emphasis__"></a><h5>
-<a name="id4949782"></a>
+<a name="id4942292"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.building__emphasis_role__bold__boost_chrono__emphasis__">Building
 Boost.Chrono </a>
 </h5>

 Boost.Chrono can be configured as a header
- only library. When BOOST_CHRONO_INLINED is defined the lib is header only
- library. Otherwise is not a header only library and you need to compile
- it before use.
+ only library. When <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.conf.header_only" title="
+ How to build Boost.Chrono as a header
+ only library?"><code class="computeroutput">BOOST_CHRONO_INLINED</code></a> is defined
+ the lib is header only library. Otherwise is not a header only library
+ and you need to compile it before use.
 
<pre class="programlisting">bjam libs/chrono/build
</pre>
<a name="boost_chrono.users_guide.getting_started.install.requirements"></a><h5>
-<a name="id4949856"></a>
+<a name="id4942382"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.requirements">Requirements</a>
 </h5>

 Boost.Chrono depends on some new traits
- in Boost.TypeTraits. For these specific parts you must use either the Boost.TypeTraits.Ext
- or the version in SVN trunk. In addition it depends on the not yet accepted
- Boost.Ratio library. Except these new dependencies, we have tested with
- older versions as 1.39.
+ in Boost.TypeTraits which have been added
+ on Boost 1.45. For these specific parts you must use either the Boost.TypeTraits.Ext
+ or the version in SVN trunk/release. In addition it depends on the recently
+ accepted Boost.Ratio library. Except these
+ new dependencies, we have tested with older versions as 1.39.
 

 In particular, Boost.Chrono depends on:
@@ -147,18 +150,20 @@
</dl>
</div>
<a name="boost_chrono.users_guide.getting_started.install.building_an_executable_that_uses__emphasis_role__bold__boost_chrono__emphasis__"></a><h5>
-<a name="id4942274"></a>
+<a name="id4942633"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.building_an_executable_that_uses__emphasis_role__bold__boost_chrono__emphasis__">Building
 an executable that uses Boost.Chrono
 </a>
 </h5>

- In addition to link with the Boost.Chrono library you need also to link
- with the Boost.System library. Once Boost.System will be configurable to
- be a header only using BOOST_SYSTEM_INLINED you will no need to link with.
+ In addition to link with the Boost.Chrono
+ library you need also to link with the Boost.System
+ library. Once Boost.System will be configurable
+ to be a header only using __BOOST_SYSTEM_INLINED you will no need to link
+ with.
 
<a name="boost_chrono.users_guide.getting_started.install.exceptions_safety_"></a><h5>
-<a name="id4942311"></a>
+<a name="id4942683"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.exceptions_safety_">Exceptions
 safety </a>
 </h5>
@@ -167,7 +172,7 @@
 of exception safety as long as the underlying parameters provide it.
 
<a name="boost_chrono.users_guide.getting_started.install.thread_safety_"></a><h5>
-<a name="id4942338"></a>
+<a name="id4942710"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.thread_safety_">Thread
 safety </a>
 </h5>
@@ -175,7 +180,7 @@
 All functions in the library are thread-unsafe except when noted explicitly.
 
<a name="boost_chrono.users_guide.getting_started.install.tested_compilers_"></a><h5>
-<a name="id4942364"></a>
+<a name="id4942736"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.tested_compilers_">Tested
 compilers </a>
 </h5>

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-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -36,11 +36,8 @@
 happens if I assign <code class="computeroutput">m3 + us3</code>
 to <code class="computeroutput">minutes</code> instead of
 <code class="computeroutput">microseconds</code>?</a></dt>
-<dt><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.i_m_trafficking_in_floating_point__duration_s__i_don_t_want_to_deal_with_writing__duration_cast__all_over_the_place__i_m_content_with_the_precision_of_my_floating_point_representation">I'm
- trafficking in floating point <code class="computeroutput">duration</code>s.
- I don't want to deal with writing <code class="computeroutput">duration_cast</code>
- all over the place. I'm content with the precision of my floating point
- representation</a></dt>
+<dt><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.trafficking_in_floating_point_durations">Trafficking
+ in floating point durations</a></dt>
<dt><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.how_expensive_is_all_of_this_">How
 expensive is all of this?</a></dt>
<dt><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.how_complicated_is_it_to_build_a_function_taking_a__duration__parameter_">How
@@ -72,11 +69,8 @@
 happens if I assign <code class="computeroutput">m3 + us3</code>
 to <code class="computeroutput">minutes</code> instead of
 <code class="computeroutput">microseconds</code>?</a></dt>
-<dt><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.i_m_trafficking_in_floating_point__duration_s__i_don_t_want_to_deal_with_writing__duration_cast__all_over_the_place__i_m_content_with_the_precision_of_my_floating_point_representation">I'm
- trafficking in floating point <code class="computeroutput">duration</code>s.
- I don't want to deal with writing <code class="computeroutput">duration_cast</code>
- all over the place. I'm content with the precision of my floating point
- representation</a></dt>
+<dt><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.trafficking_in_floating_point_durations">Trafficking
+ in floating point durations</a></dt>
<dt><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.how_expensive_is_all_of_this_">How
 expensive is all of this?</a></dt>
<dt><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.how_complicated_is_it_to_build_a_function_taking_a__duration__parameter_">How
@@ -87,7 +81,8 @@
 The <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a> is the heart of this
 library. The interface that the user will see in everyday use is nearly
- identical to that of Boost.DateTime time <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ identical to that of Boost.DateTime time
+ <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code>'s</a> authored by Jeff Garland,
 both in syntax and in behavior. This has been a very popular boost library
 for 7 years. There is an enormous positive history with this interface.
@@ -147,8 +142,9 @@
 duration typedefs"><code class="computeroutput">minutes</code></a> has.
 

- In Boost.DateTime, these units are united via inheritance. Boost.Chrono
- instead unites these units through the class template <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ In Boost.DateTime, these units are united
+ via inheritance. Boost.Chrono instead
+ unites these units through the class template <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a>. That is, in Boost.Chrono all six of the above units are nothing
 but typedefs to different instantiations of <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a>. This change from Boost.DateTime
@@ -292,7 +288,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="id4997573"></a>
+<a name="id4997825"></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>
@@ -319,17 +315,16 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
-<a name="boost_chrono.users_guide.tutorial.duration.i_m_trafficking_in_floating_point__duration_s__i_don_t_want_to_deal_with_writing__duration_cast__all_over_the_place__i_m_content_with_the_precision_of_my_floating_point_representation"></a><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.i_m_trafficking_in_floating_point__duration_s__i_don_t_want_to_deal_with_writing__duration_cast__all_over_the_place__i_m_content_with_the_precision_of_my_floating_point_representation" title="I'm
- trafficking in floating point durations.
- I don't want to deal with writing duration_cast
- all over the place. I'm content with the precision of my floating point
- representation">I'm
- trafficking in floating point <code class="computeroutput">duration</code>s.
- I don't want to deal with writing <code class="computeroutput">duration_cast</code>
- all over the place. I'm content with the precision of my floating point
- representation</a>
+<a name="boost_chrono.users_guide.tutorial.duration.trafficking_in_floating_point_durations"></a><a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.trafficking_in_floating_point_durations" title="Trafficking
+ in floating point durations">Trafficking
+ in floating point durations</a>
</h5></div></div></div>

+ I don't want to deal with writing <code class="computeroutput">duration_cast</code>
+ all over the place. I'm content with the precision of my floating point
+ representation
+ 
+
 Not a problem. When the destination of a conversion has floating point
 representation, all conversions are allowed to happen implicitly.
 
@@ -508,13 +503,15 @@
 
<div class="orderedlist"><ol type="1">
<li>
- system_clock
+ <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.system_clocks_hpp.system_clock" title="
+ Class system_clock"><code class="computeroutput">system_clock</code></a>
 </li>
<li>
- monotonic_clock
+ <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.system_clocks_hpp.monotonic_clock" title="
+ Class monotonic_clock"><code class="computeroutput">monotonic_clock</code></a>
 </li>
<li>
- high_precision_clock
+ __high_precisionclock_
 </li>
</ol></div>

@@ -709,11 +706,12 @@
 Class template duration<>"><code class="computeroutput">duration</code></a> to a known <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
 Class template duration<>"><code class="computeroutput">duration</code></a>. This insulates the
 code from future changes which may be made to the clock's precision in
- the future. For example monotonic_clock could easily be based on the
- clock speed of the cpu. When you upgrade to a faster machine, you do
- not want your code that assumed a certain tick period of this clock to
- start experiencing run time failures because your timing code has silently
- changed meaning.
+ the future. For example <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.system_clocks_hpp.monotonic_clock" title="
+ Class monotonic_clock"><code class="computeroutput">monotonic_clock</code></a> could easily
+ be based on the clock speed of the cpu. When you upgrade to a faster
+ machine, you do not want your code that assumed a certain tick period
+ of this clock to start experiencing run time failures because your timing
+ code has silently changed meaning.
 

 A delay loop example:
@@ -725,8 +723,9 @@
</pre>

 The above code will delay as close as possible to half a microsecond,
- no matter what the precision of monotonic_clock is. The more precise
- <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.system_clocks_hpp.monotonic_clock" title="
+ no matter what the precision of <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.system_clocks_hpp.monotonic_clock" title="
+ Class monotonic_clock"><code class="computeroutput">monotonic_clock</code></a> is. The more
+ precise <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.system_clocks_hpp.monotonic_clock" title="
 Class monotonic_clock"><code class="computeroutput">monotonic_clock</code></a> becomes, the
 more accurate will be the delay to 500 nanoseconds.
 
@@ -836,34 +835,46 @@
<a name="boost_chrono.users_guide.tutorial.i_o"></a>I/O
</h4></div></div></div>

- Any <code class="computeroutput">duration</code> can be streamed
- out to a <code class="computeroutput">basic_ostream</code>.
- The run time value of the <code class="computeroutput">duration</code>
- is formatted according to the rules and current format settings for <code class="computeroutput">duration::rep</code>. This is followed by a single space
- and then the compile time unit name of the <code class="computeroutput">duration</code>.
- This unit name is built on the string returned from <code class="computeroutput">ratio_string</code>
- and the data used to construct the <code class="computeroutput">duration_punct</code>
- which was inserted into the stream's locale. If a <code class="computeroutput">duration_punct</code>
- has not been inserted into the stream's locale, a default constructed
- <code class="computeroutput">duration_punct</code> will be
- added to the stream's locale.
- 
-
- <code class="computeroutput">duration</code> unit names come
- in two varieties: long and short. The default constructed <code class="computeroutput">duration_punct</code> provides names in the
- long format. These names are English descriptions. Other languages are
- supported by constructing a <code class="computeroutput">duration_punct</code>
- with the proper spellings for "hours", "minutes" and
- "seconds", and their abbreviations (for the short format). The
- short or long format can be easily chosen by streaming a <code class="computeroutput">duration_short</code> or <code class="computeroutput">duration_long</code>
- manipulator respectively.
- 
-
- A <code class="computeroutput">time_point</code> is formatted
- by outputting its internal <code class="computeroutput">duration</code>
- followed by a string that describes the <code class="computeroutput">time_point::clock</code>
- epoch. This string will vary for each distinct clock, and for each implementation
- of the supplied clocks.
+ Any <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> can be streamed out to
+ a <code class="computeroutput">basic_ostream</code>. The run
+ time value of the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> is formatted according
+ to the rules and current format settings for <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a><code class="computeroutput">::rep</code>. This is followed by a single space
+ and then the compile time unit name of the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a>. This unit name is built
+ on the string returned from <code class="computeroutput">ratio_string<></code> and the data used to construct
+ the <a href="../reference/io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> which was inserted
+ into the stream's locale. If a <a href="../reference/io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> has not been inserted
+ into the stream's locale, a default constructed <a href="../reference/io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> will be added to
+ the stream's locale.
+ 
+
+ <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> unit names come in two
+ varieties: long and short. The default constructed <a href="../reference/io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> provides names
+ in the long format. These names are English descriptions. Other languages
+ are supported by constructing a <a href="../reference/io.html#boost_chrono.reference.io.chrono_io_hpp.duration_punct" title="
+ Template class duration_punct<>"><code class="computeroutput">duration_punct</code></a> with the proper
+ spellings for hours, "minutes" and "seconds", and their
+ abbreviations (for the short format). The short or long format can be easily
+ chosen by streaming a <code class="computeroutput">duration_short</code>
+ or <code class="computeroutput">duration_long</code> manipulator
+ respectively.
+ 
+
+ A <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a> is formatted by outputting
+ its internal <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.duration_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput">duration</code></a> followed by a string
+ that describes the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.time_point_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput">time_point</code></a><code class="computeroutput">::clock</code> epoch. This string will vary for
+ each distinct clock, and for each implementation of the supplied clocks.
 

 Example:
@@ -949,46 +960,31 @@

 Example:
 
-<div class="orderedlist"><ol type="1">
-<li>
- include <boost/chrono/chrono_io.hpp>
- </li>
-<li>
- include <sstream>
- </li>
-<li>
- include <cassert>
- </li>
-</ol></div>
-
- int main() { using namespace std; using namespace boost::chrono;
- 
-<pre class="programlisting">istringstream in("5000 milliseconds 4000 ms 3001 ms");
-seconds d(0);
-in >> d;
-assert(in.good());
-assert(d == seconds(5));
-in >> d;
-assert(in.good());
-assert(d == seconds(4));
-in >> d;
-assert(in.fail());
-assert(d == seconds(4));
+<pre class="programlisting">#include <boost/chrono/chrono_io.hpp>
+#include <sstream>
+#include <cassert>

-return 0;
-</pre>
-
- istringstream in("5000 milliseconds 4000 ms 3001 ms"); seconds
- d(0); in >> d; assert(in.good()); assert(d <code class="literal">= seconds(5));
- in >> d; assert(in.good()); assert(d =</code> seconds(4)); in
- >> d; assert(in.fail()); assert(d == seconds(4));
- 
-<pre class="programlisting">return 0;
+int main()
+{
+ using namespace std;
+ using namespace boost::chrono;
+
+ istringstream in("5000 milliseconds 4000 ms 3001 ms");
+ seconds d(0);
+ in >> d;
+ assert(in.good());
+ assert(d == seconds(5));
+ in >> d;
+ assert(in.good());
+ assert(d == seconds(4));
+ in >> d;
+ assert(in.fail());
+ assert(d == seconds(4));
+
+ return 0;
+}
</pre>

- return 0; }
- 
-
 Note that a <code class="computeroutput">duration</code> failure
 may occur late in the parsing process. This means that the characters making
 up the failed parse in the stream are usually consumed despite the failure

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-10-30 12:24:03 EDT (Sat, 30 Oct 2010)
@@ -38,7 +38,7 @@
<div>Copyright © 2006 , 2008 Beman Dawes</div>
<div>Copyright © 2009 -2010 Vicente J. Botet Escriba</div>
<div><div class="legalnotice">
-<a name="id4987032"></a>
+<a name="id4946075"></a>
 Distributed under the Boost Software License, Version 1.0. (See accompanying
 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -93,7 +93,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: October 22, 2010 at 18:27:49 GMT</td>
+<td align="left">Last revised: October 30, 2010 at 16:15:11 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r66281 - sandbox/chrono/libs/chrono/example"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r66279 - sandbox/chrono/boost/chrono"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk