| Home | Libraries | People | FAQ | More

## Reference

As `constexpr` will not be supported by some compilers, it is replaced in the code by `BOOST_CONSTEXPR` for `constexpr` functions and `BOOST_STATIC_CONSTEXPR` for struct/class static fields. The same applies to `noexecpt` which is replaced by `noexcept` in the code.

The documentation doesn't use these macros.

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

Include all the chrono header files.

    #include <boost/chrono/chrono.hpp>
    #include <boost/chrono/chrono_io.hpp>
    #include <boost/chrono/process_cpu_clocks.hpp>
    #include <boost/chrono/thread_clocks.hpp>
    #include <boost/chrono/ceil.hpp>
    #include <boost/chrono/floor.hpp>
    #include <boost/chrono/round.hpp>

### 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 6.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 6.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.

### Chrono I/O V1

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

    namespace boost {
    namespace chrono {

        template <class CharT>
        class duration_punct;

        template <class CharT, class Traits>
            std::basic_ostream<CharT, Traits>&
            duration_short(std::basic_ostream<CharT, Traits>& os);

        template <class CharT, class Traits>
            std::basic_ostream<CharT, Traits>&
            duration_long(std::basic_ostream<CharT, Traits>& os);

        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);

        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)

        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);

        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);

    }
    }

##### 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
    {
    public:
        typedef std::basic_string<CharT> string_type;
        enum {use_long, use_short};

        static std::locale::id id;

        explicit duration_punct(int use = use_long);

        duration_punct(int use,
            const string_type& long_seconds, const string_type& long_minutes,
            const string_type& long_hours, const string_type& short_seconds,
            const string_type& short_minutes, const string_type& short_hours);

        duration_punct(int use, const duration_punct& d);

        template <class Period> string_type short_name() const;
        template <class Period> string_type long_name() const;
        template <class Period> string_type name() const;

        bool is_short_name() const;
        bool is_long_name() const;
    };

##### 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 `duration`s and `time_point`s as abbreviations.

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

##### 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 abbreviated 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 abbreviated 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

### Chrono I/O V2

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

This file includes the i/o of the two major components, duration and time_point.

    #include <boost/chrono/io/duration_style.hpp>
    #include <boost/chrono/io/timezone.hpp>
    #include <boost/chrono/io/ios_base_state.hpp>
    #include <boost/chrono/io/duration_get.hpp>
    #include <boost/chrono/io/duration_put.hpp>
    #include <boost/chrono/io/duration_units.hpp>
    #include <boost/chrono/io/duration_io.hpp>
    #include <boost/chrono/io/time_point_get.hpp>
    #include <boost/chrono/io/time_point_put.hpp>
    #include <boost/chrono/io/time_point_units.hpp>
    #include <boost/chrono/io/time_point_io.hpp>

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

    namespace boost {
      namespace chrono {

        // typedefs
        enum class duration_style {
          prefix, symbol
        };
      }
    }

##### Scoped enum `duration_style`

    enum class duration_style {
      prefix, symbol
    };

`duration` unit names come in two varieties: prefix and symbol.

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

    namespace boost {
      namespace chrono {

        struct timezone
        {
          enum type {
            utc, local
          };
        };
      }
    }

##### Scoped enum `timezone`

    enum class timezone {
      utc, local
    };

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

    namespace boost {
      namespace chrono {

        // setters and getters
        duration_style get_duration_style(std::ios_base & ios);
        void set_duration_style(std::ios_base& ios, duration_style style);

        timezone get_timezone(std::ios_base & ios);
        void set_timezone(std::ios_base& ios, timezone tz);

        template<typename CharT>
        std::basic_string<CharT> get_time_fmt(std::ios_base & ios);
        template<typename CharT>
        void set_time_fmt(std::ios_base& ios, std::basic_string<CharT> const& fmt);

        // i/o state savers
        struct duration_style_io_saver;
        template<typename CharT = char, typename Traits = std::char_traits<CharT> >
        struct timezone_io_saver;
        template<typename CharT = char, typename Traits = std::char_traits<CharT> >
        struct time_fmt_io_saver;
      }
    }

##### Setter and getters

###### Non Member Function `get_duration_style(std::ios_base &)`

    duration_style get_duration_style(std::ios_base & ios);

Returns: The stream's `duration_style` attribute associated to `ios`.

###### Non Member Function `set_duration_style(std::ios_base &,duration_style)`

    void set_duration_style(std::ios_base& ios, duration_style style);

Effects: Set the stream's `duration_style` attribute associated to `ios` with the `style` parameter.

###### Non Member Function `get_timezone(std::ios_base&)`

    timezone get_timezone(std::ios_base & ios);

Returns: The stream's `timezone` attribute associated to `ios`.

###### Non Member Function `set_timezone(std::ios_base&,duration_style)`

    void set_timezone(std::ios_base& ios, timezone tz);

Effects: Set the stream's `timezone` attribute associated to `ios` with the `tz` parameter.

###### Non Member Function `get_time_fmt(std::ios_base &)`

    template<typename CharT>
    std::basic_string<CharT> get_time_fmt(std::ios_base & ios);

Returns: The stream's time format attribute associated to `ios`.

###### Non Member Function `set_time_fmt(std::ios_base&, std::basic_string<CharT> const&)`

    template<typename CharT>
    void set_time_fmt(std::ios_base& ios, std::basic_string<CharT> const& fmt);

Effects: Set the stream's time format attribute associated to `ios` with the `fmt` parameter.

The format is composed of zero or more directives. Each directive is composed of one of the following:

    * one or more white-space characters (as specified by isspace());
    * an ordinary character (neither '%' nor a white-space character);
    * or a conversion specification.

Each conversion specification is composed of a '%' character followed by a conversion character which specifies the replacement required. The application shall ensure that there is white-space or other non-alphanumeric characters between any two conversion specifications. The following conversion specifications are supported:

Table 6.3. Format tags

Format Specifier | Description | Example
--- | --- | ---
`%%` | Replaced by `%`. | .
`%a %A` | The day of the week, using the locale's weekday names; either the abbreviated or full name may be specified. | "Monday".
`%b %B %h` | The month, using the locale's month names; either the abbreviated or full name may be specified. | "February".
`%c` | Not supported. | .
`%d %e` | The day of the month `[01,31]`; leading zeros are permitted but not required.. | .
`%D` | The date as `%m/%d/%y`. | .
`%F` | The date as `%Y/%m/%d`. | .
`%H` | The hour (24-hour clock) `[00,23]`; leading zeros are permitted but not required. | .
`%I` | The hour (12-hour clock) `[01,12]`; leading zeros are permitted but not required. | .
`%j` | The day number of the year `[001,366]`; leading zeros are permitted but not required. | "060" => Feb-29.
`%m` | The month number `[01,12]`; leading zeros are permitted but not required.. | "01" => January.
`%M` | The minute `[00,59]`; leading zeros are permitted but not required. | .
`%n %t` | Any white space.. | .
`%p` | Not supported. | .
`%r` | Not supported. | .
`%R` | The time as `%H:%M`. | .
`%S` | The seconds `[00,60]`; leading zeros are permitted but not required. | .
`%T` | The time as `%H:%M:%S`. | .
`%U` | Not supported. | .
`%w` | The weekday as a decimal number `[0,6]`, with 0 representing Sunday; leading zeros are permitted but not required.. | "0" => Sunday.
`%W` | Not supported. | .
`%x` | The date, using the locale's date format.. | .
`%X` | Not supported. | .
`%y` | Not supported. | "2005".
`%Y` | The year, including the century (for example, 1988). | .

##### I/O State Savers

###### Template Class `duration_style_io_saver`

    // i/o state savers

    struct duration_style_io_saver
    {
      typedef std::ios_base state_type; // the state type is ios_base
      typedef duration_style aspect_type; // the aspect type is the __duration_style

      explicit duration_style_io_saver(state_type &s);
      duration_style_io_saver(state_type &s, aspect_type new_value);
      ~duration_style_io_saver();
      void restore();
    };

The `state_type` is a version of the IOStreams base class `std::ios_base`.

###### Constructor `duration_style_io_saver(state_type&)`

This constructor takes a stream object and saves a reference to the stream and the current value of a particular stream attribute.

    explicit duration_style_io_saver(state_type &s);

Effects: Constructs a `duration_style_io_saver` by storing `s`.

###### Constructor `duration_style_io_saver(state_type&, aspect_type)`

This constructor works like the previous one, and in addition uses its second argument to change the stream's attribute to the new `aspect_type` value given.

    explicit duration_style_io_saver(state_type &s, aspect_type new_value);

Effects: Constructs a `duration_style_io_saver` by storing `s`. Sets the `state_type` `aspect_type` with the value `new_value`.

###### Destructor `~duration_style_io_saver()`

The destructor restores the stream's attribute to the saved value.

    ~duration_style_io_saver();

Effects: As if `restore`().

###### Member Function `restore()`

The restoration can be activated early (and often) with the restore member function.

    void restore();

Effects: Restores the stream's `duration_style` attribute to the saved value.

###### Template Class `timezone_io_saver<>`

    template<typename CharT = char, typename Traits = std::char_traits<CharT> >
    struct timezone_io_saver
    {
      typedef std::basic_ios<CharT, Traits> state_type;
      typedef timezone aspect_type;

      explicit timezone_io_saver(state_type &s);
      timezone_io_saver(state_type &s, aspect_type new_value);
      ~timezone_io_saver();
      void timezone_io_saver__restore();
    };

The `state_type` is a version of the IOStreams base class template `std::basic_ios<CharT, Traits>`, where `CharT` is a character type and `Traits` is a character traits class. The user would usually place an actual input, output, or combined stream object for the state-type parameter, and not a base class object.

###### Constructor `timezone_io_saver(state_type&)`

This constructor takes a stream object and saves a reference to the stream and the current value of a particular stream attribute.

    explicit timezone_io_saver(state_type &s);

Effects: Constructs a `timezone_io_saver` by storing `s`.

###### Constructor `timezone_io_saver(state_type&, aspect_type)`

This constructor works like the previous one, and uses its second argument to change the stream's attribute to the new aspect_type value given.

    explicit timezone_io_saver(state_type &s, aspect_type new_value);

Effects: Constructs a `timezone_io_saver` by storing `s`. Sets the `state_type` `aspect_type` with the value `new_value`.

###### Destructor `~timezone_io_saver()`

The destructor restores the stream's attribute to the saved value.

    ~timezone_io_saver();

Effects: As if `restore`().

###### Member Function `restore()`

The restoration can be activated early (and often) with the restore member function.

    void restore();

Effects: Restores the stream's `timezone` attribute to the saved value.

###### Template Class `time_fmt_io_saver<>`

    template<typename CharT = char, typename Traits = std::char_traits<CharT> >
    struct time_fmt_io_saver
    {
      typedef std::basic_ios<CharT, Traits> state_type;

      explicit time_fmt_io_saver(state_type &s);
      time_fmt_io_saver(state_type &s, basic_string<CharT> const& new_value);
      ~time_fmt_io_saver();
      void restore();
    };

The `state_type` is a version of the IOStreams base class template `std::basic_ios<CharT, Traits>`, where `CharT` is a character type and `Traits` is a character traits class. The user would usually place an actual input, output, or combined stream object for the state-type parameter, and not a base class object.

###### Constructor `time_fmt_io_saver(state_type&)`

This constructor takes a stream object and saves a reference to the stream and the current value of a particular stream attribute.

    explicit time_fmt_io_saver(state_type &s);

Effects: Constructs a `time_fmt_io_saver` by storing `s`.

###### Constructor `time_fmt_io_saver(state_type&, aspect_type)`

This constructor works like the previous one, and uses its second argument to change the stream's attribute to the new aspect_type value given.

    explicit time_fmt_io_saver(state_type &s, aspect_type new_value);

Effects: Constructs a `time_fmt_io_saver` by storing `s`. Sets the `state_type` `aspect_type` with the value `new_value`.

###### Destructor `~time_fmt_io_saver()`

The destructor restores the stream's attribute to the saved value.

    ~time_fmt_io_saver();

Effects: As if `restore`().

###### Member Function `restore()`

The restoration can be activated early (and often) with the restore member function.

    void restore();

Effects: Restores the stream's time format attribute to the saved value.

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

    namespace boost {
      namespace chrono {

        template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
        class duration_get;

      }
    }

##### Template Class `duration_get`

    template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
    class duration_get: public std::locale::facet
    {
    public:
      typedef CharT char_type; // Type of character the facet is instantiated on
      typedef std::basic_string<CharT> string_type; // Type of character string passed to member functions.
      typedef InputIterator iter_type; // Type of iterator used to scan the character buffer.

      explicit duration_get(size_t refs = 0);

      template <typename Rep, typename Period>
      iter_type get(
        iter_type s,
        iter_type end,
        std::ios_base& ios,
        std::ios_base::iostate& err,
        duration<Rep, Period>& d,
        const char_type* pattern,
        const char_type* pat_end
      ) const;

      template <typename Rep, typename Period>
      iter_type get(
        iter_type s,
        iter_type end,
        std::ios_base& ios,
        std::ios_base::iostate& err,
        duration<Rep, Period>& d
      ) const;

      template <typename Rep>
      iter_type get_value(
        iter_type s,
        iter_type end,
        std::ios_base& ios,
        std::ios_base::iostate& err,
        Rep& r
      ) const;

      iter_type get_unit(
        iter_type i,
        iter_type e,
        std::ios_base& is,
        std::ios_base::iostate& err,
        detail::rt_ratio &rt
      ) const

      static std::locale::id id; // Unique identifier for this type of facet.

      ~duration_get()
      {
      }

    };

The `duration_get` facet extracts duration from a character string and stores the resulting value in a class duration d argument. The facet parses the string using a specific format as a guide. If the string does not fit the format, then the facet will indicate an error by setting the err argument to iosbase::failbit. In other words, user confirmation is required for reliable parsing of user-entered durations, but machine-generated formats can be parsed reliably. This allows parsers to be aggressive about interpreting user variations on standard formats.

###### Constructor `duration_get(size_t)`

    explicit duration_get(size_t refs);

Constructs a `duration_get` facet.

Parameters:

- refs: references

Effects: Constructs a `duration_get` facet. If the `refs` argument is `0` then destruction of the object is delegated to the locale, or locales, containing it. This allows the user to ignore lifetime management issues. On the other had, if `refs` is `1` then the object must be explicitly deleted; `locale` will not do so. In this case, the object can be maintained across the lifetime of multiple locales.

###### Destructor `~duration_get()`

    ~duration_get();

Destructs a `duration_get` facet.

###### Template Member Function `get(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,duration<Rep,Period>&,const char_type*, const char_type*) const`

    template <typename Rep, typename Period>
    iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
        duration<Rep, Period> &d, const char_type *pattern, const char_type *pat_end) const;

Extracts a duration from the range `[s,end)` following the pattern `[pattern,pat_end)`.

Parameters:

- s: start input stream iterator
- end: end input stream iterator
- ios: a reference to a ios_base
- err: the ios_base state
- d: the duration
- pattern: begin of the formatting pattern
- pat_end: end of the formatting pattern

Requires: `[s, end) and [pattern, pat_end)` shall be valid ranges.

Effects: The function starts by evaluating `err = std::ios_base::goodbit`.

Then it computes an intermediate representation based on `Rep` according to the following rules:

- If `Rep` is a floating point type, the intermediate representation is `long double`.
- Else if `Rep` is a signed integral type, the intermediate representation is `long long`.
- Else if `Rep` is an unsigned integral type, the intermediate representation is unsigned long long.
- Else intermediate representation is `Rep`.

Next the following local variable `r` of type intermediate representation and `rt` of type `rt_ratio` are default constructed.

It then enters a loop, reading zero or more characters from `s` at each iteration. Unless otherwise specified below, the loop terminates when the first of the following conditions holds:

- The expression `pattern == pat_end` evaluates to `true`.
- The expression `err == std::ios_base::goodbit` evaluates to false.
- The expression `s == end` evaluates to `true`, in which case the function evaluates `err = std::ios_base::eofbit | std::ios_base::failbit`.
- The next element of pattern is equal to `'%'`, followed by a conversion specifier character, format. If the number of elements in the range `[pattern,pat_end)` is not sufficient to unambiguously determine whether the conversion specification is complete and valid, the function evaluates `err = std::ios_base::failbit`. Otherwise, the function evaluates `s = get_value(s, end, ios, err, r)` when the conversion specification is 'v' and `s = get_value(s, end, ios, err, rt)` when the conversion specification is 'u'. If `err == std::ios_base::goodbit` holds after the evaluation of the expression, the function increments pattern to point just past the end of the conversion specification and continues looping.
- The expression `isspace(*pattern, ios.getloc())` evaluates to `true`, in which case the function first increments pattern until `pattern == pat_end || !isspace(*pattern, ios.getloc())` evaluates to `true`, then advances `s` until `s == end || !isspace(*s, ios.getloc())` is `true`, and finally resumes looping.
- The next character read from `s` matches the element pointed to by pattern in a case-insensitive comparison, in which case the function evaluates `++pattern, ++s` and continues looping. Otherwise, the function evaluates `err = std::ios_base::failbit`.

If a duration representation value and a unit specifier have successfully been parsed, compute `(rt.num/rt.den)/(Period::num/Period::den)` reduced to lowest terms. If this ratio can not be stored without overflow, evaluates `err = std::ios_base::failbit`. Otherwise store the result of this division in `num` and `den`.

If the division did not result in overflow, then compute `r * num / den` in such a way as to avoid intermediate overflow. If `r` has integral type and this computation would not be exact, evaluates `err = std::ios_base::failbit`. If the result of the computation would overflow `Rep`, evaluates `err = std::ios_base::failbit`. Otherwise the result of `r * num / den` is used to construct a `duration<Rep, Period>` which is assigned to `d`.

Returns: `s`, an iterator pointing just beyond the last character that can be determined to be part of a valid duration.

###### Template Member Function `get(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,duration<Rep,Period>&) const`

    template <typename Rep, typename Period>
    iter_type get(
      iter_type s,
      iter_type end,
      std::ios_base& ios,
      std::ios_base::iostate& err,
      duration<Rep, Period>& d
    ) const;

Extracts a duration from the range `[s,end)` following the default pattern.

Parameters:

- s: start input stream iterator
- end: end input stream iterator
- ios: a reference to a ios_base
- err: the ios_base state
- d: the duration

Effects: Stores the duration pattern from the __duration_unit facet associated to 'ios`in let say` str`. Last as if

    return get(s, end, ios, err, ios, d, str.data(), str.data() + str.size());

Returns: `s`, an iterator pointing just beyond the last character that can be determined to be part of a valid duration.

###### Template Member Function `get_value(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,Rep&) const`

    template <typename Rep>
    iter_type get_value(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err, Rep& r) const;

Extracts a duration representation from the range `[s,end)`.

Parameters:

- s: start input stream iterator
- end: end input stream iterator
- ios: a reference to a ios_base
- err: the ios_base state
- r: a reference to the duration representation

Effects: As if

    return std::use_facet<std::num_get<char_type, iter_type>>(ios.getloc()).get(s, end, ios, err, r);

Returns: `s`, an iterator pointing just beyond the last character that can be determined to be part of a valid `Rep` value.

###### Member Function `get_unit(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,rt_ratio&) const`

    iter_type get_unit(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err, detail::rt_ratio &rt) const;

Extracts a duration unit from the range `[s,end)`.

Parameters:

- s: start input stream iterator
- end: end input stream iterator
- ios: a reference to a ios_base
- err: the ios_base state
- rt: a reference to the duration run-time ratio.

Effects:

- If the first character is `'['`, an attempt is made to consume a pattern of the form `"[N/D]"` where `N` and `D` have type `unsigned long long`.
  - If successful, rt records the values of `N` and `D`, otherwise evaluates `err = std::ios_base::failbit` and return `i`.
  - Return the parse the longest string possible matching one of the durations units that can follow the pattern `"[N/D]"`, as if

    return do_get_n_d_prefix_unit(facet, i, e, is, err);

- Otherwise the next character is not `'['`. Return the parse the longest string possible matching one of the durations units, as if

    return do_get_prefix_unit(facet, i, e, is, err, rt);

Returns: `i`, an iterator pointing just beyond the last character that can be determined to be part of a valid duration unit.

###### Protected Member Function `do_get_n_d_prefix_unit(duration_units<CharT> const&,iter_type,iter_type,std::ios_base&,std::ios_base::iostate&) const`

    virtual iter_type do_get_n_d_prefix_unit(
      duration_units<CharT> const &facet,
      iter_type i,
      iter_type e,
      std::ios_base&,
      std::ios_base::iostate& err
    ) const;

Extracts the run-time ratio associated to the duration when it is given in [N/D] form.

This is an extension point of this facet so that we can take in account other periods that can have a useful translation in other contexts, as e.g. days and weeks.

Parameters:

- s: start input stream iterator
- end: end input stream iterator
- ios: a reference to a ios_base
- err: the ios_base state
- rt: a reference to the duration run-time ratio.

Effects: Scan `s` for the longest of all the plural forms associated with the duration units. If successful, sets the matched ratio in `rt`. Otherwise evaluates `err = std::ios_base::failbit`.

Returns: `s`, an iterator pointing just beyond the last character that can be determined to be part of a valid name.

###### Protected Member Function `do_get_prefix_unit(duration_units<CharT> const&,iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,detail::rt_ratio&) const`

    virtual iter_type do_get_prefix_unit(
      duration_units<CharT> const &facet,
      iter_type i,
      iter_type e,
      std::ios_base&,
      std::ios_base::iostate& err,
      detail::rt_ratio &rt
    ) const;

Extracts the run-time ratio associated to the duration when it is given in prefix form.

This is an extension point of this facet so that we can take in account other periods that can have a useful translation in other contexts, as e.g. days and weeks.

Parameters:

- s: start input stream iterator
- end: end input stream iterator
- ios: a reference to a ios_base
- err: the ios_base state
- rt: a reference to the duration run-time ratio.

Effects: Scan `s` for the longest of all the plural forms associated with the duration units. If successful, sets the matched ratio in `rt`. Otherwise evaluates `err = std::ios_base::failbit`.

Returns: `s`, an iterator pointing just beyond the last character that can be determined to be part of a valid name.

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

    namespace boost {
      namespace chrono {

        template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
        class duration_put;

      }
    }

##### Template Class `duration_put`

    template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
    class duration_put: public std::locale::facet
    {
    public:
      typedef CharT char_type; // Type of character the facet is instantiated on.
      typedef std::basic_string<CharT> string_type; // Type of character string passed to member functions.
      typedef OutputIterator iter_type; // Type of iterator used to write in the character buffer.

      explicit duration_put(size_t refs = 0);

      template <typename Rep, typename Period>
      iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d, const CharT* pattern,
          const CharT* pat_end) const;

      template <typename Rep, typename Period>
      iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

      template <typename Rep, typename Period>
      iter_type put_value(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

      template <typename Rep, typename Period>
      iter_type put_unit(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

      static std::locale::id id; // Unique identifier for this type of facet.

      ~duration_put();
    };

###### Constructor `duration_put(size_t)`

    explicit duration_put(size_t refs);

Constructs a `duration_put` facet.

Parameters:

- refs: references

Effects: Constructs a `duration_put` facet. If the `refs` argument is `0` then destruction of the object is delegated to the locale, or locales, containing it. This allows the user to ignore lifetime management issues. On the other had, if `refs` is `1` then the object must be explicitly deleted; `locale` will not do so. In this case, the object can be maintained across the lifetime of multiple locales.

###### Destructor `~duration_put()`

    ~duration_put();

Destructs a `duration_put` facet.

###### Member Function `put(iter_type,std::ios_base&,char_type,duration<Rep,Period> const&, const CharT*,const CharT*)`

    template <typename Rep, typename Period>
    iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d, const CharT* pattern,
        const CharT* pat_end) const;

Parameters:

- s: an output stream iterator
- ios: a reference to a ios_base
- d: the duration
- pattern: begin of the formatting pattern
- pat_end: end of the formatting pattern

Effects: Steps through the sequence from `pattern` to `pat_end`, identifying characters that are part of a pattern sequence. Each character that is not part of a pattern sequence is written to `s` immediately, and each pattern sequence, as it is identified, results in a call to `put_value` or `put_unit`; thus, pattern elements and other characters are interleaved in the output in the order in which they appear in the pattern. Pattern sequences are identified by converting each character `c` to a `char` value as if by `ct.narrow(c,0)`, where `ct` is a reference to `ctype<charT>` obtained from `ios.getloc()`. The first character of each sequence is equal to `'%'`, followed by a pattern specifier character specifier, which can be `'v'` for the duration value or `'u'` for the duration unit. . For each valid pattern sequence identified, calls `put_value(s, ios, d)` or `put_unit(s, ios, d)`.

Returns: An iterator pointing immediately after the last character produced.

###### Member Function `put(iter_type,std::ios_base&,char_type fill, duration<Rep, Period> const&)`

    template <typename Rep, typename Period>
    iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

Parameters:

- s: an output stream iterator
- ios: a reference to a ios_base
- d: the duration

Retrieves Stores the duration pattern from the __duration_unit facet in let say `str`. Last as if

    return put(s, ios, d, str.data(), str.data() + str.size());

Returns: An iterator pointing immediately after the last character produced.

###### Member Function `put_value(iter_type, std::ios_base&, char_type, duration<Rep,Period> const&)`

    template <typename Rep, typename Period>
    iter_type put_value(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

Parameters:

- s: an output stream iterator
- ios: a reference to a ios_base
- d: the duration

Effects: As if std::use_facet<std::num_put<CharT, iter_type> >(ios.getloc()).put(s, ios, ' ', static_cast<long int> (d.count())).

Returns: An iterator pointing immediately after the last character produced.

###### Member Function `put_unit(iter_type,std::ios_base&,char_type,duration<Rep, Period> const&)`

    template <typename Rep, typename Period>
    iter_type put_unit(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

Parameters:

- s: an output stream iterator
- ios: a reference to a ios_base
- fill: the fill character
- d: the duration

Effects: Let `facet` be the `duration_units<CharT>` facet associated to `ios`. If the associated unit is named, as if

    string_type str = facet.get_unit(get_duration_style(ios), d);
    s=std::copy(str.begin(), str.end(), s);

Otherwise, format the unit as `"[Period::num/Period::den]"` followed by the unit associated to [N/D] obtained using `facet.get_n_d_unit(get_duration_style(ios), d)`.

Returns: s, iterator pointing immediately after the last character produced.

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

    namespace boost {
      namespace chrono {
        class rt_ratio;
        template <typename CharT = char>
        class duration_units;

      }
    }

##### Class `rt_ratio`

    class rt_ratio
    {
    public:
      template <typename Period>
      rt_ratio(Period const&) :
        num(Period::type::num), den(Period::type::den)
      {
      }

      rt_ratio(intmax_t n = 0, intmax_t d = 1) :
        num(n), den(d)
      {
      }

      intmax_t num;
      intmax_t den;
    };

##### Template Class `duration_units`

    template <typename CharT = char>
    class duration_units: public std::locale::facet
    {
    public:
      typedef CharT char_type; // Type of character the facet is instantiated on.
      typedef std::basic_string<CharT> string_type; // Type of character string passed to member functions.
      static std::locale::id id; // Unique identifier for this type of facet.

      explicit duration_units(size_t refs = 0);
      virtual const string_type* get_n_d_valid_units_start() const =0;
      virtual const string_type* get_n_d_valid_units_end() const=0;
      virtual const string_type* get_valid_units_start() const=0;
      virtual const string_type* get_valid_units_end() const=0;
      virtual bool match_n_d_valid_unit(const string_type* k) const = 0;
      virtual bool match_valid_unit(const string_type* k, rt_ratio& rt) const = 0;
      virtual string_type get_pattern() const=0;
      template <typename Rep, typename Period>
      string_type get_unit(duration_style style, duration<Rep, Period> const& d) const;
      template <typename Rep, typename Period>
      string_type get_n_d_unit(duration_style style, duration<Rep, Period> const& d) const;
      template <typename Period>
      bool is_named_unit() const;

    protected:
      virtual ~duration_units();
      virtual string_type do_get_n_d_unit(duration_style style, rt_ratio rt, intmax_t v) const = 0;
      virtual string_type do_get_unit(duration_style style,rt_ratio rt, intmax_t v) const = 0;
      virtual bool do_is_named_unit(rt_ratio rt) const =0;
    };

`duration_units` facet gives useful information about the duration units, as the number of plural forms, the plural form associated to a duration, the text associated to a plural form and a duration's period,

###### Constructor `duration_units()`

    explicit duration_units(size_t refs = 0);

Construct a `duration_units` facet.

Parameters:

- refs: references

Effects: Construct a `duration_units` facet. If the `refs` argument is `0` then destruction of the object is delegated to the locale, or locales, containing it. This allows the user to ignore lifetime management issues. On the other had, if `refs` is `1` then the object must be explicitly deleted; the locale will not do so. In this case, the object can be maintained across the lifetime of multiple locales.

###### Destructor `~duration_units()`

    virtual ~duration_units();

Effects: Destroys the facet.

###### Member Function `get_n_d_valid_units_start()`

    virtual const string_type* get_n_d_valid_units_start() const =0;

Returns: pointer to the start of valid [N/D] units.

###### Member Function `get_n_d_valid_units_end()`

    virtual const string_type* get_n_d_valid_units_end() const=0;

Returns: pointer to the end of valid [N/D] units.

###### Member Function `get_valid_units_start()`

    virtual const string_type* get_valid_units_start() const=0;

Returns: pointer to the start of valid units, symbol or prefix with its different plural forms.

###### Member Function `get_valid_units_end()`

    virtual const string_type* get_valid_units_end() const=0;

Returns: pointer to the end of valid units.

###### Member Function `match_n_d_valid_unit(const string_type*)`

    virtual bool match_n_d_valid_unit(const string_type* k) const = 0;

Parameters:

- k: the found pointer to the [N/D] unit.

Returns: `true` if `k` matches a valid unit.

###### Member Function `match_valid_unit(const string_type*,rt_ratio&)`

    virtual bool match_valid_unit(const string_type* k, rt_ratio& rt) const = 0;

Parameters:

- k: the found pointer to the unit.

Effects: `rt` is set to the valid Period when the `k` matches a valid unit. Returns: `true` if `k` matches a valid unit.

###### Member Function `get_pattern()`

    virtual string_type get_pattern() const=0;

Returns: the pattern to be used by default.

###### Template Member Function `get_unit(duration_style,duration<Rep,Period> const&)`

    template <typename Rep, typename Period>
    string_type get_unit(duration_style style, duration<Rep, Period> const& d) const;

Returns: `get_unit(style, d.count(), rt_ratio(Period()))`, the unit associated to this duration.

###### Template Member Function `get_n_d_unit(duration_style,duration<Rep,Period> const&)`

    template <typename Rep, typename Period>
    string_type get_n_d_unit(duration_style style, duration<Rep, Period> const& d) const;

Returns: get_n_d_unit(style, d.count(), rt_ratio(Period())), i.e. the [N/D] suffix unit associated to this duration.

###### Template Member Function `is_named_unit()`

    template <typename Period>
    bool is_named_unit() const;

Returns: `do_is_named_unit(rt_ratio(Period()))`, true if the unit associated to the given Period is named, false otherwise.

###### Protected Member Function `do_get_n_d_unit(duration_style,rt_ratio,intmax_t)`

    virtual string_type do_get_n_d_unit(duration_style style, rt_ratio rt, intmax_t v) const = 0;

Returns: the [N/D] suffix unit associated to this duration.

###### Protected Member Function `do_get_unit(duration_style,rt_ratio,intmax_t)`

    virtual string_type do_get_unit(duration_style style,rt_ratio rt, intmax_t v) const = 0;

Returns: the unit associated to this duration.

###### Protected Member Function `do_is_named_unit(rt_ratio)`

    virtual bool do_is_named_unit(rt_ratio rt) const =0;

Returns: true if the unit associated to the given Period is named, false otherwise.

##### Template Class `duration_units_default`

    template <typename CharT = char>
    class duration_units_default: public duration_units<CharT>
    {
    protected:
      static const std::size_t pfs_ = 2; // The default English facet has two plural forms.

    public:
      typedef CharT char_type;
      typedef std::basic_string<CharT> string_type;

      explicit duration_units_default(size_t refs = 0);
      ~duration_units_default();

      bool match_n_d_valid_unit(const string_type* k) const;
      bool match_valid_unit(const string_type* k, rt_ratio& rt) const;
      const string_type* get_n_d_valid_units_start()const;
      const string_type* get_n_d_valid_units_end()const;
      string_type* get_valid_units_start() const;
      string_type* get_valid_units_end() const;
      string_type get_pattern() const;
    protected:
      bool do_is_named_unit(rt_ratio rt) const;
      string_type do_get_n_d_unit(duration_style style, rt_ratio, intmax_t v) const;
      string_type do_get_unit(duration_style style, rt_ratio rt, intmax_t v) const;

      virtual std::size_t do_get_plural_forms() const;
      virtual std::size_t do_get_plural_form(int_least64_t value) const;

      virtual string_type do_get_unit(duration_style style, ratio<1> u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, ratio<60> u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, ratio<3600> u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, atto u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, femto u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, pico u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, nano u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, micro u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, milli u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, centi u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, deci u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, deca u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, hecto u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, kilo u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, mega u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, giga u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, tera u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, peta u, std::size_t pf) const;
      virtual string_type do_get_unit(duration_style style, exa u, std::size_t pf) const;

      virtual string_type do_get_ratio_prefix(duration_style style, atto u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, femto u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, pico u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, nano u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, micro u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, milli u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, centi u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, deci u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, deca u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, hecto u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, kilo u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, mega u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, giga u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, tera u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, peta u) const;
      virtual string_type do_get_ratio_prefix(duration_style style, exa u) const;
    };

This class is used to define the strings for the default English. This facet names the units associated to the following periods:

- `atto`,
- `femto`,
- `pico`,
- `nano`,
- `micro`,
- `milli`,
- `centi`,
- `deci`,
- ratio<1>,
- `deca`,
- `hecto`,
- `kilo`,
- `mega`,
- `giga`,
- `tera`,
- `peta`,
- `exa`,
- ratio<60> and
- ratio<3600>.

###### Constructor `duration_units_default()`

    explicit duration_units_default(size_t refs = 0);

Construct a duration_units_default facet.

Parameters:

- refs: references

Effects: Construct a duration_units_default facet. If the `refs` argument is `0` then destruction of the object is delegated to the locale, or locales, containing it. This allows the user to ignore lifetime management issues. On the other had, if `refs` is `1` then the object must be explicitly deleted; the locale will not do so. In this case, the object can be maintained across the lifetime of multiple locales.

###### Destructor `~duration_units_default()`

    virtual ~duration_units_default();

Effects: Destroys the facet.

###### Member Function `get_n_d_valid_units_start()`

    virtual const string_type* get_n_d_valid_units_start() const;

Returns: pointer to the start of valid [N/D] units.

###### Member Function `get_n_d_valid_units_end()`

    virtual const string_type* get_n_d_valid_units_end() const;

Returns: pointer to the end of valid [N/D] units.

###### Member Function `get_valid_units_start()`

    virtual const string_type* get_valid_units_start() const;

Returns: pointer to the start of valid units, symbol or prefix with its different plural forms.

###### Member Function `get_valid_units_end()`

    virtual const string_type* get_valid_units_end() const;

Returns: pointer to the end of valid units.

###### Member Function `match_n_d_valid_unit(const string_type*)`

    virtual bool match_n_d_valid_unit(const string_type* k) const;

Parameters:

- k: the found pointer to the [N/D] unit.

Returns: `true` if `k` matches a valid unit.

###### Member Function `match_valid_unit(const string_type*,rt_ratio&)`

    virtual bool match_valid_unit(const string_type* k, rt_ratio& rt) const;

Parameters:

- k: the found pointer to the unit.

Effects: `rt` is set to the valid Period when the `k` matches a valid unit. Returns: `true` if `k` matches a valid unit.

###### Member Function `get_pattern()`

    virtual string_type get_pattern() const;

Returns: the pattern to be used by default.

###### Protected Member Function `do_get_n_d_unit(duration_style,rt_ratio,intmax_t)`

    virtual string_type do_get_n_d_unit(duration_style style, rt_ratio rt, intmax_t v) const;

Returns: the [N/D] suffix unit associated to this duration.

###### Protected Member Function `do_get_unit(duration_style,rt_ratio,intmax_t)`

    virtual string_type do_get_unit(duration_style style,rt_ratio rt, intmax_t v) const;

Returns: the unit associated to this duration.

###### Protected Member Function `do_is_named_unit(rt_ratio)`

    virtual bool do_is_named_unit(rt_ratio rt) const;

Returns: true if the unit associated to the given Period is named, false otherwise.

###### Protected Member Function `do_get_plural_forms()`

    virtual std::size_t do_get_plural_forms() const;

Returns: the number of associated plural forms this facet manages.

###### Protected Member Function `do_get_plural_form(int_least64_t)`

    virtual std::size_t do_get_plural_form(int_least64_t value) const;

Gets the associated plural form.

Parameters:

value: the duration representation

Returns: the plural form associated to the `value` parameter. In English there are 2 plural forms

- 0 singular (-1 or 1)
- 1 plural for all others

###### Protected Member Function `do_get_unit(duration_style,ratio<1>,std::size_t)`

    virtual string_type do_get_unit(duration_style style, ratio<1> u, std::size_t pf) const;

Parameters:

- style: the duration style.
- period: the period associated to the duration hours.
- pf: the requested plural form.

Returns: if style is symbol returns "s", otherwise if pf is 0 return "second", if pf is 1 "seconds"

###### Protected Member Function `do_get_unit(duration_style style,ratio<60>,std::size_t)`

    virtual string_type do_get_unit(duration_style style, ratio<60> u, std::size_t pf) const;

Parameters:

- style: the duration style.
- period: the period associated to the duration hours.
- pf: the requested plural form.

Returns: if style is symbol returns "min", otherwise if pf is 0 return "minute", if pf is 1 "minutes"

###### Protected Member Function `do_get_unit(duration_style,ratio<3600>,std::size_t)`

    virtual string_type do_get_unit(duration_style style, ratio<3600> u, std::size_t pf) const;

Parameters:

- style: the duration style.
- period: the period associated to the duration hours.
- pf: the requested plural form.

Returns: if style is symbol returns "h", otherwise if pf is 0 return "hour", if pf is 1 "hours"

###### Protected Member Function `do_get_unit(duration_style,Period,std::size_t)`

    virtual string_type do_get_unit(duration_style style, atto u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, femto u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, pico u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, nano u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, micro u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, milli u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, centi u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, deci u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, deca u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, hecto u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, kilo u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, mega u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, giga u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, tera u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, peta u, std::size_t pf) const;
    virtual string_type do_get_unit(duration_style style, exa u, std::size_t pf) const;

Parameters:

- style: the duration style.
- u: the period tag atto.
- pf: the requested plural form.

Returns: the concatenation of the prefix associated to period `u` + the one associated to seconds.

###### Protected Member Function `do_get_ratio_prefix(duration_style, Period)`

    virtual string_type do_get_ratio_prefix(duration_style style, atto u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, femto u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, pico u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, nano u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, micro u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, milli u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, centi u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, deci u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, deca u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, hecto u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, kilo u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, mega u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, giga u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, tera u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, peta u) const;
    virtual string_type do_get_ratio_prefix(duration_style style, exa u) const;

Parameters:

- style: the duration style.
- u: the period tag atto.

Returns: depending on the value of `style` return the ratio_string symbol or prefix.

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

    namespace boost {
      namespace chrono {

        // manipulators

        std::ios_base& symbol_format(ios_base& ios);
        std::ios_base& name_format(ios_base& ios);
        class duration_fmt;
        template<class CharT, class Traits>
        std::basic_ostream<CharT, Traits>&
        operator <<(std::basic_ostream<CharT, Traits>& os, duration_fmt d);

        template<class CharT, class Traits>
        std::basic_istream<CharT, Traits>&
        operator >>(std::basic_istream<CharT, Traits>& is, duration_fmt d);

        // duration I/O

        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);

        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)

      }
    }

##### I/O Manipulators

There is a parameterized manipulator that takes the duration_style as parameter. The symbol or name format can be easily chosen by streaming a `symbol_format` or `name_format` manipulators respectively.

###### Template Class `duration_fmt`

    class duration_fmt
    {
    public:

      explicit duration_fmt(duration_style style) noexcept;

    #ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
      explicit
      operator duration_style() const noexcept;
    #endif
      duration_style get_duration_style() const noexcept;
    };

    template<class CharT, class Traits>
    std::basic_ostream<CharT, Traits>&
    operator <<(std::basic_ostream<CharT, Traits>& os, duration_fmt d);

    template<class CharT, class Traits>
    std::basic_istream<CharT, Traits>&
    operator >>(std::basic_istream<CharT, Traits>& is, duration_fmt d);

###### Constructor `duration_fmt(duration_style)`

    explicit duration_fmt(duration_style f) noexcept;

Effects: Constructs a `duration_fmt` by storing `f`.

Post Conditions: `static_cast<duration_style>(*this) == f`.

###### Member Function `operator duration_style()`

    explicit operator duration_style() const noexcept;
    duration_style get_duration_style() const noexcept;

Returns:: The stored `duration_fmt` `f`.

###### Member Function `operator <<(basic_ostream<>&, duration_fmt)`

    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& s, duration_fmt d);

Effects:: ``set_duration_style`(s, static_cast<`duration_style`>(d))))`.

Returns:: `s`.

###### Member Function `operator >>(basic_istream<>&, duration_fmt)`

    template<class CharT, class Traits>
      basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& s, duration_fmt d);

Effects:: ``set_duration_style`(s, static_cast<`duration_style`>(d))))`.

Returns:: `s`.

###### Non Member Function `symbol_format(ios_base&)`

    std::ios_base& symbol_format(ios_base& ios);

Effects:: ``set_duration_style`(s, `duration_style`::symbol)`.

Returns: `ios`

###### Non Member Function `name_format(ios_base&)`

    std::ios_base& name_format(ios_base& ios);

Effects:: ``set_duration_style`(s, `duration_style`::prefix)`.

Returns: `ios`

##### I/O Streams Operations

###### Member Function `operator <<(basic_ostream<>&, const duration<>& d)`

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` and the `duration_units` facet.

    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: Behaves as a formatted output function. After constructing a sentry object, if the sentry converts to true, calls to `facet.`put`(os,os,os.fill(),d)` where `facet` is the ``duration_put`<CharT>` facet associated to `os` or a new created instance of the default ``duration_put`<CharT>` facet.

Returns: `os`.

###### Member Function `operator <<(basic_istream<>&, const duration<>& d)`

    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: Behaves as a formatted input function. After constructing a `sentry` object, if the `sentry` converts to `true`, calls to `facet.`get`(is,std::istreambuf_iterator<CharT, Traits>(), is, err, d)` where `facet` is the ``duration_get`<CharT>` facet associated to `is` or a new created instance of the default ``duration_get`<CharT>` facet.

If any step fails, calls `os.setstate(std::ios_base::failbit | std::ios_base::badbit)`.

Returns: `is`

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

    namespace boost {
      namespace chrono {
        template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
        class time_point_get;
      }
    }

##### Template Class `time_point_get`

    template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
    class time_point_get: public std::locale::facet
    {
    public:
      typedef CharT char_type; // Type of character the facet is instantiated on.
      typedef InputIterator iter_type; // Type of iterator used to scan the character buffer.

      explicit __time_point_get_c(size_t refs = 0);

      template <class Clock, class Duration>
      iter_type __time_point_get_get(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
          time_point<Clock, Duration> &tp, const char_type *pattern, const char_type *pat_end) const;

      template <class Clock, class Duration>
      iter_type __time_point_get_get2(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
          time_point<Clock, Duration> &tp) const;

      template <typename Rep, typename Period>
      iter_type __time_point_get_get_duration(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
          duration<Rep, Period>& d) const;

      template <class Clock>
      iter_type __time_point_get_get_epoch(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err) const;

      static std::locale::id id; // Unique identifier for this type of facet.

      __time_point_get_d();
    };

`time_point_get` is used to parse a character sequence, extracting the duration and the epoch into a class `time_point`.

The pattern can contain the format specifiers `%d` and `%e` in any order.

User confirmation is required for reliable parsing of user-entered durations, but machine-generated formats can be parsed reliably. This allows parsers to be aggressive about interpreting user variations on standard formats.

If the end iterator is reached during parsing the member function sets `std::ios_base::eofbit` in `err`.

###### Constructor `time_point_get(size_t)`

    explicit time_point_get(size_t refs);

Constructs a __time_point_get facet.

Parameters:

- refs: references

Effects: Constructs a `duration_put` facet. If the `refs` argument is `0` then destruction of the object is delegated to the locale, or locales, containing it. This allows the user to ignore lifetime management issues. On the other had, if `refs` is `1` then the object must be explicitly deleted; `locale` will not do so. In this case, the object can be maintained across the lifetime of multiple locales.

###### Destructor `~time_point_get()`

    ~time_point_get();

Effects: Destroy the facet.

###### Template Member Function `get(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,time_point<Clock, Duration>&,const CharT*,const CharT*)`

    template <class Clock, class Duration>
    iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
        time_point<Clock, Duration> &tp, const char_type *pattern, const char_type *pat_end) const;

Parameters:

- s: start input stream iterator
- end: end input stream iterator
- ios: a reference to a `ios_base`
- err: the `ios_base::iostate`
- tp: the `time_point`
- pattern: begin of the formatting pattern
- pat_end: end of the formatting pattern

Requires: `[pattern,pat_end)` must be a valid range.

Effects:: The function starts by evaluating `err = std::ios_base::goodbit`. It then enters a loop, reading zero or more characters from `s` at each iteration. Unless otherwise specified below, the loop terminates when the first of the following conditions holds:

- The expression `pattern == pat_end` evaluates to `true`.
- The expression `err == std::ios_base::goodbit` evaluates to `false`.
- The expression `s == end` evaluates to `true`, in which case the function evaluates `err = std::ios_base::eofbit | std::ios_base::failbit`.
- The next element of pattern is equal to `'%'`, followed by a conversion specifier character, the functions `get_duration` or `get_epoch` are called depending on whether the format is `'d'` or `'e'`. If the number of elements in the range `[pattern,pat_end)` is not sufficient to unambiguously determine whether the conversion specification is complete and valid, the function evaluates `err |= std::ios_base::failbit`. Otherwise, the function evaluates `s = do_get(s, end, ios, err, d)`. If `err == std::ios_base::goodbit` holds after the evaluation of the expression, the function increments pattern to point just past the end of the conversion specification and continues looping.
- The expression `isspace(*pattern, ios.getloc())` evaluates to `true`, in which case the function first increments `pattern` until `pattern == pat_end || !isspace(*pattern, ios.getloc())` evaluates to `true`, then advances `s` until `s == end || !isspace(*s, ios.getloc())` is `true`, and finally resumes looping.
- The next character read from `s` matches the element pointed to by pattern in a case-insensitive comparison, in which case the function evaluates `++pattern`, `++s` and continues looping. Otherwise, the function evaluates `err = std::ios_base::failbit`.

Returns: An iterator pointing just beyond the last character that can be determined to be part of a valid time_point.

###### Template Member Function `get(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,time_point<Clock,Duration>&)`

    template <class Clock, class Duration>
    iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
        time_point<Clock, Duration> &tp) const;

Parameters:

- s: start input stream iterator
- end: end input stream iterator
- ios: a reference to a `ios_base`
- err: the `ios_base::iostate`
- tp: the `time_point`

Effects: Stores the duration pattern from the `duration_unit` facet in let say `str`. Last as if

    return get(s, end, ios, err, ios, d, str.data(), str.data() + str.size());

Returns: An iterator pointing just beyond the last character that can be determined to be part of a valid name.

###### Template Member Function `get_duration(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,duration<Rep,Period>&)`

    template <typename Rep, typename Period>
    iter_type get_duration(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
        duration<Rep, Period>& d) const;

Effects: As if

    return facet.get(s, end, ios, err, d);

where `facet` is either the `duration_get` facet associated to the `ios` or an instance of the default `duration_get` facet.

Returns: An iterator pointing just beyond the last character that can be determined to be part of a valid duration.

###### Template Member Function `get_epoch(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&)`

    template <class Clock>
    iter_type get_epoch(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err) const;

Effects: Let `facet` be the `time_point_units` facet associated to `ios` or a new instance of the default __time_point_units_default facet. Let `epoch` be the epoch string associated to the `Clock` using this facet. Scans `s` to match `epoch` or `end` is reached.

If not match before the `end` is reached `std::ios_base::failbit` is set in `err`. If `end` is reached `std::ios_base::failbit` is set in `err`.

Returns: An iterator pointing just beyond the last character that can be determined to be part of a epoch.

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

    namespace boost {
      namespace chrono {
        template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
        class time_point_put;
      }
    }

##### Template Class `time_point_put`

The __time_point_put facet provides facilities for formatted output of `time_point` values. The member function of __time_point_put take a `time_point` and format it into character string representation.

tparam ChatT a character type tparam OutputIterator a model of `OutputIterator`

    template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
    class time_point_put: public std::locale::facet
    {
    public:
      typedef CharT char_type; // Type of character the facet is instantiated on.
      typedef std::basic_string<CharT> string_type; // Type of character string passed to member functions.
      typedef OutputIterator iter_type; // Type of iterator used to write in the character buffer.

      explicit time_point_put(size_t refs = 0);
      ~time_point_put();

      template <class Clock, class Duration>
      iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp, const CharT* pattern,
          const CharT* pat_end) const;
      template <class Clock, class Duration>
      iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp) const;
      template <typename Rep, typename Period>
      iter_type put_duration(iter_type i, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;
      template <typename Clock>
      iter_type put_epoch(iter_type i, std::ios_base& os) const;

      static std::locale::id id; // Unique identifier for this type of facet.

    };

###### Constructor `time_point_get(size_t)`

    explicit time_point_put(size_t refs = 0);

Construct a time_point_put facet.

Effects: Construct a time_point_put facet. If the `refs` argument is `0` then destruction of the object is delegated to the locale, or locales, containing it. This allows the user to ignore lifetime management issues. On the other had, if `refs` is `1` then the object must be explicitly deleted; the locale will not do so. In this case, the object can be maintained across the lifetime of multiple locales.

Parameters:

- refs: references

###### Member Function `put()`

    template <class Clock, class Duration>
    iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp, const CharT* pattern,
        const CharT* pat_end) const;

Parameters:

- i: an output stream iterator
- ios: a reference to a ios_base
- fill: the character used as filler
- tp: the `time_point`
- pattern: begin of the formatting pattern
- pat_end: end of the formatting pattern

Effects: Steps through the sequence from `pattern` to `pat_end`, identifying characters that are part of a pattern sequence. Each character that is not part of a pattern sequence is written to `s` immediately, and each pattern sequence, as it is identified, results in a call to __put_duration or __put_epoch; thus, pattern elements and other characters are interleaved in the output in the order in which they appear in the pattern. Pattern sequences are identified by converting each character `c` to a `char` value as if by `ct.narrow(c,0)`, where `ct` is a reference to `ctype<charT>` obtained from `ios.getloc()`. The first character of each sequence is equal to `'%'`, followed by a pattern specifier character spec, which can be `'d'` for the duration value or `'e'` for the epoch. For each valid pattern sequence identified, calls `put_duration(s, ios, fill, tp.time_since_epoch())` or `put_epoch(s, ios)`.

Returns: An iterator pointing immediately after the last character produced.

###### Member Function `put()`

    template <class Clock, class Duration>
    iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp) const;

Parameters:

- i: an output stream iterator
- ios: a reference to a ios_base
- fill: the character used as filler
- tp: the `time_point`
- tern: begin of the formatting pattern
- pat_end: end of the formatting pattern

Effects: Stores the time_point pattern from the __time_point_unit facet in let say `str`. Last as if

    return put(s, ios, fill, tp, str.data(), str.data() + str.size());

Returns: An iterator pointing immediately after the last character produced.

###### Member Function `put_duration()`

    template <typename Rep, typename Period>
    iter_type put_duration(iter_type i, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

Parameters:

- i: an output stream iterator
- ios: a reference to a ios_base
- fill: the character used as filler
- d: the `duration`

Effects: As if `facet.put(s, ios, fill, d)` where facet is the ``duration_put`<CharT>` facet associated to the `ios` or a new instance of ``duration_put`<CharT>`.

Returns: An iterator pointing immediately after the last character produced.

###### Member Function `put_epoch()`

    template <typename Clock>
    iter_type put_epoch(iter_type i, std::ios_base& os) const;

Parameters:

- i: an output stream iterator
- ios: a reference to a ios_base

Effects: As if

    string_type str = facet.template get_epoch<Clock>();
    s=std::copy(str.begin(), str.end(), s);

where facet is the ``time_point_units`<CharT>` facet associated to the `ios` or a new instance of `__time_point_units_default<CharT>`.

Returns: s, iterator pointing immediately after the last character produced.

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

    namespace boost {
      namespace chrono {
        template <typename CharT, typename Clock, typename TPUFacet>
        std::basic_string<CharT> get_epoch_custom(Clock, TPUFacet& f);
        template <typename CharT=char>
        class time_point_units;
        template <typename CharT=char>
        class time_point_units_default,
      }
    }

##### Template Function `get_epoch_custom`

    template <typename CharT, typename Clock, typename TPUFacet>
    std::basic_string<CharT> get_epoch_custom(Clock, TPUFacet& f);

Customization point to the epoch associated to the clock `Clock` The default calls `f.do_get_epoch(Clock())`.

The user can overload this function.

Returns: Forwards the call to the facet as if

    return f.do_get_epoch(Clock());

##### Template Class `time_point_units`

`time_point_units` facet gives useful information about the time_point pattern, the text associated to a time_point's epoch,

      template <typename CharT=char>
      class time_point_units: public std::locale::facet
      {
      public:
        typedef CharT char_type; // Type of character the facet is instantiated on.
        typedef std::basic_string<char_type> string_type; // Type of character string used by member functions.
        static std::locale::id id; // Unique identifier for this type of facet.

        explicit time_point_units(size_t refs = 0);

        virtual string_type get_pattern() const =0;
        template <typename Clock>
        string_type get_epoch() const;

      protected:
        virtual ~time_point_units();
        virtual string_type do_get_epoch(system_clock) const=0;
        virtual string_type do_get_epoch(steady_clock) const=0;

    #if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
        virtual string_type do_get_epoch(process_real_cpu_clock) const=0;
        virtual string_type do_get_epoch(process_user_cpu_clock) const=0;
        virtual string_type do_get_epoch(process_system_cpu_clock) const=0;
        virtual string_type do_get_epoch(process_cpu_clock) const=0;
    #endif
    #if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
        virtual string_type do_get_epoch(thread_clock) const=0;
    #endif

      };

###### Constructor `time_point_units()`

    explicit time_point_units(size_t refs = 0);

Construct a `time_point_units` facet.

Parameters:

- refs: references

Effects: Construct a `time_point_units` facet. If the `refs` argument is `0` then destruction of the object is delegated to the locale, or locales, containing it. This allows the user to ignore lifetime management issues. On the other had, if `refsv is` 1` then the object must be explicitly deleted; the locale will not do so. In this case, the object can be maintained across the lifetime of multiple locales.

###### Member Function `get_pattern()`

    virtual string_type get_pattern() const =0;

Returns: the pattern to be used by default.

###### Member Function `get_epoch()`

    template <typename Clock>
    string_type get_epoch() const;

Returns: the epoch associated to the clock `Clock` as if `return get_epoch_custom<CharT>(Clock(), *this);`

###### Destructor `time_point_units()`

    virtual ~time_point_units();

Destroy the facet.

###### Member Function `do_get_epoch(system_clock)`

    virtual string_type do_get_epoch(system_clock) const=0;

Parameters:

- c: a dummy instance of `system_clock`.

Returns: The epoch string associated to the `system_clock`.

###### Member Function `do_get_epoch(steady_clock)`

    virtual string_type do_get_epoch(steady_clock) const=0;

Parameters:

- c: a dummy instance of `steady_clock`.

Returns: The epoch string associated to the `steady_clock`.

###### Member Function `do_get_epoch(process_real_cpu_clock)`

    #if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
        virtual string_type do_get_epoch(process_real_cpu_clock) const=0;
    #endif

Parameters:

- c: a dummy instance of `process_real_cpu_clock`.

Returns: The epoch string associated to the `process_real_cpu_clock`.

###### Member Function `do_get_epoch(process_user_cpu_clock)`

    #if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
        virtual string_type do_get_epoch(process_user_cpu_clock) const=0;
    #endif

Parameters:

- c: a dummy instance of `process_real_cpu_clock`.

Returns: The epoch string associated to the process_user_cpu_clock.

###### Member Function `do_get_epoch(process_system_cpu_clock)`

    #if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
        virtual string_type do_get_epoch(process_system_cpu_clock) const=0;
    #endif

Parameters:

- c: a dummy instance of `process_system_cpu_clock`.

Returns: The epoch string associated to the process_user_cpu_clock.

###### Member Function `do_get_epoch(process_cpu_clock)`

    #if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
        virtual string_type do_get_epoch(process_cpu_clock) const=0;
    #endif

Parameters:

- c: a dummy instance of `process_cpu_clock`.

Returns: The epoch string associated to the process_cpu_clock.

###### Member Function `do_get_epoch(thread_clock)`

    #if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
        virtual string_type do_get_epoch(thread_clock) const=0;
    #endif

Parameters:

- c: a dummy instance of `thread_clock`.

Returns: The epoch string associated to the `thread_clock`.

##### Template Class `time_point_units_default`

      // This class is used to define the strings for the default English
      template <typename CharT=char>
      class time_point_units_default: public time_point_units<CharT>
      {
      public:
        typedef CharT char_type; // Type of character the facet is instantiated on.
        typedef std::basic_string<char_type> string_type; // Type of character string used by member functions.

        explicit time_point_units_default(size_t refs = 0);
        ~time_point_units_default();

        /**
         * __returns the default pattern "%d%e".
         */
        string_type get_pattern() const;

      protected:
        /**
         * [param c a dummy instance of __system_clock.
         * __returns The epoch string returned by `clock_string<system_clock,CharT>::since()`.
         */
        string_type do_get_epoch(system_clock ) const;
        /**
         * [param c a dummy instance of __steady_clock.
         * __returns The epoch string returned by `clock_string<steady_clock,CharT>::since()`.
         */
        string_type do_get_epoch(steady_clock ) const;
    #if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
        /**
         * [param c a dummy instance of __process_real_cpu_clock.
         * __returns The epoch string returned by `clock_string<process_real_cpu_clock,CharT>::since()`.
         */
        string_type do_get_epoch(process_real_cpu_clock ) const;
        /**
         * [param c a dummy instance of __process_user_cpu_clock.
         * __returns The epoch string returned by `clock_string<process_user_cpu_clock,CharT>::since()`.
         */
        string_type do_get_epoch(process_user_cpu_clock ) const;
        /**
         * [param c a dummy instance of __process_system_cpu_clock.
         * __returns The epoch string returned by `clock_string<process_system_cpu_clock,CharT>::since()`.
         */
        string_type do_get_epoch(process_system_cpu_clock ) const;
        /**
         * [param c a dummy instance of __process_cpu_clock.
         * __returns The epoch string returned by `clock_string<process_cpu_clock,CharT>::since()`.
         */
        string_type do_get_epoch(process_cpu_clock ) const;

    #endif
    #if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
        /**
         * [param c a dummy instance of __thread_clock.
         * __returns The epoch string returned by `clock_string<thread_clock,CharT>::since()`.
         */
        string_type do_get_epoch(thread_clock ) const;
    #endif

      };

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

    namespace boost {
    namespace chrono {

        // manipulators

        unspecified time_fmt(timezone tz);
        template<class CharT>
        unspecified time_fmt(timezone tz, basic_string<CharT> f);
        template<class CharT>
        unspecified time_fmt(timezone tz, const CharT* f);

        // i/o state savers

        template<typename CharT = char, typename Traits = std::char_traits<CharT> >
        struct timezone_io_saver
        {
          typedef std::basic_ios<CharT, Traits> state_type;
          typedef timezone aspect_type;

          explicit timezone_io_saver(state_type &s);
          timezone_io_saver(state_type &s, aspect_type new_value);
          ~timezone_io_saver();
          void timezone_io_saver__restore();
        };

        template<typename CharT = char, typename Traits = std::char_traits<CharT> >
        struct time_fmt_io_saver
        {
          typedef std::basic_ios<CharT, Traits> state_type;

          explicit time_fmt_io_saver(state_type &s);
          time_fmt_io_saver(state_type &s, basic_string<CharT> const& new_value);
          ~ time_fmt_io_saver();
          void restore();
        };

        // system_clock I/O

        template <class CharT, class Traits, class Duration>
          basic_ostream<CharT, Traits>&
          operator<<(basic_ostream<CharT, Traits>& os,
                     const time_point<system_clock, Duration>& tp);

        template <class CharT, class Traits, class Duration>
          basic_istream<CharT, Traits>&
          operator>>(basic_istream<CharT, Traits>& is,
                     time_point<system_clock, Duration>& tp);

        // Other Clocks I/O

        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);

        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);

    }
    }

##### I/O Manipulators

###### Non Member Function time_fmt(`timezone`)

    unspecified time_fmt(timezone tz);

Returns:: An unspecified object that when streamed to a `basic_ostream<CharT, Traits>` or `basic_istream<CharT, Traits>` `s` will have the effects of:

    set_timezone(s, tz);

###### Non Member Function time_fmt(`timezone`, string)

    template<class CharT>
      unspecified time_fmt(timezone tz, basic_string<CharT> f);
    template<class CharT>
      unspecified time_fmt(timezone tz, const CharT* f);

Returns:: An unspecified object that when streamed to a `basic_ostream<CharT, Traits>` or `basic_istream<CharT, Traits>` `s` will have the effects of:

    set_timezone(s, tz);
    set_time_fmt<CharT>(s, f);

##### I/O Streams Operations

###### `system_clock`

###### Non Member Function `operator<<()`

    template <class CharT, class Traits, class Duration>
        std::basic_ostream<CharT, Traits>&
        operator<<(std::basic_ostream<CharT, Traits>& os,
               const time_point<system_clock, Duration>& tp);

Effects: Behaves as a formatted output function. After constructing a `sentry` object, if the `sentry` converts to `true`, sets a local variable `tz` of type `timezone` to `get_timezone(os)`. Additionally the format string obtained with ``get_time_fmt`()` is recorded as a pair of `const CharT*`. If the stream has no time_punct facet, then this pair of `const CharT*` that represent an empty range.

Next `tp` is converted to a `time_t`, and this `time_t` is converted to a `tm`. The conversion to `tm` use `gmtime` (when available) if the timezone is `utc`, else it use localtime (if available).

Using the `std::time_put` facet stored in `os`, this inserter writes characters to the stream using the `tm` and the formatting string stored in the `time_punct` facet, unless that facet was missing, or unless it provided an empty string.

If the formatting string is empty, then output as follows:

First output `tm` using `"%F %H:%M:"`

Next output a `double` representing the number of seconds stored in the `tm` plus the fractional seconds represented in `tp`. The format shall be `ios::fixed` and the precision shall be sufficient to represent `system_clock::duration` exactly (e.g. if `system_clock::period` is micro, the precision should be sufficient to output six digits following the decimal point). If the number of seconds is less than `10`, the output shall be prefixed by `'0'`.

Finally if `tz` is `local`, output the `tm` using the pattern " %z". Else append the sequence " +0000" to the stream.

If any step fails, calls `os.setstate(ios_base::failbit | ios_base::badbit)`.

Returns: `os`

###### Non Member Function `operator>>()`

    template <class CharT, class Traits, class Duration>
        std::basic_istream<CharT, Traits>&
        operator>>(std::basic_istream<CharT, Traits>& is,
               time_point<system_clock, Duration>& tp);

Effects: Behaves as a formatted input function. After constructing a sentry object, if the sentry converts to true, obtains a `std::time_get` facet from `is`, and obtains a formatting string in the same manner as described for insertion operator. Extract a `tm` using the supplied formatting string, or if empty, defaulted as described for the insertion operator. Note that extraction does not use the `timezone` data stored in the `is` for the defaulted string as the `timezone` information is stored in the stream.

Any `time_point<system_clock, `Duration`>` inserted, and then extracted should result in an equal `time_point<system_clock, `Duration`>`, excepting any precision that did not get inserted.

Example:

    void test(std::chrono::system_clock::time_point tp)
    {
        std::stringstream s;
        s << tp;
        boost::chrono::system_clock::time_point tp2;
        s >> tp2;
        assert(tp == tp2);
    }

Returns: is

###### Other Clocks

###### Non Member Function `operator<<()`

    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: Behaves as a formatted output function. After constructing a `sentry` object, if the `sentry` converts to `true`, calls to `facet.put(os,os,os.fill(),tp)` where `facet` is the `time_point_put<CharT>` facet associated to `os` or a new created instance of the default `time_point_put<CharT>` facet.

Returns: `os`.

Example:

    22644271279698 nanoseconds since boot

###### Non Member Function `operator>>()`

    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);

Extracts `tp` from the stream `is`.

Effects: Behaves as a formatted input function. After constructing a `sentry` object, if the `sentry` converts to `true`, calls to `facet.get(is,std::istreambuf_iterator<CharT, Traits>(), is, err, tp)` where `facet` is the `time_point_get<CharT>` facet associated to `is` or a new created instance of the default `time_point_get<CharT>` facet.

If any step fails, calls `os.setstate(std::ios_base::failbit | std::ios_base::badbit)`.

Returns: `is`.

### Chrono Rounding Utilities

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

    namespace boost { namespace chrono {
      template <class To, class Rep, class Period>
      To floor(const duration<Rep, Period>& d);
    } }

This function round down the given parameter.

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

    namespace boost { namespace chrono {
      template <class To, class Rep, class Period>
      To round(const duration<Rep, Period>& d);
    } }

This function round to nearest, to even on tie the given parameter.

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

    namespace boost { namespace chrono {
      template <class To, class Rep, class Period>
      To ceil(const duration<Rep, Period>& d);
    } }

This function round up the given parameter.

### Other Clocks

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

Knowing how long a program takes to execute is useful in both test and production environments. 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 don't include the time spent by the child process.

    #define BOOST_CHRONO_HAS_PROCESS_CLOCKS

    namespace boost { namespace chrono {

        class process_real_cpu_clock;
        class process_user_cpu_clock;
        class process_system_cpu_clock;
        class process_cpu_clock;

        template <typename Rep>
        struct process_times;
        template <class CharT, class Traits, class Rep>
        std::basic_ostream<CharT, Traits>&
        operator<<(std::basic_ostream<CharT, Traits>& os,
                process_times<Rep> const& rhs);

        template <class CharT, class Traits, class Rep>
        std::basic_istream<CharT, Traits>&
        operator>>(std::basic_istream<CharT, Traits>& is,
                process_times<Rep> const& rhs);

        template <class Rep>
        struct duration_values<process_times<Rep> >;

        template <class CharT>
        struct clock_string<process_real_cpu_clock, CharT>;
        struct clock_string<process_user_cpu_clock, CharT>;
        struct clock_string<process_system_cpu_clock, CharT>;
        struct clock_string<process_cpu_clock, CharT>;

    } }
    namespace std {
        template <class Rep>
        class numeric_limits<boost::chrono::process_times<Rep> >;
    }

##### Macro `BOOST_CHRONO_HAS_PROCESS_CLOCKS`

This macro is defined if the platform supports process clocks.

##### Class `process_real_cpu_clock`

`process_real_cpu_clock` satisfy the `Clock` requirements.

`process_real_cpu_clock` class provides access to the real process wall-clock steady clock, i.e. the real CPU-time clock of the calling process. The process relative current time can be obtained by calling `process_real_cpu_clock::now()`.

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

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

##### Class `process_user_cpu_clock`

`process_user_cpu_clock` satisfy the `Clock` requirements.

`process_user_cpu_clock` class provides access to the user CPU-time steady clock of the calling process. The process relative user current time can be obtained by calling `process_user_cpu_clock::now()`.

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

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

##### Class `process_system_cpu_clock`

`process_system_cpu_clock` satisfy the `Clock` requirements.

`process_system_cpu_clock` class provides access to the system CPU-time steady clock of the calling process. The process relative system current time can be obtained by calling `process_system_cpu_clock::now()`.

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

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

##### Class `process_cpu_clock`

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

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

    class process_cpu_clock
    {
    public:
        typedef process_times<nanoseconds::rep> times ;

        typedef duration<times,  nano>                  duration;
        typedef duration::rep                           rep;
        typedef duration::period                        period;
        typedef chrono::time_point<process_cpu_clock>   time_point;
        static constexpr bool is_steady =               true;

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

##### Template Class `process_times`

This class is the representation of the `process_cpu_clock::duration` class. As such it needs to implements the arithmetic operators.

    template <typename Rep>
    struct process_times : arithmetic<process_times<Rep>,
        multiplicative<process_times<Rep>, Rep,
        less_than_comparable<process_times<Rep> > > >
    {
        Rep real;    // real (i.e wall clock) time
        Rep user;    // user cpu time
        Rep system;  // system cpu time

        times();
        times(
            process_real_cpu_clock::rep r,
            process_user_cpu_clock::rep u,
            process_system_cpu_clock::rep s);

        template <typename Rep2>
        explicit process_times(
            Rep2 r);
        template <typename Rep2>
        explicit process_times(
            process_times<Rep2> const& rhs);
        operator rep() const;

        bool operator==(process_times const& rhs);
        template <typename Rep2>
        bool operator==(process_times<Rep2> const& rhs);

        times operator+=(process_times const& rhs);
        times operator-=(process_times const& rhs);
        times operator*=(process_times const& rhs);
        times operator/=(process_times const& rhs);
        bool operator<(process_times const & rhs) const;
    };

##### `process_times` Input/Output

    template <class CharT, class Traits, class Rep>
    std::basic_ostream<CharT, Traits>&
    operator<<(std::basic_ostream<CharT, Traits>& os,
            process_times<Rep> const& rhs);

Effects: Output each part separated by ';' and surrounded by '{', '}'.

Throws: None.

    template <class CharT, class Traits, class Rep>
    std::basic_istream<CharT, Traits>&
    operator>>(std::basic_istream<CharT, Traits>& is,
            process_times<Rep> const& rhs);

Effects: overrides the value of rhs if the input stream has the format "{r;u;s}". Otherwise, set the input stream state as failbit | eofbit.

Throws: None.

##### `duration_values` Specialization for `process_times<>`

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

The `times` specific functions `zero()`, `max()` and `min()` uses the relative functions on the representation of each component.

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

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

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

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

##### `numeric_limits` Specialization for `process_times<>`

    namespace std {
        template <>
        class numeric_limits<boost::chrono::process_times<Rep>> {
            typedef boost::chrono::process_times<Rep> Res;

        public:
            static const bool is_specialized = true;
            static Res min();
            static Res max();
            static Res lowest();
            static const int digits;
            static const int digits10;
            static const bool is_signed = false;
            static const bool is_integer = true;
            static const bool is_exact = true;
            static const int radix = 0;
        };
    }

The `process_times<Rep>` specialization functions `min()`, `max()` and `lowest()` uses the relative functions on the representation of each component.

Notes

- `min()` returns the tuple of mins.
- `max()` returns the tuple of maxs.
- `lowest()` returns the tuple of lowests.
- `digits` is the sum of (binary) digits.
- `digits10` is the sum of digits10s.

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

Knowing the time a thread takes to execute is useful in both test and production environments.

    #define BOOST_CHRONO_HAS_THREAD_CLOCK
    #define BOOST_CHRONO_THREAD_CLOCK_IS_STEADY
    namespace boost { namespace chrono {

        class thread_clock;
        template <class CharT>
        struct clock_string<thread_clock, CharT>;

    } }

##### Macro `BOOST_CHRONO_HAS_THREAD_CLOCK`

This macro is defined if the platform supports thread clocks.

##### Macro `BOOST_CHRONO_THREAD_CLOCK_IS_STEADY`

This macro is defined if the platform has a thread clock. Its value is true if it is steady and false otherwise.

##### Class `thread_clock`

`thread_clock` satisfy the `Clock` requirements.

`thread_clock` class provides access to the real thread wall-clock, i.e. the real CPU-time clock of the calling thread. The thread relative current time can be obtained by calling `thread_clock::now()`.

    class thread_clock {
    public:
        typedef nanoseconds                          duration;
        typedef duration::rep                        rep;
        typedef duration::period                     period;
        typedef chrono::time_point<thread_clock>     time_point;
        static constexpr bool is_steady =            BOOST_CHRONO_THREAD_CLOCK_IS_STEADY;

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

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