![]() |
Home | Libraries | People | FAQ | More |
<boost/chrono/chrono_io.hpp>
<boost/chrono/io/duration_style.hpp>
<boost/chrono/io/timezone.hpp>
<boost/chrono/io/ios_base_state.hpp>
<boost/chrono/io/duration_get.hpp>
<boost/chrono/io/duration_put.hpp>
<boost/chrono/io/duration_units.hpp>
<boost/chrono/io/duration_io.hpp>
<boost/chrono/io/time_point_get.hpp>
<boost/chrono/io/time_point_put.hpp>
<boost/chrono/io/time_point_units.hpp>
<boost/chrono/io/time_point_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>
namespace boost { namespace chrono { // typedefs enum classduration_style
{prefix
,symbol
}; } }
enum class duration_style { prefix, symbol };
duration
unit names come in
two varieties: prefix and symbol.
namespace boost { namespace chrono { structtimezone
{ enum type {utc
,local
}; }; } }
enum class timezone { utc, local };
namespace boost { namespace chrono { // setters and getters duration_styleget_duration_style
(std::ios_base & ios); voidset_duration_style
(std::ios_base& ios, duration_style style); timezoneget_timezone
(std::ios_base & ios); voidset_timezone
(std::ios_base& ios, timezone tz); template<typename CharT> std::basic_string<CharT>get_time_fmt
(std::ios_base & ios); template<typename CharT> voidset_time_fmt
(std::ios_base& ios, std::basic_string<CharT> const& fmt); // i/o state savers structduration_style_io_saver
; template<typename CharT = char, typename Traits = std::char_traits<CharT> > structtimezone_io_saver
; template<typename CharT = char, typename Traits = std::char_traits<CharT> > structtime_fmt_io_saver
; } }
get_duration_style(std::ios_base
&)
set_duration_style(std::ios_base
&,duration_style)
get_timezone(std::ios_base&)
set_timezone(std::ios_base&,duration_style)
get_time_fmt(std::ios_base
&)
set_time_fmt(std::ios_base&, std::basic_string<CharT> const&)
duration_style get_duration_style(std::ios_base & ios);
Returns: The stream's duration_style
attribute associated
to ios
.
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.
timezone get_timezone(std::ios_base & ios);
Returns: The stream's timezone
attribute associated
to ios
.
void set_timezone(std::ios_base& ios, timezone tz);
Effects: Set the stream's timezone
attribute associated
to ios
with the tz
parameter.
template<typename CharT> std::basic_string<CharT> get_time_fmt(std::ios_base & ios);
Returns: The stream's time format
attribute associated to ios
.
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 |
. |
|
The day of the week, using the locale's weekday names; either the abbreviated or full name may be specified. |
"Monday". |
|
The month, using the locale's month names; either the abbreviated or full name may be specified. |
"February". |
|
Not supported. |
. |
|
The day of the month |
. |
|
The date as |
. |
|
The date as |
. |
|
The hour (24-hour clock) |
. |
|
The hour (12-hour clock) |
. |
|
The day number of the year |
"060" => Feb-29. |
|
The month number |
"01" => January. |
|
The minute |
. |
|
Any white space.. |
. |
|
Not supported. |
. |
|
Not supported. |
. |
|
The time as |
. |
|
The seconds |
. |
|
The time as |
. |
|
Not supported. |
. |
|
The weekday as a decimal number |
"0" => Sunday. |
|
Not supported. |
. |
|
The date, using the locale's date format.. |
. |
|
Not supported. |
. |
|
Not supported. |
"2005". |
|
The year, including the century (for example, 1988). |
. |
// i/o state savers struct duration_style_io_saver { typedef std::ios_base state_type; // the state type is ios_base typedefduration_style
aspect_type; // the aspect type is the __duration_style explicitduration_style_io_saver
(state_type &s);duration_style_io_saver
(state_type &s, aspect_type new_value);~duration_style_io_saver
(); voidrestore
(); };
The state_type
is a
version of the IOStreams base class std::ios_base
.
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
.
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
.
The destructor restores the stream's attribute to the saved value.
~duration_style_io_saver();
Effects: As if 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<typename CharT = char, typename Traits = std::char_traits<CharT> > structtimezone_io_saver
{ typedef std::basic_ios<CharT, Traits> state_type; typedeftimezone
aspect_type; explicittimezone_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.
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
.
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
.
The destructor restores the stream's attribute to the saved value.
~timezone_io_saver();
Effects: As if 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<typename CharT = char, typename Traits = std::char_traits<CharT> > structtime_fmt_io_saver
{ typedef std::basic_ios<CharT, Traits> state_type; explicittime_fmt_io_saver
(state_type &s);time_fmt_io_saver
(state_type &s, basic_string<CharT> const& new_value);~time_fmt_io_saver
(); voidrestore
(); };
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.
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
.
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
.
The destructor restores the stream's attribute to the saved value.
~time_fmt_io_saver();
Effects: As if 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.
namespace boost {
namespace chrono {
template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
class duration_get
;
}
}
duration_get(size_t)
~duration_get()
get(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,duration<Rep,Period>&,const char_type*, const char_type*)
const
get(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,duration<Rep,Period>&)
const
get_value(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,Rep&) const
get_unit(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,rt_ratio&)
const
do_get_n_d_prefix_unit(duration_units<CharT> const&,iter_type,iter_type,std::ios_base&,std::ios_base::iostate&) const
do_get_prefix_unit(duration_units<CharT> const&,iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,detail::rt_ratio&) const
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. explicitduration_get
(size_t refs = 0); template <typename Rep, typename Period> iter_typeget
( 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_typeget
( iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err, duration<Rep, Period>& d ) const; template <typename Rep> iter_typeget_value
( iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err, Rep& r ) const; iter_typeget_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.
explicit duration_get(size_t refs);
Constructs a duration_get
facet.
Parameters:
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.
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:
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:
Rep
is a floating
point type, the intermediate representation is long
double
.
Rep
is
a signed integral type, the intermediate representation is long long
.
Rep
is
an unsigned integral type, the intermediate representation is unsigned
long long.
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:
pattern
== pat_end
evaluates to true
.
err == std::ios_base::goodbit
evaluates to false.
s == end
evaluates to true
,
in which case the function evaluates err
= std::ios_base::eofbit
| std::ios_base::failbit
.
'%'
,
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.
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.
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 <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:
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 <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:
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.
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:
Effects:
'['
,
an attempt is made to consume a pattern of the form "[N/D]"
where N
and D
have type unsigned long long
.
N
and D
, otherwise
evaluates err = std::ios_base::failbit
and return i
.
"[N/D]"
, as if
return do_get_n_d_prefix_unit(facet, i, e, is, err);
'['
.
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.
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:
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.
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:
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.
namespace boost {
namespace chrono {
template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
class duration_put
;
}
}
duration_put(size_t)
~duration_put()
put(iter_type,std::ios_base&,char_type,duration<Rep,Period>
const&,
const CharT*,const CharT*)
put(iter_type,std::ios_base&,char_type fill, duration<Rep, Period> const&)
put_value(iter_type,
std::ios_base&,
char_type,
duration<Rep,Period>
const&)
put_unit(iter_type,std::ios_base&,char_type,duration<Rep, Period>
const&)
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. explicitduration_put
(size_t refs = 0); template <typename Rep, typename Period> iter_typeput
(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_typeput
(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const; template <typename Rep, typename Period> iter_typeput_value
(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const; template <typename Rep, typename Period> iter_typeput_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
(); };
explicit duration_put(size_t refs);
Constructs a duration_put
facet.
Parameters:
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.
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:
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.
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:
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.
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:
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.
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:
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.
namespace boost { namespace chrono { class rt_ratio; template <typename CharT = char> class duration_units; } }
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; };
duration_units()
~duration_units()
get_n_d_valid_units_start()
get_n_d_valid_units_end()
get_valid_units_start()
get_valid_units_end()
match_n_d_valid_unit(const string_type*)
match_valid_unit(const string_type*,rt_ratio&)
get_pattern()
get_unit(duration_style,duration<Rep,Period> const&)
get_n_d_unit(duration_style,duration<Rep,Period> const&)
is_named_unit()
do_get_n_d_unit(duration_style,rt_ratio,intmax_t)
do_get_unit(duration_style,rt_ratio,intmax_t)
do_is_named_unit(rt_ratio)
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. explicitduration_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 boolmatch_n_d_valid_unit
(const string_type* k) const = 0; virtual boolmatch_valid_unit
(const string_type* k, rt_ratio& rt) const = 0; virtual string_typeget_pattern
() const=0; template <typename Rep, typename Period> string_typeget_unit
(duration_style style, duration<Rep, Period> const& d) const; template <typename Rep, typename Period> string_typeget_n_d_unit
(duration_style style, duration<Rep, Period> const& d) const; template <typename Period> boolis_named_unit
() const; protected: virtual~duration_units
(); virtual string_typedo_get_n_d_unit
(duration_style style, rt_ratio rt, intmax_t v) const = 0; virtual string_typedo_get_unit
(duration_style style,rt_ratio rt, intmax_t v) const = 0; virtual booldo_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,
explicit duration_units(size_t refs = 0);
Construct a duration_units
facet.
Parameters:
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.
virtual const string_type* get_n_d_valid_units_start() const =0;
Returns: pointer to the start of valid [N/D] units.
virtual const string_type* get_n_d_valid_units_end() const=0;
Returns: pointer to the end of valid [N/D] units.
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.
virtual const string_type* get_valid_units_end() const=0;
Returns: pointer to the end of valid units.
virtual bool match_n_d_valid_unit(const string_type* k) const = 0;
Parameters:
Returns: true
if k
matches a valid
unit.
virtual bool match_valid_unit(const string_type* k, rt_ratio& rt) const = 0;
Parameters:
Effects: rt
is set to the valid Period when the k
matches a valid unit. Returns: true
if k
matches a valid unit.
virtual string_type get_pattern() const=0;
Returns: the pattern to be used by default.
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 <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 <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.
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.
virtual string_type do_get_unit(duration_style style,rt_ratio rt, intmax_t v) const = 0;
Returns: the unit associated to this duration.
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.
duration_units_default()
~duration_units_default()
get_n_d_valid_units_start()
get_n_d_valid_units_end()
get_valid_units_start()
get_valid_units_end()
match_n_d_valid_unit(const string_type*)
match_valid_unit(const string_type*,rt_ratio&)
get_pattern()
do_get_n_d_unit(duration_style,rt_ratio,intmax_t)
do_get_unit(duration_style,rt_ratio,intmax_t)
do_is_named_unit(rt_ratio)
do_get_plural_forms()
do_get_plural_form(int_least64_t)
do_get_unit(duration_style,ratio<1>,std::size_t)
do_get_unit(duration_style
style,ratio<60>,std::size_t)
do_get_unit(duration_style,ratio<3600>,std::size_t)
do_get_unit(duration_style,Period,std::size_t)
do_get_ratio_prefix(duration_style, Period)
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
,
deca
,
hecto
,
kilo
,
mega
,
giga
,
tera
,
peta
,
exa
,
explicit duration_units_default(size_t refs = 0);
Construct a duration_units_default facet.
Parameters:
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.
virtual ~duration_units_default();
Effects: Destroys the facet.
virtual const string_type* get_n_d_valid_units_start() const;
Returns: pointer to the start of valid [N/D] units.
virtual const string_type* get_n_d_valid_units_end() const;
Returns: pointer to the end of valid [N/D] units.
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.
virtual const string_type* get_valid_units_end() const;
Returns: pointer to the end of valid units.
virtual bool match_n_d_valid_unit(const string_type* k) const;
Parameters:
Returns: true
if k
matches a valid
unit.
virtual bool match_valid_unit(const string_type* k, rt_ratio& rt) const;
Parameters:
Effects: rt
is set to the valid Period when the k
matches a valid unit. Returns: true
if k
matches a valid unit.
virtual string_type get_pattern() const;
Returns: the pattern to be used by default.
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.
virtual string_type do_get_unit(duration_style style,rt_ratio rt, intmax_t v) const;
Returns: the unit associated to this duration.
virtual bool do_is_named_unit(rt_ratio rt) const;
Returns: true if the unit associated to the given Period is named, false otherwise.
virtual std::size_t do_get_plural_forms() const;
Returns: the number of associated plural forms this facet manages.
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
virtual string_type do_get_unit(duration_style style, ratio<1> u, std::size_t pf) const;
Parameters:
Returns: if style is symbol returns "s", otherwise if pf is 0 return "second", if pf is 1 "seconds"
virtual string_type do_get_unit(duration_style style, ratio<60> u, std::size_t pf) const;
Parameters:
Returns: if style is symbol returns "min", otherwise if pf is 0 return "minute", if pf is 1 "minutes"
virtual string_type do_get_unit(duration_style style, ratio<3600> u, std::size_t pf) const;
Parameters:
Returns: if style is symbol returns "h", otherwise if pf is 0 return "hour", if pf is 1 "hours"
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:
Returns: the concatenation of the
prefix associated to period u
+ the one associated to seconds.
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:
Returns: depending on the value of
style
return the ratio_string
symbol or prefix.
namespace boost { namespace chrono { // manipulators std::ios_base&symbol_format
(ios_base& ios); std::ios_base&name_format
(ios_base& ios); classduration_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, constduration
<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) } }
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.
class duration_fmt { public: explicitduration_fmt
(duration_style
style) noexcept; #ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS explicitoperator duration_style
() const noexcept; #endifduration_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);
explicit duration_fmt(duration_style f) noexcept;
Effects: Constructs a duration_fmt
by storing
f
.
Post Conditions: static_cast<duration_style>(*this) == f
.
explicit operator duration_style() const noexcept; duration_style get_duration_style() const noexcept;
Returns:: The stored duration_fmt
f
.
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
.
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
.
std::ios_base& symbol_format
(ios_base& ios);
Effects::
.
set_duration_style
(s, duration_style
::symbol)
Returns: ios
std::ios_base& name_format
(ios_base& ios);
Effects::
.
set_duration_style
(s, duration_style
::prefix)
Returns: ios
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.
where put
(os,os,os.fill(),d)facet
is the
facet associated to duration_put
<CharT>os
or a new created instance of the default
facet.
duration_put
<CharT>
Returns: os
.
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.
where get
(is,std::istreambuf_iterator<CharT,
Traits>(),
is,
err,
d)facet
is the
facet associated to duration_get
<CharT>is
or a new created instance of the default
facet.
duration_get
<CharT>
If any step fails, calls os.setstate(std::ios_base::failbit
| std::ios_base::badbit)
.
Returns: is
namespace boost { namespace chrono { template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> > class time_point_get; } }
time_point_get(size_t)
~time_point_get()
get(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,time_point<Clock, Duration>&,const CharT*,const CharT*)
get(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,time_point<Clock,Duration>&)
get_duration(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&,duration<Rep,Period>&)
get_epoch(iter_type,iter_type,std::ios_base&,std::ios_base::iostate&)
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
.
explicit time_point_get(size_t refs);
Constructs a __time_point_get facet.
Parameters:
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.
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:
ios_base
ios_base::iostate
time_point
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:
pattern
== pat_end
evaluates to true
.
err == std::ios_base::goodbit
evaluates to false
.
s == end
evaluates to true
,
in which case the function evaluates err
= std::ios_base::eofbit
| std::ios_base::failbit
.
'%'
,
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.
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.
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 <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:
ios_base
ios_base::iostate
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 <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 <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.
namespace boost { namespace chrono { template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> > 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. };
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:
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:
time_point
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.
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:
time_point
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.
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:
duration
Effects: As if facet.put(s, ios, fill, d)
where facet is the
facet associated to the duration_put
<CharT>ios
or a new instance of
.
duration_put
<CharT>
Returns: An iterator pointing immediately after the last character produced.
template <typename Clock> iter_type put_epoch(iter_type i, std::ios_base& os) const;
Parameters:
Effects: As if
string_type str = facet.template get_epoch<Clock>(); s=std::copy(str.begin(), str.end(), s);
where facet is the
facet associated to the time_point_units
<CharT>ios
or a new instance of __time_point_units_default<CharT>
.
Returns: s, iterator pointing immediately after the last character produced.
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 <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());
time_point_units()
get_pattern()
get_epoch()
time_point_units()
do_get_epoch(system_clock)
do_get_epoch(steady_clock)
do_get_epoch(process_real_cpu_clock)
do_get_epoch(process_user_cpu_clock)
do_get_epoch(process_system_cpu_clock)
do_get_epoch(process_cpu_clock)
do_get_epoch(thread_clock)
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 };
explicit time_point_units(size_t refs = 0);
Construct a time_point_units
facet.
Parameters:
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.
virtual string_type get_pattern() const =0;
Returns: the pattern to be used by default.
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);
virtual string_type do_get_epoch(system_clock) const=0;
Parameters:
system_clock
.
Returns: The epoch string associated
to the system_clock
.
virtual string_type do_get_epoch(steady_clock) const=0;
Parameters:
steady_clock
.
Returns: The epoch string associated
to the steady_clock
.
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS) virtual string_type do_get_epoch(process_real_cpu_clock) const=0; #endif
Parameters:
process_real_cpu_clock
.
Returns: The epoch string associated
to the process_real_cpu_clock
.
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS) virtual string_type do_get_epoch(process_user_cpu_clock) const=0; #endif
Parameters:
process_real_cpu_clock
.
Returns: The epoch string associated to the process_user_cpu_clock.
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS) virtual string_type do_get_epoch(process_system_cpu_clock) const=0; #endif
Parameters:
process_system_cpu_clock
.
Returns: The epoch string associated to the process_user_cpu_clock.
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS) virtual string_type do_get_epoch(process_cpu_clock) const=0; #endif
Parameters:
process_cpu_clock
.
Returns: The epoch string associated to the process_cpu_clock.
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK) virtual string_type do_get_epoch(thread_clock) const=0; #endif
Parameters:
thread_clock
.
Returns: The epoch string associated
to the thread_clock
.
// 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 };
namespace boost { namespace chrono { // manipulators unspecifiedtime_fmt
(timezone tz); template<class CharT> unspecifiedtime_fmt
(timezone tz, basic_string<CharT> f); template<class CharT> unspecifiedtime_fmt
(timezone tz, const CharT* f); // i/o state savers template<typename CharT = char, typename Traits = std::char_traits<CharT> > structtimezone_io_saver
{ typedef std::basic_ios<CharT, Traits> state_type; typedef timezone aspect_type; explicittimezone_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> > structtime_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, classDuration
> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const time_point<system_clock,Duration
>& tp); template <class CharT, class Traits, classDuration
> 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, classClock
, classDuration
> std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const time_point<Clock
,Duration
>& tp); template <class CharT, class Traits, classClock
, classDuration
> std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, time_point<Clock
,Duration
>& tp); } }
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);
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);
template <class CharT, class Traits, classDuration
> 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
is recorded as a pair of get_time_fmt
()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
template <class CharT, class Traits, classDuration
> 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,
inserted, and then extracted should result in an equal Duration
>time_point<system_clock,
,
excepting any precision that did not get inserted.
Duration
>
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
template <class CharT, class Traits, classClock
, classDuration
> 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
template <class CharT, class Traits, classClock
, classDuration
> 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
.