| Home | Libraries | People | FAQ | More

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