| Home | Libraries | People | FAQ | More

### Included on the C++11 Recommendation

#### Header `<boost/chrono.hpp>`

Include only the standard files.

    #include <boost/chrono/chrono.hpp>

#### Header `<boost/chrono/chrono.hpp>`

Include only the standard files.

    #include <boost/chrono/duration.hpp>
    #include <boost/chrono/time_point.hpp>
    #include <boost/chrono/system_clocks.hpp>
    #include <boost/chrono/typeof/boost/chrono/chrono.hpp>

##### Limitations and Extensions

At present, there is no know limitation respect to the C++11 standard.

The current implementation provides in addition:

- clock error handling as specified in clock error handling needs to be specified.
- process and thread clocks.

##### Configuration Macros

###### How Assert Behaves?

When `BOOST_NO_CXX11_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 assertions.
- `BOOST_CHRONO_USES_ARRAY_ASSERT`: define it if you want to use internal static assertions.

The default 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

    #define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION \
        "A duration representation can not be a duration"
    #define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO \
        "Second template parameter of duration must be a boost::ratio"
    #define BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE \
        "duration period must be positive"
    #define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_CHRONO_DURATION \
        "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 text.

###### Don't provide Hybrid Error Handling

When `BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING` is defined the lib don't provides the hybrid error handling prototypes:

    Clock::time_point Clock::now(system::error_code&ec=boost::throws());

This allow to be closer to the standard and to avoid the Boost.System dependency, making possible to have Boost.Chrono as a header-only library.

By default `BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING` is defined.

###### How to Build Boost.Chrono as a Header Only Library?

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

If in addition `BOOST_USE_WINDOWS_H` is defined `<windows.h>` is included, otherwise files in `boost/detail/win` are used to reduce the impact of including `<windows.h>`.

However, you will either need to define `BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING` or link with Boost.System.

###### Deprecated IO

Version 2.0.0 deprecates the preceding IO features.

However the default version is always version 1. If you don't want to include the deprecated features you could define `BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0`.

###### time_point<system_clock,D> specialization limitation

###### Version

`BOOST_CHRONO_VERSION` defines the Boost.Chrono version. The default version is 1. In this case the following breaking or extending macros are defined if the opposite is not requested:

- `BOOST_CHRONO_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0`

The user can request the version 2 by defining `BOOST_CHRONO_VERSION` to 2. In this case the following breaking or extending macros are defined if the opposite is not requested:

- Breaking change `BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0`

The default value for `BOOST_CHRONO_VERSION` will be changed to 2 since Boost 1.55.

#### Header `<boost/chrono/duration.hpp>`

This file contains duration specific classes and non-member functions.

    namespace boost {
      namespace chrono {

        template <class Rep, class Period = ratio<1> >  class duration;

      }
      template <class Rep1, class Period1, class Rep2, class Period2>
      struct common_type<duration<Rep1, Period1>,
                         duration<Rep2, Period2> >;

      namespace chrono {

        // customization traits
        template <class Rep> struct treat_as_floating_point;
        template <class Rep> struct duration_values;

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

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

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

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

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

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

        #ifdef BOOST_CHRONO_EXTENSIONS
        // Used to get frequency of events
        template <class Rep1, class Rep2, class Period>
        constexpr
        double operator/(
            const Rep1& s,
            const duration<Rep2, Period>& d);
        #endif

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

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

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

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

        // duration_cast

        template <class ToDuration, class Rep, class Period>
        constexpr
        ToDuration duration_cast(const duration<Rep, Period>& d);

        // convenience typedefs
        typedef duration<boost::int_least64_t, nano> nanoseconds;    // at least 64 bits needed
        typedef duration<boost::int_least64_t, micro> microseconds;  // at least 55 bits needed
        typedef duration<boost::int_least64_t, milli> milliseconds;  // at least 45 bits needed
        typedef duration<boost::int_least64_t> seconds;              // at least 35 bits needed
        typedef duration<boost::int_least32_t, ratio< 60> > minutes; // at least 29 bits needed
        typedef duration<boost::int_least32_t, ratio<3600> > hours;  // at least 23 bits needed

      }
    }

##### Time-related Traits

###### Metafunction `treat_as_floating_point<>`

    template <class Rep> struct treat_as_floating_point
        : boost::is_floating_point<Rep> {};

The `duration` template uses the `treat_as_floating_point` trait to help determine if a `duration` with one tick period can be converted to another `duration` with a different tick period. If `treat_as_floating_point<Rep>::value` is `true`, then `Rep` is a floating-point type and implicit conversions are allowed among `duration`s. Otherwise, the implicit convertibility depends on the tick periods of the `duration`s. If `Rep` is a class type which emulates a floating-point type, the author of `Rep` can specialize `treat_as_floating_point` so that `duration` will treat this `Rep` as if it were a floating-point type. Otherwise `Rep` is assumed to be an integral type, or a class emulating an integral type.

###### Class Template `duration_values`

    template <class Rep>
    struct duration_values
    {
    public:
        static constexpr Rep zero();
        static constexpr Rep max();
        static constexpr Rep min();
    };

The `duration` template uses the `duration_values` trait to construct special values of the `duration`'s representation (`Rep`). This is done because the representation might be a class type with behavior which requires some other implementation to return these special values. In that case, the author of that class type should specialize `duration_values` to return the indicated values.

###### Static Member Function `zero()`

    static 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.

Remarks: The value returned corresponds to the additive identity.

###### Static Member Function `max()`

    static constexpr Rep max();

Returns: `numeric_limits<Rep>::max()`.

Remarks: The value returned compares greater than zero().

###### Static Member Function `min()`

    static constexpr Rep min();

Returns: `numeric_limits<Rep>::lowest()`.

Remarks: The value returned compares less than or equal to `zero()`.

##### `common_type` Specialization

    template <class Rep1, class Period1, class Rep2, class Period2>
    struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2> >
    {
        typedef chrono::duration<typename common_type<Rep1, Rep2>::type, see bellow> type;
    };

The period of the `duration` indicated by this specialization of `common_type` is the greatest common divisor of `Period1` and `Period2`. This can be computed by forming a `ratio` of the greatest common divisor of `Period1::num` and `Period2::num`, and the least common multiple of `Period1::den` and `Period2::den`.

Note: The typedef type is the `duration` with the largest tick period possible where both `duration` arguments will convert to it without requiring a division operation. The representation of this type is intended to be able to hold any value resulting from this conversion, with the possible exception of round-off error when floating-point `duration`s are involved (but not truncation error).

##### Class Template `duration<>`

A `duration` measures time between two points in time (`time_point`). A `duration` has a representation which holds a count of ticks, and a tick period. The tick period is the amount of time which occurs from one tick to another in units of a second. It is expressed as a rational constant using `ratio`.

    namespace boost { namespace chrono {

        template <class Rep, class Period>
        class duration {
        public:
            typedef Rep rep;
            typedef Period period;
        private:
            rep rep_; // exposition only
        public:
            constexpr duration();
            template <class Rep2>
            constexpr explicit duration(const Rep2& r);

            template <class Rep2, class Period2>
            constexpr duration(const duration<Rep2, Period2>& d);

            duration& operator=(const duration&) = default;

            constexpr rep count() const;

            constexpr duration  __duration__op_plus();
            constexpr duration  __duration__op_minus();
            duration& operator++();
            duration  operator++(int);
            duration& operator--();
            duration  operator--(int);

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

            duration& operator*=(const rep& rhs);
            duration& operator/=(const rep& rhs);
            duration& operator%=(const rep& rhs);
            duration& operator%=(const duration& rhs);

            static constexpr duration zero();
            static constexpr duration min();
            static constexpr duration max();
        };

    }}

`Rep` must be an arithmetic type, or a class emulating an arithmetic type, compile diagnostic otherwise. If `duration` is instantiated with the type of `Rep` being a `duration`, compile diagnostic is issued.

`Period` must be an instantiation of `ratio`, compile diagnostic otherwise.

`Period::num` must be positive, compile diagnostic otherwise.

Examples:

- ``duration`<long, `ratio`<60> >` holds a count of minutes using a long.
- ``duration`<long long, milli>` holds a count of milliseconds using a long long.
- ``duration`<double, `ratio`<1, 30> >` holds a count using a double with a tick period of 1/30 second (a tick frequency of 30 Hz).

The following members of `duration` do not throw an exception unless the indicated operations on the representations throw an exception.

###### Constructor `duration()`

    constexpr duration();

Effects: Constructs an object of type `duration` initialized from `duration_values<rep>::zero()` in C++98 or `BOOST_CHRONO_DURATION_DEFAULTS_TO_ZERO` is defined, otherwise the duration is uninitialized.

###### Constructor `duration(const Rep2&)`

    template <class Rep2>
    constexpr explicit duration(const Rep2& r);

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:

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

Effects: Constructs an object of type `duration`.

Post Conditions: `count() == static_cast<rep>(r)`.

###### Constructor `duration(const duration&)`

    template <class Rep2, class Period2>
    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`.

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()`.

###### Member Function `count() const`

    constexpr rep count() const;

Returns: `rep_`.

###### Member Function `operator+() const`

    constexpr duration operator+() const;

Returns: `*this`.

###### Member Function `operator-() const`

    constexpr duration operator-() const;

Returns: ``duration`(-rep_)`.

###### Member Function `operator++()`

    duration& operator++();

Effects: `++rep_`.

Returns: `*this`.

###### Member Function `operator++(int)`

    duration operator++(int);

Returns: ``duration`(rep_++)`.

###### Member Function `operator--()`

    duration& operator--();

Effects: `--rep_`.

Returns: `*this`.

###### Member Function `operator--(int)`

    duration operator--(int);

Returns: ``duration`(rep_--)`.

###### Member Function `operator+=(const duration&)`

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

Effects: `rep_ += d.count()`.

Returns: `*this`.

###### Member Function `operator-=(const duration&)`

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

Effects: `rep_ -= d.count()`.

Returns: `*this`.

###### Member Function `operator%=(const duration&)`

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

Effects: `rep_ %= d.count()`.

Returns: `*this`.

###### Member Function `operator*=(const rep&)`

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

Effects: `rep_ *= rhs`.

Returns: `*this`.

###### Member Function `operator/=(const rep&)`

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

Effects: `rep_ /= rhs`.

Returns: `*this`.

###### Member Function `operator%=(const rep&)`

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

Effects: `rep_ %= rhs`.

Returns: `*this`.

###### Static Member Function `zero()`

    static constexpr duration zero();

Returns: ``duration`(`duration_values`<rep>::zero())`.

###### Static Member Function `min()`

    static constexpr duration min();

Returns: ``duration`(`duration_values`<rep>::min()).`

###### Static Member Function `max()`

    static constexpr duration max();

Returns: ``duration`(`duration_values`<rep>::max())`.

##### `duration` Non-Member Arithmetic

###### Non-Member Function `operator+(duration,duration)`

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

Returns: `CD(CD(lhs).count() + CD(rhs).count())` where `CD` is the type of the return value.

###### Non-Member Function `operator-(duration,duration)`

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

Returns: `CD(CD(lhs).count() - CD(rhs).count())` where `CD` is the type of the return value.

###### Non-Member Function `operator*(duration,Rep1)`

    template <class Rep1, class Period, class Rep2>
    constexpr
    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`.

Returns: `CD(CD(d).count() * s)` where `CD` is the type of the return value.

###### Non-Member Function `operator*(Rep1,duration)`

    template <class Rep1, class Period, class Rep2>
    constexpr
    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`.

Returns: `d * s`.

###### Non-Member Function `operator/(duration,Rep2)`

    template <class Rep1, class Period, class Rep2>
    constexpr
    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`.

Returns: `CD(CD(d).count() / s)` where `CD` is the type of the return value.

###### Non-Member Function `operator/(duration,duration)`

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

Remarks: Let `CD` represent the `common_type` of the two `duration` arguments. Returns: Returns `CD(lhs).count() / CD(rhs).count()`.

###### Non-Member Function `operator/(Rep1,duration)`

Included only if BOOST_CHRONO_EXTENSIONS is defined.

This overloading could be used to get the frequency of an event counted by `Rep1`.

    template <class Rep1, class Rep2, class Period>
    constexpr
    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`. Let `CD` represent `duration`<CR,Period>.

Returns: `CR(s)/CD(d).count()` where `CD` is the type of the return value.

###### Non-Member Function `operator%(duration,Rep2)`

    template <class Rep1, class Period, class Rep2>
    constexpr
    duration<typename common_type<Rep1, Rep2>::type, Period>
    operator%(const duration<Rep1, Period>& d, const Rep2& s);

Remarks: Let `CR` represent the `common_type` of `Rep1` and `Rep2`. This function will not participate in overload resolution unless Rep2 must be implicitly convertible to CR and Rep2 must not be an instantiation of `duration`.

Returns: CD(CD(d).count() % s) where `CD` is the type of the return value.

###### Non-Member Function `operator%(duration,duration)`

    template <class Rep1, class Period1, class Rep2, class Period2>
    constexpr
    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
    operator%(const duration<Rep1, Period1>& lhs,
              const duration<Rep2, Period2>& rhs);

Remarks: This function will not participate in overload resolution unless

Returns: CD(CD(lhs).count() % CD(rhs).count()) where `CD` is the type of the return value.

##### `duration` Non-Member Comparaisons

###### Non-Member Function `operator==(duration,duration)`

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

Returns: Let `CD` represent the `common_type` of the two `duration` arguments.

Returns: Returns `CD(lhs).count() == CD(rhs).count()`

###### Non-Member Function `operator!=(duration,duration)`

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

Returns: `!(lhs == rhs)`.

###### Non-Member Function `operator<(duration,duration)`

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

Returns: Let `CD` represent the `common_type` of the two `duration` arguments. Returns `CD(lhs).count() < CD(rhs).count()`

###### Non-Member Function `operator<=(duration,duration)`

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

Returns: `!(rhs < lhs)`.

###### Non-Member Function `operator>(duration,duration)`

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

Returns: `rhs < lhs`.

###### Non-Member Function `operator>=(duration,duration)`

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

Returns: `!(lhs < rhs)`.

##### Non-Member Function `duration_cast(duration)`

    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`.

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 `ToDuration(static_cast<typename ToDuration::rep>(static_cast<CR>(d.count()) * static_cast<CR>(CF::num)))`
- else if `CF::num == 1` and `CF::den != 1`, then returns `ToDuration(static_cast<typename ToDuration::rep>(static_cast<CR>(d.count()) / static_cast<CR>(CF::den)))`
- else returns `ToDuration(static_cast<typename ToDuration::rep>(static_cast<CR>(d.count()) * 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.

##### `duration` typedefs

    // convenience typedefs
    typedef duration<boost::int_least64_t, nano> nanoseconds;    // at least 64 bits needed
    typedef duration<boost::int_least64_t, micro> microseconds;  // at least 55 bits needed
    typedef duration<boost::int_least64_t, milli> milliseconds;  // at least 45 bits needed
    typedef duration<boost::int_least64_t> seconds;              // at least 35 bits needed
    typedef duration<boost::int_least32_t, ratio< 60> > minutes; // at least 29 bits needed
    typedef duration<boost::int_least32_t, ratio<3600> > hours;  // at least 23 bits needed

#### `Clock` Requirements

A clock represents a bundle consisting of a `duration`, a `time_point`, and a function `now()` to get the current `time_point`. A clock must meet the requirements in the following Table.

In this table `C1` and `C2` denote `Clock` types. `t1` and `t2` are values returned from `C1::now()` where the call returning `t1` happens before the call returning `t2` and both of these calls occur before `C1::time_point::max()`. (note This means C1 did not wrap around between t1 and t2.).

Table 1.1. Clock Requirements

expression | return type | operational semantics
--- | --- | ---
`C1::rep` | An arithmetic type or class emulating an arithmetic type. | The representation type of the `duration` and `time_point`.
`C1::period` | `ratio` | The tick period of the clock in seconds.
`C1::duration` | `chrono::duration<C1::rep, C1::period>` | The `duration` type of the `clock`.
`C1::time_point` | `chrono::time_point<C1> or chrono::time_point<C2, C1::duration>` | The `time_point` type of the `clock`. Different clocks are permitted to share a `time_point` definition if it is valid to compare their time_points by comparing their respective `duration`s. `C1` and `C2` must refer to the same epoch.
`C1::is_steady` | `constexpr bool` | `true` if `t1 <= t2` is always `true`, else `false`. Note: A `clock` that can be adjusted backwards is not steady
`C1::now()` | `C1::time_point` | Returns a `time_point` representing the current point in time.

Models of `Clock`:

- `system_clock`
- `steady_clock`
- `high_resolution_clock`
- `process_real_cpu_clock`
- `process_user_cpu_clock`
- `process_system_cpu_clock`
- `process_cpu_clock`
- `thread_clock`

#### `TrivialClock` Requirements

A type `TC` meets the `TrivialClock` requirements if:

- `TC` satisfies the `Clock` requirements,
- the types `TC::rep`, `TC::duration`, and `TC::time_point` satisfy the requirements of `EqualityComparable`, `LessThanComparable`, `DefaultConstructible`, `CopyConstructible`, `CopyAssignable`, `Destructible`, and the requirements of numeric types.

| Note
This means, in particular, that operations on these types will not throw exceptions.

- lvalues of the types `TC::rep`, `TC::duration`, and `TC::time_point` are swappable,
- the function `TC::now()` does not throw exceptions and it is thread-safe, and
- the type `TC::time_point::clock` meets the `TrivialClock` requirements, recursively.

Models of `TrivialClock`:

- `system_clock`
- `steady_clock`
- `high_resolution_clock`
- `process_real_cpu_clock`
- `process_user_cpu_clock`
- `process_system_cpu_clock`
- `thread_clock`

#### `EcClock` Requirements

A type `EcC` meets the `EcClock` requirements if

- `TC` satisfies the `TrivialClock` requirements, and
- it adds `now()` interfaces allowing to recover internal error codes as described in the following table.
- the added now() function is thread-safe.

In this table `C1` denotes a `EcClock` type and `ec` is an instance of a `boost::system::error_code`.

Table 1.2. Clock Requirements

expression | return type | operational semantics
--- | --- | ---
`C1::now(ec)` | `C1::time_point` | Returns a `time_point` representing the current point in time. `ec` will stores the error-code in case something was wrong internally.
`C1::now(boost::throws())` | `C1::time_point` | Returns a `time_point` representing the current point in time. Throws a `boost::system::system_error` exception in case something was wrong internally.

Models of `Clock`:

- `system_clock`
- `steady_clock`
- `high_resolution_clock`
- `process_real_cpu_clock`
- `process_user_cpu_clock`
- `process_system_cpu_clock`
- `process_cpu_clock`
- `thread_clock`

#### Header `<boost/chrono/time_point.hpp>`

This file contains `time_point` specific classes and non-member functions.

    namespace boost {
      namespace chrono {

        template <class Clock, class Duration = typename Clock::duration>
        class time_point;

      }
      template <class Clock, class Duration1, class Duration2>
      struct common_type<time_point<Clock, Duration1>,
                         time_point<Clock, Duration2> >;

      namespace chrono {

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

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

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

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

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

        // time_point_cast
        template <class ToDuration, class Clock, class Duration>
        constexpr time_point<Clock, ToDuration>
        time_point_cast(const time_point<Clock, Duration>& t);

      }
    }

##### `common_type` specialization

    template <class Clock, class Duration1, class Duration2>
    struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2> >
    {
        typedef chrono::time_point<Clock, typename common_type<Duration1, Duration2>::type> type;
    };

The `common_type` of two `time_point`s is a `time_point` with the same `Clock` (both have the same `Clock`), and the `common_type` of the two `duration`s.

##### Class template `time_point<>`

A `time_point` represents a point in time with respect to a specific clock.

    template <class Clock, class Duration>
    class time_point {
    public:
        typedef Clock                     clock;
        typedef Duration                  duration;
        typedef typename duration::rep    rep;
        typedef typename duration::period period;
    private:
        duration d_; // exposition only
    public:
        constexpr time_point();

        constexpr explicit time_point(const duration& d);

        // conversions
        template <class Duration2>
        constexpr
        time_point(const time_point<clock, Duration2>& t);

        // observer
        constexpr duration time_since_epoch() const;

        // arithmetic

        #ifdef BOOST_CHRONO_EXTENSIONS
        constexpr time_point  operator+();
        constexpr time_point  operator-();
        time_point& operator++();
        time_point  operator++(int);
        time_point& operator--();
        time_point  operator--(int);

        time_point& __time_point__op_plus_eq_1(const rep& d);
        time_point& operator-=(const rep& d);
        #endif

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

        // special values

        static constexpr time_point min();
        static constexpr time_point max();
    };

Clock must meet the `Clock` requirements.

Duration must be an instantiation of `duration`, compile diagnostic otherwise.

###### Constructor `time_point()`

    constexpr time_point();

Effects: Constructs an object of `time_point`, initializing `d_` with `duration::zero()`. This `time_point` represents the epoch.

###### Constructor `time_point(const duration&)`

    constexpr time_point(const duration& d);

Effects: Constructs an object of `time_point`, initializing `d_` with `d`. This `time_point` represents the epoch `+ d`.

###### Copy Constructor `time_point(const time_point&)`

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

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()`.

###### Member Function `time_since_epoch() const`

    constexpr duration time_since_epoch() const;

Returns: `d_`.

###### Member Function `operator+() const`

    constexpr time_point operator+() const;

Returns: `*this`.

###### Member Function `operator-() const`

    constexpr time_point operator-() const;

Returns: ``time_point`(-d_)`.

###### Member Function `operator++()`

    time_point& operator++();

Effects: `++d_`.

Returns: `*this`.

###### Member Function `operator++(int)`

    time_point operator++(int);

Returns: ``time_point`(d_++)`.

###### Member Function `operator--()`

    time_point& operator--();

Effects: `--d_`.

Returns: `*this`.

###### Member Function `operator--(int)`

    time_point operator--(int);

Returns: ``time_point`(d_--)`.

###### Member Function `operator+=(const rep&)`

    time_point& operator+=(const rep& r);

Effects: `d_ += duration(r)`.

Returns: `*this`.

###### Member Function `operator-=(const rep&)`

    time_point& operator-=(const rep& r);

Effects: `d_ -= duration(r)`

Returns: `*this`.

###### Member Function `operator+=`

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

Effects: `d_ += d`.

Returns: `*this`.

###### Member Function `operator-=`

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

Effects: `d_ -= d`

Returns: `*this`.

###### Static Member Function `min`

    static constexpr time_point min();

Returns: `time_point(duration::min())`.

###### Static Member Function `max`

    static constexpr time_point max();

Returns: `time_point(duration::max())`.

##### `time_point` non-member arithmetic

###### Non-Member Function `operator+(time_point,duration)`

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

Returns: `CT(lhs.time_since_epoch() + rhs)` where `CT` is the type of the return value.

###### Non-Member Function `operator+(duration,time_point)`

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

Returns: `rhs + lhs`.

###### Non-Member Function `operator-(time_point,duration)`

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

Returns: `lhs + (-rhs)`.

###### Non-Member Function `operator-(time_point,time_point)`

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

Returns: `lhs.time_since_epoch() - rhs.time_since_epoch()`.

##### `time_point` non-member comparisons

###### Non-Member Function `operator==(time_point,time_point)`

    template <class Clock, class Duration1, class Duration2>
    constexpr
    bool operator==(const time_point<Clock, Duration1>& lhs,
                    const time_point<Clock, Duration2>& rhs);

Returns: `lhs.time_since_epoch() == rhs.time_since_epoch()`.

###### Non-Member Function `operator!=(time_point,time_point)`

    template <class Clock, class Duration1, class Duration2>
    constexpr
    bool operator!=(const time_point<Clock, Duration1>& lhs,
                    const time_point<Clock, Duration2>& rhs);

Returns: `!(lhs == rhs)`.

###### Non-Member Function `operator<(time_point,time_point)`

    template <class Clock, class Duration1, class Duration2>
    constexpr
    bool operator< (const time_point<Clock, Duration1>& lhs,
                    const time_point<Clock, Duration2>& rhs);

Returns: lhs.time_since_epoch() < rhs.time_since_epoch().

###### Non-Member Function `operator<=(time_point,time_point)`

    template <class Clock, class Duration1, class Duration2>
    constexpr
    bool operator<=(const time_point<Clock, Duration1>& lhs,
                    const time_point<Clock, Duration2>& rhs);

Returns: `!(rhs < lhs)`.

###### Non-Member Function `operator>(time_point,time_point)`

    template <class Clock, class Duration1, class Duration2>
    constexpr
    bool operator>(const time_point<Clock, Duration1>& lhs,
                   const time_point<Clock, Duration2>& rhs);

Returns: `rhs < lhs`.

###### Non-Member Function `operator>=(time_point,time_point)`

    template <class Clock, class Duration1, class Duration2>
    constexpr
    bool operator>=(const time_point<Clock, Duration1>& lhs,
                    const time_point<Clock, Duration2>& rhs);

Returns: `!(lhs < rhs)`.

##### Non-Member Function `time_point_cast(time_point)`

    template <class ToDuration, class Clock, class Duration>
    constexpr
    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`.

Returns: ``time_point`<`Clock`, ToDuration>(`duration_cast`<ToDuration>(t.time_since_epoch()))`.

#### Header `<boost/chrono/system_clocks.hpp>`

This file contains the standard clock classes. The types defined in this section satisfy the `TrivialClock` requirements

    namespace boost {
      namespace chrono {

        // Clocks
        class system_clock;
        class steady_clock;
        class high_resolution_clock;

        template <class CharT>
        struct clock_string<system_clock, CharT>;
        template <class CharT>
        struct clock_string<steady_clock, CharT>;

      }
    }

##### Class `system_clock`

The `system_clock` class provides a means of obtaining the current wall-clock time from the system-wide real-time clock. The current time can be obtained by calling `system_clock::now()`. Instances of `system_clock::time_point` can be converted to and from time_t with the `system_clock::to_time_t()` and `system_clock::from_time_t()` functions. If system clock is not steady, a subsequent call to `system_clock::now()` may return an earlier time than a previous call (e.g. if the operating system clock is manually adjusted, or synchronized with an external clock).

The current implementation of `system_clock` is related an epoch (midnight UTC of January 1, 1970), but this is not in the contract. You need to use the static function static

    std::time_t to_time_t(const time_point& t);

which returns a `time_t` type that is based on midnight UTC of January 1, 1970.

    class system_clock {
    public:
        typedef see bellow          duration;
        typedef duration::rep                        rep;
        typedef duration::period                     period;
        typedef chrono::time_point<system_clock>     time_point;
        static constexpr bool is_steady =            false;

        static time_point  now() noexcept;
        static time_point  now(system::error_code & ec);

        // Map to C API
        static std::time_t to_time_t(const time_point& t) noexcept;
        static time_point  from_time_t(std::time_t t) noexcept;
    };

`system_clock` satisfy the `Clock` requirements:

- `system_clock::duration::min() < system_clock::duration::zero()` is `true`.
- The nested `duration` typedef has a resolution that depends on the one provided by the platform.

###### Static Member Function `to_time_t(time_point)`

    time_t to_time_t(const time_point& t) noexcept;

Returns: A `time_t` such that the `time_t` and `t` represent the same point in time, truncated to the coarser of the precisions among `time_t` and `time_point`.

###### Static Member Function `from_time_t(time_t)`

    time_point from_time_t(time_t t) noexcept;

Returns: A `time_point` such that the `time_point` and `t` represent the same point in time, truncated to the coarser of the precisions among `time_point` and `time_t`.

##### Macro `BOOST_CHRONO_HAS_CLOCK_STEADY`

Defined if the platform support steady clocks.

##### Class `steady_clock`

`steady_clock` satisfy the `Clock` requirements.

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

    #ifdef BOOST_HAS_CLOCK_STEADY
        class steady_clock {
        public:
            typedef nanoseconds                          duration;
            typedef duration::rep                        rep;
            typedef duration::period                     period;
            typedef chrono::time_point<steady_clock>     time_point;
            static constexpr bool is_steady =            true;

            static time_point  now() noexcept;
            static time_point  now(system::error_code & ec);
        };
    #endif

##### Class `high_resolution_clock`

`high_resolution_clock` satisfy the `Clock` requirements.

    #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
      typedef steady_clock high_resolution_clock;  // as permitted by [time.clock.hires]
    #else
      typedef system_clock high_resolution_clock;  // as permitted by [time.clock.hires]
    #endif

##### `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"

##### `clock_string<steady_clock>` Specialization

    #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY

    template <class CharT>
    struct clock_string<steady_clock, CharT>
    {
        static std::basic_string<CharT> name();
        static std::basic_string<CharT> since();
    };
    #endif

`clock_string<>::name()` returns "steady_clock".

`clock_string<>::since()` returns " since boot"

#### Header `<boost/chrono/clock_strings.hpp>`

    namespace boost {
      namespace chrono {

        template <class Clock, class CharT>
        struct 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 usually corresponds to the class name.

`clock_string<>::since()` return the textual format of the clock epoch.

#### Header `<boost/chrono/typeof/boost/chrono/chrono.hpp>`

Register `duration``<>` and `time_point``<>` class templates to Boost.Typeof.