|  | Home | Libraries | People | FAQ | More | 
      As constexpr will not be supported
      by some compilers, it is replaced in the code by BOOST_CONSTEXPR
      for constexpr functions and BOOST_STATIC_CONSTEXPR for struct/class static
      fields. The same applies to noexecpt
      which is replaced by noexcept
      in the code.
    
The documentation doesn't use these macros.
Include all the chrono header files.
#include <boost/chrono/chrono.hpp> #include <boost/chrono/chrono_io.hpp> #include <boost/chrono/process_cpu_clocks.hpp> #include <boost/chrono/thread_clocks.hpp> #include <boost/chrono/ceil.hpp> #include <boost/chrono/floor.hpp> #include <boost/chrono/round.hpp>
<boost/chrono.hpp><boost/chrono/chrono.hpp><boost/chrono/duration.hpp>Clock
        RequirementsTrivialClock RequirementsEcClock
        Requirements<boost/chrono/time_point.hpp><boost/chrono/system_clocks.hpp><boost/chrono/clock_strings.hpp><boost/chrono/typeof/boost/chrono/chrono.hpp>Include only the standard files.
#include <boost/chrono/duration.hpp> #include <boost/chrono/time_point.hpp> #include <boost/chrono/system_clocks.hpp> #include <boost/chrono/typeof/boost/chrono/chrono.hpp>
At present, there is no know limitation respect to the C++11 standard.
The current implementation provides in addition:
              When BOOST_NO_CXX11_STATIC_ASSERT
              is defined, the user can select the way static assertions are reported.
              Define
            
BOOST_CHRONO_USES_STATIC_ASSERT:
                  define it if you want to use Boost.StaticAssert.
                BOOST_CHRONO_USES_MPL_ASSERT:
                  define it if you want to use Boost.MPL static assertions.
                BOOST_CHRONO_USES_ARRAY_ASSERT:
                  define it if you want to use internal static assertions.
                
              The default behavior is as BOOST_CHRONO_USES_ARRAY_ASSERT
              was defined.
            
              When BOOST_CHRONO_USES_MPL_ASSERT
              is not defined the following symbols are defined as
            
#define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION \ "A duration representation can not be a duration" #define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO \ "Second template parameter of duration must be a boost::ratio" #define BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE \ "duration period must be positive" #define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_CHRONO_DURATION \ "Second template parameter of time_point must be a boost::chrono::duration"
Depending on the static assertion used system you will have an hint of the failing assertion either through the symbol or through the text.
              When BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
              is defined the lib doesn't provides the hybrid error handling prototypes:
            
Clock::time_point Clock::now(system::error_code&ec=boost::throws());
This allow to be closer to the standard and to avoid the Boost.System dependency, making possible to have Boost.Chrono as a header-only library.
              By default BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING
              is defined.
            
              When BOOST_CHRONO_HEADER_ONLY
              is defined the lib is header-only.
            
              If in addition BOOST_USE_WINDOWS_H
              is defined <windows.h> is included, otherwise files in
              boost/detail/win are used to reduce the impact
              of including <windows.h>.
            
              However, you will either need to define BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
              or link with Boost.System.
            
Version 2.0.0 deprecates the preceding IO features.
              However the default version is always version 1. If you don't want
              to include the deprecated features you could define BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0.
            
              BOOST_CHRONO_VERSION
              defines the Boost.Chrono version. The default version is 1. In this
              case the following breaking or extending macros are defined if the
              opposite is not requested:
            
BOOST_CHRONO_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
                
              The user can request the version 2 by defining BOOST_CHRONO_VERSION
              to 2. In this case the following breaking or extending macros are defined
              if the opposite is not requested:
            
BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
                  
                
              The default value for BOOST_CHRONO_VERSION
              will be changed to 2 since Boost 1.55.
            
This file contains duration specific classes and non-member functions.
namespace boost { namespace chrono { template <class Rep, class Period =ratio<1> > classduration; } template <class Rep1, class Period1, class Rep2, class Period2> structcommon_type<duration<Rep1, Period1>, duration<Rep2, Period2> >; namespace chrono { // customization traits template <class Rep> structtreat_as_floating_point; template <class Rep> structduration_values; // duration arithmetic template <class Rep1, class Period1, class Rep2, class Period2> constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::typeoperator+( const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::typeoperator-( const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); template <class Rep1, class Period, class Rep2> constexpr duration<typename common_type<Rep1, Rep2>::type, Period>operator*( const duration<Rep1, Period>& d, const Rep2& s); template <class Rep1, class Period, class Rep2> constexpr duration<typename common_type<Rep1, Rep2>::type, Period>operator*( const Rep1& s, const duration<Rep2, Period>& d); template <class Rep1, class Period, class Rep2> constexpr duration<typename common_type<Rep1, Rep2>::type, Period>operator/( const duration<Rep1, Period>& d, const Rep2& s); template <class Rep1, class Period1, class Rep2, class Period2> constexpr typename common_type<Rep1, Rep2>::typeoperator/( const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); #ifdef BOOST_CHRONO_EXTENSIONS // Used to get frequency of events template <class Rep1, class Rep2, class Period> constexpr doubleoperator/( const Rep1& s, const duration<Rep2, Period>& d); #endif // duration comparisons template <class Rep1, class Period1, class Rep2, class Period2> constexpr booloperator==( const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr booloperator!=( const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool __duration__op_le_1( const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr booloperator<=( const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr booloperator>( const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr booloperator>=( const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); // duration_cast template <class ToDuration, class Rep, class Period> constexpr ToDurationduration_cast(const duration<Rep, Period>& d); // convenience typedefs typedef duration<boost::int_least64_t, nano>nanoseconds; // at least 64 bits needed typedef duration<boost::int_least64_t, micro>microseconds; // at least 55 bits needed typedef duration<boost::int_least64_t, milli>milliseconds; // at least 45 bits needed typedef duration<boost::int_least64_t>seconds; // at least 35 bits needed typedef duration<boost::int_least32_t, ratio< 60> >minutes; // at least 29 bits needed typedef duration<boost::int_least32_t, ratio<3600> >hours; // at least 23 bits needed } }
template <class Rep> struct treat_as_floating_point : boost::is_floating_point<Rep> {};
              The duration template uses the
              treat_as_floating_point trait
              to help determine if a duration with one tick period
              can be converted to another duration with a different
              tick period. If treat_as_floating_point<Rep>::value
              is true, then Rep is a floating-point type and
              implicit conversions are allowed among durations. Otherwise, the
              implicit convertibility depends on the tick periods of the durations. If Rep is a class type which emulates
              a floating-point type, the author of Rep
              can specialize treat_as_floating_point so
              that duration will treat this
              Rep as if it were a
              floating-point type. Otherwise Rep
              is assumed to be an integral type, or a class emulating an integral
              type.
            
template <class Rep> struct duration_values { public: static constexpr Repzero(); static constexpr Repmax(); static constexpr Repmin(); };
              The duration template uses the
              duration_values trait to construct
              special values of the duration's representation
              (Rep). This is done
              because the representation might be a class type with behavior which
              requires some other implementation to return these special values.
              In that case, the author of that class type should specialize duration_values to return
              the indicated values.
            
static constexpr Rep zero();
                Returns: Rep(0). Note:
                Rep(0)
                is specified instead of Rep() since Rep() may have some other meaning, such
                as an uninitialized value.
              
Remarks: The value returned corresponds to the additive identity.
static constexpr Rep max();
                Returns: numeric_limits<Rep>::max().
              
Remarks: The value returned compares greater than zero().
static constexpr Rep min();
                Returns: numeric_limits<Rep>::lowest().
              
                Remarks: The value returned compares
                less than or equal to zero().
              
template <class Rep1, class Period1, class Rep2, class Period2> structcommon_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2> > { typedef chrono::duration<typenamecommon_type<Rep1, Rep2>::type, see bellow> type; };
            The period of the duration indicated by this specialization
            of common_type is the
            greatest common divisor of Period1
            and Period2. This can
            be computed by forming a ratio
            of the greatest common divisor of Period1::num
            and Period2::num, and the least common multiple
            of Period1::den and Period2::den.
          
            Note: The typedef type is the duration with the largest tick
            period possible where both duration arguments will convert
            to it without requiring a division operation. The representation of this
            type is intended to be able to hold any value resulting from this conversion,
            with the possible exception of round-off error when floating-point durations are involved (but
            not truncation error).
          
            A duration measures time between
            two points in time (time_point). A duration has a representation
            which holds a count of ticks, and a tick period. The tick period is the
            amount of time which occurs from one tick to another in units of a second.
            It is expressed as a rational constant using ratio.
          
namespace boost { namespace chrono { template <class Rep, class Period> class duration { public: typedef Rep rep; typedef Period period; private: rep rep_; // exposition only public: constexprduration(); template <class Rep2> constexpr explicitduration(const Rep2& r); template <class Rep2, class Period2> constexprduration(const duration<Rep2, Period2>& d); duration& operator=(const duration&) = default; constexpr repcount() const; constexpr duration __duration__op_plus(); constexpr duration __duration__op_minus(); duration&operator++(); durationoperator++(int); duration&operator--(); durationoperator--(int); duration&operator+=(const duration& d); duration&operator-=(const duration& d); duration&operator*=(const rep& rhs); duration&operator/=(const rep& rhs); duration&operator%=(const rep& rhs); duration&operator%=(const duration& rhs); static constexpr durationzero(); static constexpr durationmin(); static constexpr durationmax(); }; }}
            Rep must be an arithmetic
            type, or a class emulating an arithmetic type, compile diagnostic otherwise.
            If duration is instantiated with
            the type of Rep being
            a duration, compile diagnostic
            is issued.
          
            Period must be an instantiation
            of ratio, compile diagnostic
            otherwise.
          
            Period::num must be positive, compile diagnostic
            otherwise.
          
Examples:
            The following members of duration do not throw an exception
            unless the indicated operations on the representations throw an exception.
          
constexpr duration();
              Effects: Constructs an object of type
              duration initialized from
              duration_values<rep>::zero()
              in C++98 or BOOST_CHRONO_DURATION_DEFAULTS_TO_ZERO
              is defined, otherwise the duration is uninitialized.
            
template <class Rep2> constexpr explicit duration(const Rep2& r);
              Remarks: Rep2
              is implicitly convertible to rep,
              and
            
treat_as_floating_point<rep>::value
                  is true, or
                !treat_as_floating_point<rep>::value
                  && !treat_as_floating_point<Rep2>::value is true.
                
              If these constraints are not met, this constructor will not participate
              in overload resolution. Note: This
              requirement prevents construction of an integral-based duration with a floating-point
              representation. Such a construction could easily lead to confusion
              about the value of the duration.
            
Example:
duration<int, milli> d(3.5); // do not compileduration<int, milli> d(3); // ok
              Effects: Constructs an object of type
              duration.
            
              Post Conditions: count() == static_cast<rep>(r).
            
template <class Rep2, class Period2> constexprduration(constduration<Rep2, Period2>& d);
              Remarks: treat_as_floating_point<rep>::value,
              or ratio_divide<Period2,
              period>::type::den ==
              1, else this constructor will
              not participate in overload resolution. note
              This requirement prevents implicit truncation error when converting
              between integral-based durations. Such a construction
              could easily lead to confusion about the value of the duration.
            
Example:
duration<int, milli> ms(3);duration<int, micro> us = ms; // okduration<int, milli> ms2 = us; // do not compile
              Effects: Constructs an object of type
              duration, constructing rep_ from duration_cast<.
            duration>(d).count()
static constexpr duration zero();
              Returns: duration(duration_values<rep>::zero())
static constexpr duration min();
              Returns: duration(duration_values<rep>::min()).
static constexpr duration max();
              Returns: duration(duration_values<rep>::max())
template <class Rep1, class Period1, class Rep2, class Period2> constexpr typenamecommon_type<duration<Rep1, Period1>,duration<Rep2, Period2> >::type operator+(constduration<Rep1, Period1>& lhs, constduration<Rep2, Period2>& rhs);
              Returns: CD(CD(lhs).count() + CD(rhs).count())
              where CD is the type
              of the return value.
            
template <class Rep1, class Period1, class Rep2, class Period2> constexpr typenamecommon_type<duration<Rep1, Period1>,duration<Rep2, Period2> >::type operator-(constduration<Rep1, Period1>& lhs, constduration<Rep2, Period2>& rhs);
              Returns: CD(CD(lhs).count() - CD(rhs).count())
              where CD is the type
              of the return value.
            
template <class Rep1, class Period, class Rep2> constexprduration<typenamecommon_type<Rep1, Rep2>::type, Period> operator*(constduration<Rep1, Period>& d, const Rep2& s);
              Requires: Let CR
              represent the common_type
              of Rep1 and Rep2. This function will not participate
              in overload resolution unless both Rep1
              and Rep2 are implicitly
              convertible to CR.
            
              Returns: CD(CD(d).count() * s)
              where CD is the type
              of the return value.
            
template <class Rep1, class Period, class Rep2> constexprduration<typenamecommon_type<Rep1, Rep2>::type, Period> operator*(const Rep1& s, constduration<Rep2, Period>& d);
              Requires: Let CR
              represent the common_type
              of Rep1 and Rep2. This function will not participate
              in overload resolution unless both Rep1
              and Rep2 are implicitly
              convertible to CR.
            
              Returns: d
              * s.
            
template <class Rep1, class Period, class Rep2> constexprduration<typenamecommon_type<Rep1, Rep2>::type, Period> operator/(constduration<Rep1, Period>& d, const Rep2& s);
              Requires: Let CR
              represent the common_type
              of Rep1 and Rep2. This function will not participate
              in overload resolution unless both Rep1
              and Rep2 are implicitly
              convertible to CR,
              and Rep2 is not an
              instantiation of duration.
            
              Returns: CD(CD(d).count() / s)
              where CD is the type
              of the return value.
            
template <class Rep1, class Period1, class Rep2, class Period2> constexpr typenamecommon_type<Rep1, Rep2>::type operator/(constduration<Rep1, Period1>& lhs, constduration<Rep2, Period2>& rhs);
              Remarks: Let CD
              represent the common_type
              of the two duration arguments. Returns: Returns CD(lhs).count() / CD(rhs).count().
            
Included only if BOOST_CHRONO_EXTENSIONS is defined.
              This overloading could be used to get the frequency of an event counted
              by Rep1.
            
template <class Rep1, class Rep2, class Period>
constexpr
double operator/(const Rep1& s, const duration<Rep2, Period>& d);
              Remarks: Let CR
              represent the common_type
              of Rep1 and Rep2. This function will not participate
              in overload resolution unless both Rep1
              and Rep2 are implicitly
              convertible to CR,
              and Rep1 is not an
              instantiation of duration. Let CD represent duration<CR,Period>.
            
              Returns: CR(s)/CD(d).count() where CD
              is the type of the return value.
            
template <class Rep1, class Period, class Rep2> constexprduration<typenamecommon_type<Rep1, Rep2>::type, Period> operator%(constduration<Rep1, Period>& d, const Rep2& s);
              Remarks: Let CR
              represent the common_type
              of Rep1 and Rep2. This function will not participate
              in overload resolution unless Rep2 must be implicitly convertible to
              CR and Rep2 must not be an instantiation of duration.
            
              Returns: CD(CD(d).count() % s) where
              CD is the type of the
              return value.
            
template <class Rep1, class Period1, class Rep2, class Period2> constexpr typenamecommon_type<duration<Rep1, Period1>,duration<Rep2, Period2> >::type operator%(constduration<Rep1, Period1>& lhs, constduration<Rep2, Period2>& rhs);
Remarks: This function will not participate in overload resolution unless
              Returns: CD(CD(lhs).count() % CD(rhs).count())
              where CD is the type
              of the return value.
            
template <class Rep1, class Period1, class Rep2, class Period2> bool operator==(constduration<Rep1, Period1>& lhs, constduration<Rep2, Period2>& rhs);
              Returns: Let CD
              represent the common_type
              of the two duration arguments.
            
              Returns: Returns CD(lhs).count() == CD(rhs).count()
            
template <class Rep1, class Period1, class Rep2, class Period2> bool operator!=(constduration<Rep1, Period1>& lhs, constduration<Rep2, Period2>& rhs);
              Returns: !(lhs ==
              rhs).
            
template <class Rep1, class Period1, class Rep2, class Period2> bool operator< (constduration<Rep1, Period1>& lhs, constduration<Rep2, Period2>& rhs);
              Returns: Let CD
              represent the common_type
              of the two duration arguments. Returns
              CD(lhs).count()
              < CD(rhs).count()
            
template <class Rep1, class Period1, class Rep2, class Period2> bool operator<=(constduration<Rep1, Period1>& lhs, constduration<Rep2, Period2>& rhs);
              Returns: !(rhs <
              lhs).
            
template <class Rep1, class Period1, class Rep2, class Period2> bool operator> (constduration<Rep1, Period1>& lhs, constduration<Rep2, Period2>& rhs);
              Returns: rhs
              < lhs.
            
template <classToDuration, class Rep, class Period>ToDurationduration_cast(constduration<Rep, Period>& d);
            Requires: This function will not participate
            in overload resolution unless ToDuration
            is an instantiation of duration.
          
            Returns: Forms CF
            which is a ratio resulting
            from ratio_divide<Period, typename ToDuration::period>::type.
            Let CR be the common_type of ToDuration::rep,
            Rep, and intmax_t.
          
CF::num ==
                1 and CF::den
                == 1,
                then returns ToDuration(static_cast<typename
                ToDuration::rep>(d.count()))
                
              CF::num !=
                1 and CF::den
                == 1,
                then returns ToDuration(static_cast<typename
                ToDuration::rep>(static_cast<CR>(d.count())
                * static_cast<CR>(CF::num)))
              CF::num ==
                1 and CF::den
                != 1,
                then returns ToDuration(static_cast<typename
                ToDuration::rep>(static_cast<CR>(d.count())
                / static_cast<CR>(CF::den)))
              ToDuration(static_cast<typename
                ToDuration::rep>(static_cast<CR>(d.count())
                * static_cast<CR>(CF::num) / static_cast<CR>(CF::den)))
              
            Remarks: This function does not rely
            on any implicit conversions. All conversions must be accomplished through
            static_cast. The implementation
            avoids all multiplications or divisions when it is known at compile-time
            that it can be avoided because one or more arguments are 1. All intermediate computations are carried
            out in the widest possible representation and only converted to the destination
            representation at the final step.
          
// convenience typedefs typedefduration<boost::int_least64_t, nano> nanoseconds; // at least 64 bits needed typedefduration<boost::int_least64_t, micro> microseconds; // at least 55 bits needed typedefduration<boost::int_least64_t, milli> milliseconds; // at least 45 bits needed typedefduration<boost::int_least64_t> seconds; // at least 35 bits needed typedefduration<boost::int_least32_t,ratio< 60> > minutes; // at least 29 bits needed typedefduration<boost::int_least32_t,ratio<3600> > hours; // at least 23 bits needed
          A clock represents a bundle consisting of a duration, a time_point, and a function now()
          to get the current time_point. A clock must meet
          the requirements in the following Table.
        
          In this table C1 and C2 denote Clock
          types. t1 and t2 are values returned from C1::now()
          where the call returning t1
          happens before the call returning t2
          and both of these calls occur before C1::time_point::max(). (note This means C1 did not wrap around
          between t1 and t2.).
        
Table 7.1. Clock Requirements
| expression | return type | operational semantics | 
|---|---|---|
| 
                     | An arithmetic type or class emulating an arithmetic type. | 
                    The representation type of the  | 
| 
                     | 
                     | The tick period of the clock in seconds. | 
| 
                     | 
                     | 
                    The  | 
| 
                     | 
                     | 
                    The  | 
| 
                     | 
                     | 
                     | 
| 
                     | 
                     | 
                    Returns a  | 
          Models of Clock:
        
          A type TC meets the TrivialClock requirements if:
        
TC satisfies the Clock requirements,
            TC::rep, TC::duration,
              and TC::time_point satisfy the requirements
              of EqualityComparable,
              LessThanComparable,
              DefaultConstructible,
              CopyConstructible,
              CopyAssignable, Destructible, and the requirements
              of numeric types.
            | ![[Note]](../../../doc/src/images/note.png) | Note | 
|---|---|
| This means, in particular, that operations on these types will not throw exceptions. | 
TC::rep,
              TC::duration, and TC::time_point
              are swappable,
            TC::now()
              does not throw exceptions and it is thread-safe, and
            TC::time_point::clock meets the TrivialClock
              requirements, recursively.
            
          Models of TrivialClock:
        
          A type EcC meets the EcClock requirements if
        
TC satisfies the TrivialClock  requirements, and
            now()
              interfaces allowing to recover internal error codes as described in
              the following table.
            
          In this table C1 denotes
          a EcClock type and ec is an instance of a boost::system::error_code.
        
Table 7.2. Clock Requirements
| expression | return type | operational semantics | 
|---|---|---|
| 
                     | 
                     | 
                    Returns a  | 
| 
                     | 
                     | 
                    Returns a  | 
          Models of Clock:
        
          This file contains time_point specific classes and
          non-member functions.
        
namespace boost { namespace chrono { template <classClock, classDuration= typename Clock::duration> classtime_point; } template <classClock, classDuration1, classDuration2> structcommon_type<time_point<Clock, Duration1>, time_point<Clock, Duration2> >; namespace chrono { // time_point arithmetic template <classClock, classDuration1, class Rep2, class Period2> constexpr time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs); template <class Rep1, class Period1, classClock, classDuration2> constexpr time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs); template <classClock, classDuration1, class Rep2, class Period2> constexpr time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs); template <classClock, classDuration1, classDuration2> constexpr typename common_type<Duration1, Duration2>::typeoperator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); // time_point comparisons template <classClock, classDuration1, classDuration2> constexpr booloperator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); template <classClock, classDuration1, classDuration2> constexpr booloperator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); template <classClock, classDuration1, classDuration2> constexpr booloperator<(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); template <classClock, classDuration1, classDuration2> constexpr booloperator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); template <classClock, classDuration1, classDuration2> constexpr booloperator>(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); template <classClock, classDuration1, classDuration2> constexpr booloperator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); // time_point_cast template <classToDuration, classClock, classDuration> constexpr time_point<Clock, ToDuration>time_point_cast(const time_point<Clock, Duration>& t); } }
template <classClock, classDuration1, classDuration2> structcommon_type<chrono::time_point<Clock,Duration1>, chrono::time_point<Clock,Duration2> > { typedef chrono::time_point<Clock, typenamecommon_type<Duration1,Duration2>::type> type; };
            The common_type of two
            time_points is a time_point with the same Clock
            (both have the same Clock), and the common_type of the two durations.
          
            A time_point represents a point
            in time with respect to a specific clock.
          
template <classClock, classDuration> class time_point { public: typedef Clock clock; typedef Duration duration; typedef typename duration::rep rep; typedef typename duration::period period; private: duration d_; // exposition only public: constexprtime_point(); constexpr explicittime_point(const duration& d); // conversions template <classDuration2> constexprtime_point(const time_point<clock,Duration2>& t); // observer constexpr durationtime_since_epoch() const; // arithmetic #ifdef BOOST_CHRONO_EXTENSIONS constexpr time_pointoperator+(); constexpr time_pointoperator-(); time_point&operator++(); time_pointoperator++(int); time_point&operator--(); time_pointoperator--(int); time_point& __time_point__op_plus_eq_1(const rep& d); time_point&operator-=(const rep& d); #endif time_point& __time_point__op_plus_eq_2(const duration& d); time_point&operator-=(const duration& d); // special values static constexpr time_pointmin(); static constexpr time_pointmax(); };
            Clock must meet the Clock requirements.
          
            Duration must be an instantiation of duration, compile diagnostic
            otherwise.
          
constexpr time_point();
              Effects: Constructs an object of
              time_point, initializing
              d_ with duration::zero().
              This time_point represents the
              epoch.
            
constexpr time_point(const duration& d);
              Effects: Constructs an object of
              time_point, initializing
              d_ with d. This time_point represents the
              epoch + d.
            
template <classDuration2> constexpr time_point(consttime_point<clock,Duration2>& t);
              Requires: This function will not participate
              in overload resolution unless Duration2
              is implicitly convertible to duration.
            
              Effects: Constructs an object of
              time_point, initializing
              d_ with t.time_since_epoch().
            
time_point& operator+=(const duration& d);
              Effects: d_
              += d.
            
              Returns: *this.
            
time_point& operator-=(const duration& d);
              Effects: d_
              -= d
            
              Returns: *this.
            
template <classClock, classDuration1, class Rep2, class Period2> constexprtime_point<Clock, typenamecommon_type<Duration1, duration<Rep2, Period2> >::type> operator+(consttime_point<Clock,Duration1>& lhs, const duration<Rep2, Period2>& rhs);
              Returns: CT(lhs.time_since_epoch() + rhs)
              where CT is the type
              of the return value.
            
template <class Rep1, class Period1, classClock, classDuration2> constexprtime_point<Clock, typenamecommon_type<duration<Rep1, Period1>,Duration2>::type> operator+(const duration<Rep1, Period1>& lhs, consttime_point<Clock,Duration2>& rhs);
              Returns: rhs
              + lhs.
            
template <classClock, classDuration1, class Rep2, class Period2> constexprtime_point<Clock, typenamecommon_type<Duration1, duration<Rep2, Period2> >::type> operator-(consttime_point<Clock,Duration1>& lhs, const duration<Rep2, Period2>& rhs);
              Returns: lhs
              + (-rhs).
            
template <classClock, classDuration1, classDuration2> constexpr typenamecommon_type<Duration1,Duration2>::type operator-(consttime_point<Clock,Duration1>& lhs, consttime_point<Clock,Duration2>& rhs);
              Returns: lhs.time_since_epoch() - rhs.time_since_epoch().
            
template <classClock, classDuration1, classDuration2> constexpr bool operator==(consttime_point<Clock,Duration1>& lhs, consttime_point<Clock,Duration2>& rhs);
              Returns: lhs.time_since_epoch() == rhs.time_since_epoch().
            
template <classClock, classDuration1, classDuration2> constexpr bool operator!=(consttime_point<Clock,Duration1>& lhs, consttime_point<Clock,Duration2>& rhs);
              Returns: !(lhs ==
              rhs).
            
template <classClock, classDuration1, classDuration2> constexpr bool operator< (consttime_point<Clock,Duration1>& lhs, consttime_point<Clock,Duration2>& rhs);
Returns: lhs.time_since_epoch() < rhs.time_since_epoch().
template <classClock, classDuration1, classDuration2> constexpr bool operator<=(consttime_point<Clock,Duration1>& lhs, consttime_point<Clock,Duration2>& rhs);
              Returns: !(rhs <
              lhs).
            
template <classClock, classDuration1, classDuration2> constexpr bool operator>(consttime_point<Clock,Duration1>& lhs, consttime_point<Clock,Duration2>& rhs);
              Returns: rhs
              < lhs.
            
template <classClock, classDuration1, classDuration2> constexpr bool operator>=(consttime_point<Clock,Duration1>& lhs, consttime_point<Clock,Duration2>& rhs);
              Returns: !(lhs <
              rhs).
            
template <classToDuration, classClock, classDuration> constexprtime_point<Clock, ToDuration>time_point_cast(consttime_point<Clock,Duration>& t);
            Requires: This function will not participate
            in overload resolution unless ToDuration
            is an instantiation of duration.
          
            Returns: time_point<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()))
          This file contains the standard clock classes. The types defined in this
          section satisfy the TrivialClock requirements
        
namespace boost { namespace chrono { // Clocks classsystem_clock; classsteady_clock; classhigh_resolution_clock; template <class CharT> struct clock_string<system_clock, CharT>; template <class CharT> struct clock_string<steady_clock, CharT>; } }
            The system_clock class provides
            a means of obtaining the current wall-clock time from the system-wide
            real-time clock. The current time can be obtained by calling system_clock::now().
            Instances of system_clock::time_point
            can be converted to and from time_t with the system_clock::to_time_t() and system_clock::from_time_t() functions. If system clock is not steady,
            a subsequent call to system_clock::now() may return an earlier time than a previous
            call (e.g. if the operating system clock is manually adjusted, or synchronized
            with an external clock).
          
            The current implementation of system_clock is related an epoch
            (midnight UTC of January 1, 1970), but this is not in the contract. You
            need to use the static function static
          
std::time_t to_time_t(const time_point& t);
            which returns a time_t
            type that is based on midnight UTC of January 1, 1970.
          
class system_clock {
public:
    typedef see bellow          duration;
    typedef duration::rep                        rep;
    typedef duration::period                     period;
    typedef chrono::time_point<system_clock>     time_point;
    static constexpr bool is_steady =            false;
    static time_point  now() noexcept;
    static time_point  now(system::error_code & ec);
    // Map to C API
    static std::time_t to_time_t(const time_point& t) noexcept;
    static time_point  from_time_t(std::time_t t) noexcept;
};
            system_clock satisfy the Clock
            requirements:
          
system_clock::duration::min()
                < system_clock::duration::zero() is true.
              duration
                typedef has a resolution that depends on the one provided by the
                platform.
              time_t to_time_t(const time_point& t) noexcept;
              Returns: A time_t
              such that the time_t
              and t represent the
              same point in time, truncated to the coarser of the precisions among
              time_t and time_point.
            
time_point from_time_t(time_t t) noexcept;
              Returns: A time_point such that the
              time_point and t represent the same point in time,
              truncated to the coarser of the precisions among time_point and time_t.
            
Defined if the platform support steady clocks.
            steady_clock satisfy the Clock
            requirements.
          
            steady_clock class provides
            access to the system-wide steady clock. The current time can be obtained
            by calling steady_clock::now(). There is no fixed relationship between
            values returned by steady_clock::now() and wall-clock time.
          
#ifdef BOOST_HAS_CLOCK_STEADY class steady_clock { public: typedefnanosecondsduration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point<steady_clock> time_point; static constexpr bool is_steady = true; static time_point now() noexcept; static time_point now(system::error_code & ec); }; #endif
            high_resolution_clock satisfy
            the Clock
            requirements.
          
#ifdefBOOST_CHRONO_HAS_CLOCK_STEADYtypedefsteady_clockhigh_resolution_clock; // as permitted by [time.clock.hires] #else typedefsystem_clockhigh_resolution_clock; // as permitted by [time.clock.hires] #endif
template <class CharT> struct clock_string<system_clock, CharT> { static std::basic_string<CharT> name(); static std::basic_string<CharT> since(); };
            clock_string<>::name()
            returns "system_clock".
          
            clock_string<>::since()
            returns " since Jan 1, 1970"
          
#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY template <class CharT> struct clock_string<steady_clock, CharT> { static std::basic_string<CharT> name(); static std::basic_string<CharT> since(); }; #endif
            clock_string<>::name()
            returns "steady_clock".
          
            clock_string<>::since()
            returns " since boot"
          
namespace boost {
  namespace chrono {
    template <class Clock, class CharT>
    struct clock_string;
  }
}
template <class Clock, class CharT>
struct clock_string;
This template must be specialized for specific clocks. The specialization must define the following functions
static std::basic_string<CharT> name(); static std::basic_string<CharT> since();
            clock_string<>::name()
            return the clock name, which usually corresponds to the class name.
          
            clock_string<>::since()
            return the textual format of the clock epoch.
          
          Register duration<>
          and time_point<>
          class templates to Boost.Typeof.
        
namespace boost { namespace chrono { template <class CharT> class duration_punct; template <class CharT, class Traits> std::basic_ostream<CharT, Traits>& duration_short(std::basic_ostream<CharT, Traits>& os); template <class CharT, class Traits> std::basic_ostream<CharT, Traits>& duration_long(std::basic_ostream<CharT, Traits>& os); template <class CharT, class Traits, class Rep, class Period> std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d); template <class CharT, class Traits, class Rep, class Period> std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d) template <class CharT, class Traits, class Clock, class Duration> std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const time_point<Clock, Duration>& tp); template <class CharT, class Traits, class Clock, class Duration> std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, time_point<Clock, Duration>& tp); } }
            The duration unit names can be customized
            through the facet: duration_punct. duration unit names come in
            two varieties: long and short. The default constructed duration_punct provides names
            in the long format. These names are English descriptions. Other languages
            are supported by constructing a duration_punct with the proper
            spellings for "hours", "minutes" and "seconds",
            and their abbreviations (for the short format).
          
template <class CharT> class duration_punct : public std::locale::facet { public: typedef std::basic_string<CharT> string_type; enum {use_long, use_short}; static std::locale::id id; explicit duration_punct(int use = use_long); duration_punct(int use, const string_type& long_seconds, const string_type& long_minutes, const string_type& long_hours, const string_type& short_seconds, const string_type& short_minutes, const string_type& short_hours); duration_punct(int use, const duration_punct& d); template <class Period> string_type short_name() const; template <class Period> string_type long_name() const; template <class Period> string_type name() const; bool is_short_name() const; bool is_long_name() const; };
            The short or long format can be easily chosen by streaming a duration_short or duration_long
            manipulator respectively.
          
template <class CharT, class Traits> std::basic_ostream<CharT, Traits>& duration_short(std::basic_ostream<CharT, Traits>& os);
            Effects: Set the duration_punct facet to stream
            durations and time_points as abbreviations.
          
Returns: the output stream
template <class CharT, class Traits> std::basic_ostream<CharT, Traits>& duration_long(std::basic_ostream<CharT, Traits>& os);
            Effects: Set the duration_punct facet to stream
            durations and time_points as long text.
          
Returns: the output stream
            Any duration can be streamed out
            to a basic_ostream. The
            run-time value of the duration is formatted according
            to the rules and current format settings for duration::rep. This is followed by a single space
            and then the compile-time unit name of the duration. This unit name is
            built on the string returned from ratio_string<> and the data used to construct
            the duration_punct which was inserted
            into the stream's locale. If a duration_punct has not been
            inserted into the stream's locale, a default constructed duration_punct will be added
            to the stream's locale.
          
            A time_point is formatted by outputting
            its internal duration followed by a string
            that describes the time_point::clock epoch. This string will vary
            for each distinct clock, and for each implementation of the supplied
            clocks.
          
template <class CharT, class Traits, class Rep, class Period> std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d);
            Effects: outputs the duration as an abbreviated or
            long text format depending on the state of the duration_punct facet.
          
Returns: the output stream
template <class CharT, class Traits, class Rep, class Period> std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
            Effects: reads a duration from the input stream.
            If a format error is found, the input stream state will be set to failbit.
          
Returns: the input stream
template <class CharT, class Traits, class Clock, class Duration> std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const time_point<Clock, Duration>& tp);
            Effects: outputs the time_point as an abbreviated
            or long text format depending on the state of the duration_punct facet.
          
Returns: the output stream
template <class CharT, class Traits, class Clock, class Duration> std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, time_point<Clock, Duration>& tp);
            Effects: reads a time_point from the input stream.
            If a format error is found, the input stream state will be set to failbit.
          
Returns: the input stream
<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; } }
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 7.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_styleaspect_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; typedeftimezoneaspect_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;
  }
}
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;
  }
}
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; };
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.
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_stylestyle) noexcept; #ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS explicitoperator duration_style() const noexcept; #endifduration_styleget_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
              duration_put<CharT>os
              or a new created instance of the default 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
              duration_get<CharT>is
              or a new created instance of the default 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; } }
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 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 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 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); } }
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);
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);
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 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.
              
namespace boost { namespace chrono { template <class To, class Rep, class Period> To floor(const duration<Rep, Period>& d); } }
This function round down the given parameter.
namespace boost { namespace chrono { template <class To, class Rep, class Period> To round(const duration<Rep, Period>& d); } }
This function round to nearest, to even on tie the given parameter.
namespace boost { namespace chrono { template <class To, class Rep, class Period> To ceil(const duration<Rep, Period>& d); } }
This function round up the given parameter.
BOOST_CHRONO_HAS_PROCESS_CLOCKS
          process_real_cpu_clockprocess_user_cpu_clockprocess_system_cpu_clockprocess_cpu_clockprocess_timesprocess_times Input/Outputduration_values Specialization for process_times<>clock_string<process_real_cpu_clock>
          Specializationclock_string<process_user_cpu_clock>
          Specializationclock_string<process_system_cpu_clock>
          Specializationclock_string<process_cpu_clock>
          Specializationnumeric_limits Specialization for process_times<>Knowing how long a program takes to execute is useful in both test and production environments. It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests.
Process clocks don't include the time spent by the child process.
#define BOOST_CHRONO_HAS_PROCESS_CLOCKS namespace boost { namespace chrono { class process_real_cpu_clock; class process_user_cpu_clock; class process_system_cpu_clock; class process_cpu_clock; template <typename Rep> struct process_times; template <class CharT, class Traits, class Rep> std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, process_times<Rep> const& rhs); template <class CharT, class Traits, class Rep> std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, process_times<Rep> const& rhs); template <class Rep> struct duration_values<process_times<Rep> >; template <class CharT> struct clock_string<process_real_cpu_clock, CharT>; struct clock_string<process_user_cpu_clock, CharT>; struct clock_string<process_system_cpu_clock, CharT>; struct clock_string<process_cpu_clock, CharT>; } } namespace std { template <class Rep> class numeric_limits<boost::chrono::process_times<Rep> >; }
This macro is defined if the platform supports process clocks.
            process_real_cpu_clock satisfy
            the Clock
            requirements.
          
            process_real_cpu_clock class
            provides access to the real process wall-clock steady clock, i.e. the
            real CPU-time clock of the calling process. The process relative current
            time can be obtained by calling process_real_cpu_clock::now().
          
class process_real_cpu_clock { public: typedefnanosecondsduration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point<process_real_cpu_clock> time_point; static constexpr bool is_steady = true; static time_point now( ) noexcept; static time_point now( system::error_code & ec ); };
            process_user_cpu_clock satisfy
            the Clock
            requirements.
          
            process_user_cpu_clock class
            provides access to the user CPU-time steady clock of the calling process.
            The process relative user current time can be obtained by calling process_user_cpu_clock::now().
          
class process_user_cpu_clock { public: typedefnanosecondsduration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point<process_user_cpu_clock> time_point; static constexpr bool is_steady = true; static time_point now( ) noexcept; static time_point now( system::error_code & ec ); };
            process_system_cpu_clock satisfy
            the Clock
            requirements.
          
            process_system_cpu_clock class
            provides access to the system CPU-time steady clock of the calling process.
            The process relative system current time can be obtained by calling
            process_system_cpu_clock::now().
          
class process_system_cpu_clock { public: typedefnanosecondsduration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point<process_system_cpu_clock> time_point; static constexpr bool is_steady = true; static time_point now( ) noexcept; static time_point now( system::error_code & ec ); };
            process_cpu_clock can
            be considered as a tuple<process_real_cpu_clock, process_user_cpu_clock, process_system_cpu_clock>.
          
            process_cpu_clock provides
            a thin wrapper around the operating system's process time API. For POSIX-like
            systems, that's the times() function, while for Windows, it's the GetProcessTimes()
            function.
          
            The process relative real, user and system current time can be obtained
            at once by calling process_clocks::now().
          
class process_cpu_clock { public: typedef process_times<nanoseconds::rep> times ; typedefduration<times, nano> duration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point<process_cpu_clock> time_point; static constexpr bool is_steady = true; static time_point now( ) noexcept; static time_point now( system::error_code & ec ); };
            This class is the representation of the process_cpu_clock::duration
            class. As such it needs to implements the arithmetic operators.
          
template <typename Rep> struct process_times : arithmetic<process_times<Rep>, multiplicative<process_times<Rep>, Rep, less_than_comparable<process_times<Rep> > > > { Rep real; // real (i.e wall clock) time Rep user; // user cpu time Rep system; // system cpu time times(); times( process_real_cpu_clock::rep r, process_user_cpu_clock::rep u, process_system_cpu_clock::rep s); template <typename Rep2> explicit process_times( Rep2 r); template <typename Rep2> explicit process_times( process_times<Rep2> const& rhs); operator rep() const; bool operator==(process_times const& rhs); template <typename Rep2> bool operator==(process_times<Rep2> const& rhs); times operator+=(process_times const& rhs); times operator-=(process_times const& rhs); times operator*=(process_times const& rhs); times operator/=(process_times const& rhs); bool operator<(process_times const & rhs) const; };
template <class CharT, class Traits, class Rep> std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, process_times<Rep> const& rhs);
Effects: Output each part separated by ';' and surrounded by '{', '}'.
Throws: None.
template <class CharT, class Traits, class Rep> std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, process_times<Rep> const& rhs);
Effects: overrides the value of rhs if the input stream has the format "{r;u;s}". Otherwise, set the input stream state as failbit | eofbit.
Throws: None.
template <class Rep>
struct duration_values<process_times<Rep> >
{
    static process_times<Rep> zero();
    static process_times<Rep> max();
    static process_times<Rep> min();
};
            The times specific functions
            zero(),
            max()
            and min()
            uses the relative functions on the representation of each component.
          
template <class CharT> struct clock_string<process_real_cpu_clock, CharT> { static std::basic_string<CharT> name(); static std::basic_string<CharT> since(); };
            clock_string<>::name()
            returns "process_real_cpu_clock".
          
            clock_string<>::since()
            returns " since process start-up"
          
template <class CharT> struct clock_string<process_user_cpu_clock, CharT> { static std::basic_string<CharT> name(); static std::basic_string<CharT> since(); };
            clock_string<>::name()
            returns "process_user_cpu_clock".
          
            clock_string<>::since()
            returns " since process start-up"
          
template <class CharT> struct clock_string<process_system_cpu_clock, CharT> { static std::basic_string<CharT> name(); static std::basic_string<CharT> since(); };
            clock_string<>::name()
            returns "process_system_cpu_clock".
          
            clock_string<>::since()
            returns " since process start-up"
          
template <class CharT> struct clock_string<process_cpu_clock, CharT> { static std::basic_string<CharT> name(); static std::basic_string<CharT> since(); };
            clock_string<>::name()
            returns "process_cpu_clock".
          
            clock_string<>::since()
            returns " since process start-up"
          
namespace std { template <> class numeric_limits<boost::chrono::process_times<Rep>> { typedef boost::chrono::process_times<Rep> Res; public: static const bool is_specialized = true; static Res min(); static Res max(); static Res lowest(); static const int digits; static const int digits10; static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; static const int radix = 0; }; }
            The process_times<Rep>
            specialization functions min(), max() and lowest() uses the relative functions on the
            representation of each component.
          
Notes
min()
                returns the tuple of mins.
              max()
                returns the tuple of maxs.
              lowest()
                returns the tuple of lowests.
              digits is the sum
                of (binary) digits.
              digits10 is the sum
                of digits10s.
              Knowing the time a thread takes to execute is useful in both test and production environments.
#define BOOST_CHRONO_HAS_THREAD_CLOCK #define BOOST_CHRONO_THREAD_CLOCK_IS_STEADY namespace boost { namespace chrono { class thread_clock; template <class CharT> struct clock_string<thread_clock, CharT>; } }
This macro is defined if the platform supports thread clocks.
This macro is defined if the platform has a thread clock. Its value is true if it is steady and false otherwise.
            thread_clock satisfy the Clock
            requirements.
          
            thread_clock class provides
            access to the real thread wall-clock, i.e. the real CPU-time clock of
            the calling thread. The thread relative current time can be obtained
            by calling thread_clock::now().
          
class thread_clock { public: typedefnanosecondsduration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point<thread_clock> time_point; static constexpr bool is_steady = BOOST_CHRONO_THREAD_CLOCK_IS_STEADY; static time_point now( ) noexcept; static time_point now( system::error_code & ec ); };
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK) template <class CharT> struct clock_string<thread_clock, CharT> { static std::basic_string<CharT> name(); static std::basic_string<CharT> since(); }; #endif
            clock_string<>::name()
            returns "thread_clock".
          
            clock_string<>::since()
            returns " since thread start-up"