/*
A prototype of a proposal for a time/duration/clock library for the C++ standard.
It is intended that this be a solid foundation upon which higher level libraries
can be based. Examples of such libraries include a date/time library and a
physical quantities library.
Two general purpose facilities are proposed:
common_type
ratio
And 5 time/duration/clock facilities are proposed
duration
time_point
system_clock
monotonic_clock // optional
high_resolution_clock // optional
Much thanks to Andrei Alexandrescu,
Walter Brown,
Peter Dimov,
Jeff Garland,
Terry Golubiewski,
Daniel Krügler,
Anthony Williams.
Synopsis
namespace std
{
// <type_traits>
// common_type
// common_type is ageneral purpose trait that can be specialized for user-defined types.
// The semantics are intended to be identical to finding the resulting type of a
// the conditional operator.
// The client may need to specialize common_type if he wishes to convert to or from
// another type only explicitly. It is used to determine the result type
// in "mixed-mode" duration and time_point arithmetic. It will also find use in
// similar "mixed-mode" arithmetic applications.
template <class ...T> struct common_type;
template <class T>
struct common_type<T>
{
typedef T type;
};
template <class T, class U>
struct common_type<T, U>
{
private:
static T&& t();
static U&& u();
public:
typedef decltype(true ? t() : u()) type;
};
template <class T, class U, class ...V>
struct common_type<T, U, V...>
{
typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
};
// This variadic formulation of common_type has some advantages:
//
// 1. The obvious advantage is that it can handle 3 or more arguments seamlessly.
// This can come in handy when writing template functions that take more than
// two arguments, such as fma(x, y, z).
//
// 2. We could just get rid of identity (avoiding the legacy conflict) and use
// common_type<T>::type in the one place we use identity<T>::type today.
//
// 3. For clients that need to specialize common_type (such as duration and time_point),
// the client still needs to specialize only the two-argument version. The default
// definition of the higher-order common_type will automatically use the client's
// specialized two-argument version.
// For example:
// common_type<duration<double>, hours, microseconds>::type is duration<double, micro>
// The cost of not including either version of common_type is that it is very likely that
// the implementation would include it anyway, but spell it __common_type instead. This
// would prevent authors of arithmetic emulators from using their classes as representations
// with durations unless the emulator had exactly one implicit conversion to or from an
// arithmetic type. This would be a large loss of functionality from the client's point
// of view, possibly mandating a less safe interface for the client's arithmetic emulator.
// ratio
// ratio is a general purpose type allowing one to easily and safely compute integral
// ratio values at compile time. The ratio class catches all errors (such as divide by
// zero and overflow) at compile time. It is used in the duration and time_point libraries
// to efficiently create units of time. It can also be used in other "quantity"
// libraries (both std-defined and user-defined), or anywhere there is an integral
// ratio which is known at compile time. The use of this utility can greatly reduce
// the chances of run time overflow because the ratio (and any ratios resulting from
// ratio arithmetic) are always reduced to lowest terms.
// The cost of not including ratio would mean that the implementor would likely have this
// functionality anyway, but spell it __ratio instead. This would prevent the client from
// using ratio in his own code as demonstrated in the "User1" example. Furthermore duration
// would have to be templated on two long long's instead of on ratio like so:
//
// template <class Rep, long long N, long long D> duration.
//
// This would mean that clients wanting to build a custom duration type (say a nanosecond
// represented by a double) would have to write:
//
// duration<double, 1, 1000000000LL>
//
// instead of:
//
// duration<double, nano>
//
// This lack of syntatic niceness, along with the loss of functionality in the reuse of
// ratio in user-written code seems to indicate that the loss of ratio would be a sizeable
// loss to client code.
template <intmax_t N, intmax_t D = 1>
class ratio
{
// For every possible value of N and D, abs(N) >= 0 and abs(D) > 0
static_assert(__static_abs<N>::value >= 0, "ratio numerator is out of range");
static_assert(__static_abs<D>::value > 0, "ratio denominator is out of range");
public:
static const intmax_t num; // Reduced by greatest common divisor of N and D, has sign of sign(N) * sign(D)
static const intmax_t den; // Reduced by greatest common divisor of N and D, always positive
// When num == 0, den == 1
};
// The static_asserts in ratio are there to catch any values which have a negative absolute value.
// In a typical 2's complement representation this is only LLONG_MIN. The reason for prohibiting
// this value is because ratio must take the absolute values of its arguments and generally depends
// on that number being non-negative in order to maintain invariants such as den > 0.
// convenience typedefs
typedef ratio<1, 1000000000000000000000000> yocto; // conditionally supported
typedef ratio<1, 1000000000000000000000> zepto; // conditionally supported
typedef ratio<1, 1000000000000000000> atto;
typedef ratio<1, 1000000000000000> femto;
typedef ratio<1, 1000000000000> pico;
typedef ratio<1, 1000000000> nano;
typedef ratio<1, 1000000> micro;
typedef ratio<1, 1000> milli;
typedef ratio<1, 100> centi;
typedef ratio<1, 10> deci;
typedef ratio< 10, 1> deca;
typedef ratio< 100, 1> hecto;
typedef ratio< 1000, 1> kilo;
typedef ratio< 1000000, 1> mega;
typedef ratio< 1000000000, 1> giga;
typedef ratio< 1000000000000, 1> tera;
typedef ratio< 1000000000000000, 1> peta;
typedef ratio< 1000000000000000000, 1> exa;
typedef ratio< 1000000000000000000000, 1> zetta; // conditionally supported
typedef ratio<1000000000000000000000000, 1> yotta; // conditionally supported
// Compile time arithmetic and comparisons should either avoid overflow or not compile
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_add
{
typedef ratio<pseudo code: R1 + R2> type;
};
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_subtract
{
typedef ratio<pseudo code: R1 - R2> type;
};
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_multiply
{
typedef ratio<pseudo code: R1 * R2> type;
};
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_divide
{
typedef ratio<pseudo code: R1 / R2> type;
};
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_equal
: public integral_constant<bool, pseudo code: R1 == R2> {};
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_not_equal
: public integral_constant<bool, !ratio_equal<R1, R2>::value> {};
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_less
: public integral_constant<bool, pseudo code: R1 < R2> {};
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_less_equal
: public integral_constant<bool, !ratio_less<R2, R1>::value> {};
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_greater
: public integral_constant<bool, ratio_less<R2, R1>::value> {};
template <class R1, class R2>
requires R1 and R2 are instantiations of ratio
struct ratio_greater_equal
: public integral_constant<bool, !ratio_less<R1, R2>::value> {};
namespace chrono
{
// duration customization traits
// Authors of arithmetic emulation types should specialize treat_as_floating_point
// if their class emulates floating point and they want to use it as a duration's
// representation.
template <class Rep> struct treat_as_floating_point
: is_floating_point<Rep> {};
// Authors of arithmetic emulation types should specialize duration_values
// if they want to use it as a duration's representation, and the default
// definition of duration_values does not have the correct behavior.
template <class Rep>
struct duration_values
{
public:
static constexpr Rep zero() {return Rep(0);}
static constexpr Rep max() {return numeric_limits<Rep>::max();}
static constexpr Rep min() {return unsigned<Rep>::value ? zero() : -max();}
};
// Note: Rep(0) instead of Rep() is used for zero() because the author of Rep may
// chose to have Rep() refer to an inderminant or unitialized value.
// duration
// A duration has a representation and a period.
//
// The representation is an arithmetic type, or a class emulating an arithmetic type.
//
// The period is the rational number of seconds between "ticks" of the duration. The
// duration simply holds a count of the elapsed number of ticks (using the
// representation), and that is related to seconds by multiplying by the period.
// Note, this multiplication is only required when one needs to convert between
// durations with different tick periods (e.g. milliseconds to microseconds).
//
// A duration has defalt construction and default copy semantics. One can also explicitly
// construct a duration from its representation or something implicitly convertible to
// its representation. If the representation is integral (or emulated integral) the
// duration may not be constructed from a floating point (or emulated floating point)
// type, even if that type is impilcitly convertible to the representation (the client
// must explicitly convert such an argument as they pass it to the constructor if such
// a conversion is desired).
//
// A duration may be implicitly constructible from another duration if the representations
// of the two durations meet certain requirements. Let the representation of this duration
// be Rep1 and the representation of the other duration be Rep2. Example representations
// include int, long long, double, or a user-defined class which emulates one of these
// arithmetic types. To qualify for implicit constructability Rep1 must be explicitly
// constructible from Rep2. Note that implicit constructibility of Rep1 from Rep2 is not
// required for this implicit construction between durations. Additionally the trait
// common_type<Rep1, Rep2>::type must be well defined. If a conditional expression involving
// these two types isn't valid, there must exist a common_type specialization which makes
// the trait valid.
//
// The requirements put on the relationship between Rep1 and Rep2 are intended to be minimal,
// and not require implicit conversions (which could be considered error prone by the author
// of either of these representations).
//
// In addition to the above relationship between the representations, implicit constructability
// also depends on whether the representation is considered floating point (or emulated floating
// point) or integral (or emulated integral).
//
// If a duration has a floating point (or emulated floating point) representation it
// is implicitly constructible from all other durations of any period (as long as
// the representations are compatible as described above).
//
// If a duration has an integral (or emulated integral) representation it is implicitly
// constructible from other integral-based durations which have a period which will exactly convert
// to the period of this duration with no truncation error. More specifically, if the
// period of this duration is P1, and the period of the other duration is P2, this
// duration is implicitly constructible from the other duration if P2/P1 is a whole number
// (as long as the representations are compatible as described above). Example:
// microseconds has a period p1 = 1/1000000 seconds. milliseconds has a period
// P2 = 1/1000 seconds. P2/P1 is (1/1000)/(1/1000000) = 1000000/1000 = 1000.
// Therefore microseconds will implicitly construct from milliseconds (but not vice-versa).
//
// These rules involving integral representations are meant to prevent accidental truncatation
// error. If truncation error is desired, a duration_cast facility is available to force it.
// Example:
// milliseconds ms(3); // ok, ms.count() == 3, which is 0.003 seconds
// microseconds us = ms; // ok, us.count() == 3000 which is 0.003000 seconds
// ++us; // ok, us.count() == 3001 which is 0.003001 seconds
// ms = us; // won't compile, might truncate
// ms = duration_cast<milliseconds>(us); // ok, ms.count() = 3, truncated a microsecond
//
// A duration has a single observer: rep count() const; which returns the stored
// representation which holds the number of elapsed "ticks".
//
// A duration supports the following member arithmetic:
//
// duration operator+() const;
// duration operator-() const;
// duration& operator++();
// duration operator++(int);
// duration& operator--();
// duration operator--(int);
//
// duration& operator+=(duration d);
// duration& operator-=(duration d);
//
// duration& operator*=(rep rhs);
// duration& operator/=(rep rhs);
//
// The arithmetic simply manipulates the "tick" count in the obvious way (e.g. operator++
// increments the tick count by 1).
//
// A duration supports the following non-member arithmetic.
// Let D1 represent duration<Rep1, Period1> and D2 represent duration<Rep2, Period2>.
//
// common_type<D1, D2>::type operator+( D1, D2); // returns a duration
// common_type<D1, D2>::type operator-( D1, D2); // returns a duration
// duration<common_type<D1::rep,Rep2>::type, D1::period> operator*( D1, Rep2); // returns a duration
// duration<common_type<D1::rep,Rep2>::type, D1::period> operator*(Rep2, D1); // returns a duration
// duration<common_type<D1::rep,Rep2>::type, D1::period> operator/( D1, Rep2); // returns a duration
// common_type<D1::rep, D2::rep>::type operator/( D1, D2); // returns a scalar
//
// A duration D1 is fully equality and less-than comparable with any other duration D2, as
// long as common_type<D1::rep, D2::rep> is well defined.
// Example:
// milliseconds ms(3); // ms.count() == 3, which is 0.003 seconds
// microseconds us = ms; // us.count() == 3000 which is 0.003000 seconds
// --us; // us.count() == 2999 which is 0.002999 seconds
// assert(ms != us); // 3 milliseconds is not equal to 2999 microseconds
// assert(ms > us); // 3 milliseconds is greater than 2999 microseconds
// ++us; // us.count() == 3000 which is 0.003000 seconds
// assert(ms == us); // 3 milliseconds is equal to 3000 microseconds
//
// Durations based on floating point representations are subject to round off error precisely the
// same way their representations are.
//
// Arithmetic and comparisons among integral-based durations is not subject to truncation error or
// round off error. If truncation error would result from the arithmetic (say
// by converting a smaller period duration to a larger one) the expression will
// not compile (unless duration_cast is used). If one performs arithmetic
// involving the duration's representation (such as division), then truncation
// will happen implicitly.
//
// Overflow error may silently happen with a duration. The std-defined durations
// have a minimum range of +/- 292 years.
//
// A duration is a thin wrapper around its representation. sizeof(duration<Rep, Period>) == sizeof(Rep).
//
// A duration can represent units as small as 10^-18 seconds (attoseconds) and as large as 10^18 seconds
// (about 30 billion years). The range of a duration is based on the range of its representation
// combined with its period.
// The cost of not including the flexibility to represent different "tick periods" in the duration
// type would be a great loss of both flexibility, convenience and safety for the client. For example
// if had just one duration type which counted nanoseconds (no matter how that count was represented),
// then clients could never have the ability to traffic in picoseconds. And the only hope of reaching
// beyond a +/- 292 year range with nanoseconds is to increase the number of bits in the representation
// (such as a long long). Furthermore, if the client wanted to traffic in units larger than a nanosecond
// (e.g. seconds) for convience, they would likely need to set up their own conversion constants and
// convert manually.
//
// If the conversion constants are specified at run time, rather than as compile time integral constants,
// then the client suffers a significant performance penalty as for every conversion one will have to
// perform both a multiplication and a division. In contrast, when converting among any two units of
// the set (hours, minutes, seconds, milliseconds, microseconds, nanoseconds), there need be only a
// single multiplication *or* division (never both). This proposal makes every unit conversion as
// efficient as if it had been coded by hand (see duration_cast). Furthermore duration_cast encapsulates
// all unit conversions within a single uniform-syntax function which is easily used in generic code. There
// is no need (or motivation) to set up a "hub-and-spoke" conversion regimen, so that the number of conversion
// functions is O(N) rather than O(N^2).
template <class Rep, class Period = ratio<1>>
requires Rep is an arithmetic type, or a class emulating an arithmetic type,
and not an instantiation of duration
requires Period is an instantiation of ratio and represents a positive fraction
class duration
{
public:
typedef Rep rep;
typedef Period period;
private:
rep rep_; // exposition only
public:
// construction / destruction
duration() = default;
template <class Rep2>
requires is_convertible<Rep2, rep>::value &&
(treat_as_floating_point<rep>::value ||
!treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value)
explicit duration(const Rep2& r);
~duration() = default;
// copy semantics
duration(const duration&) = default;
duration& operator=(const duration&) = default;
// conversions
template <class Rep2, class Period2>
requires Rep2 is explicitly convertible to rep &&
(treat_as_floating_point<rep>::value ||
!treat_as_floating_point<Rep2>::value && ratio_divide<Period2, period>::type::den == 1)
duration(const duration<Rep2, Period2>& d);
// observer
rep count() const;
// arithmetic
duration operator+() const;
duration operator-() const;
duration& operator++();
duration operator++(int);
duration& operator--();
duration operator--(int);
duration& operator+=(const duration& d);
duration& operator-=(const duration& d);
duration& operator*=(const rep& rhs);
duration& operator/=(const rep& rhs);
// special values
static constexpr duration zero();
static constexpr duration min();
static constexpr duration max();
};
// convenience typedefs
typedef duration<int_least64_t, nano> nanoseconds; // 10^-9 seconds
typedef duration<int_least55_t, micro> microseconds; // 10^-6 seconds
typedef duration<int_least45_t, milli> milliseconds; // 10^-3 seconds
typedef duration<int_least35_t > seconds; // 1 second
typedef duration<int_least29_t, ratio< 60>> minutes; // 60 seconds
typedef duration<int_least23_t, ratio<3600>> hours; // 3600 seconds
// duration_cast can be used to force a conversion between two durations (assuming
// the source representation can be explicitly converted to the target representation).
// Not all integral-based durations are implicitly convertible to another (to
// avoid accidental truncation error). When truncation error is desired, the client
// uses duration_cast to explicitly request the non-exact conversion. When
// duration_cast is used to convert between durations which have an implicit conversion,
// the behavior and performance of the conversion using duration_cast is identical to
// that of the implicit conversion.
template <class ToDuration, class Rep, class Period>
requires ToDuration is an instantiation of duration
ToDuration duration_cast(const duration<Rep, Period>& fd);
// Examples:
// microseconds us(3500); // 3500 microseconds
// milliseconds ms = us; // Does not compile (implicit truncation)
// milliseconds ms = duration_cast<milliseconds>(us); // 3 milliseconds (explicit truncation)
// us = ms; // 3000 microseconds
// us = duration_cast<microseconds>(ms); // 3000 microseconds
} // chrono
// Given two durations: duration<Rep1, Period1> and duration<Rep2, Period2>, the common_type
// of those two durations is a duration with a representation of common_type<Rep1, Rep2>,
// and a period which is the "greatest common period" of Period1 and Period2. The GCP
// (Greatest Common Period) of Period1 and Period2 is the largest period which will divide
// both Period1 and Period2 evenly (and is often equivalent to the minimum of Period1 and
// Period2). This can be computed (by the implementation at compile time) by
// GCD(Period1::num, Period2::num) / LCM(Period1::den, Period2::den) where GCD is
// "Greatest Common Divisor" and LCM is "Least Common Multiple".
template <class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2> >
{
typedef chrono::duration<typename common_type<Rep1, Rep2>::type,
ratio<GCD(Period1::num, Period2::num), LCM(Period1::den, Period2::den)>> type;
};
// Note: For any two durations D1 and D2, they will both exactly convert to common_type<D1, D2>::type.
// common_type<D1, D2>::type will have the largest possible period to make this possible, and
// may be the same type as D1 or D2. Examples:
// common_type<minutes, microseconds>::type is microseconds.
// common_type<milliseconds, microseconds>::type is microseconds.
// common_type<nanoseconds, microseconds>::type is nanoseconds.
//
// A more complex example:
// common_type< duration<long, milli>, duration<int, ratio<1,30>> >::type is
// duration<long, ratio<1,3000>>. And both duration<long, milli> and
// duration<int, ratio<1,30>> will exactly convert to duration<long, ratio<1,3000>>.
// The former multitplies its representation by 3L and the latter converts its
// representation to long and multiplies that result by 1000L. There exists no
// duration with a larger period such that both duration<long, milli> and
// duration<int, ratio<1,30>> will exactly convert to it.
namespace chrono {
template <class Rep1, class Period1, class Rep2, class Period2>
bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period, class Rep2>
requires Constructible<Rep1, typename common_type<Rep1, Rep2>::type>::value> &&
Constructible<Rep2, typename common_type<Rep1, Rep2>::type>::value>
duration<typename common_type<Rep1, Rep2>::type, Period>
operator*(const duration<Rep, Period>& d, const Rep2& s);
template <class Rep1, class Period, class Rep2>
requires Constructible<Rep1, typename common_type<Rep1, Rep2>::type>::value> &&
Constructible<Rep2, typename common_type<Rep1, Rep2>::type>::value>
duration<typename common_type<Rep1, Rep2>::type, Period>
operator*(const Rep2& s, const duration<Rep, Period>& d);
template <class Rep1, class Period, class Rep2>
requires Rep2 is not a duration &&
Constructible<Rep1, typename common_type<Rep1, Rep2>::type>::value> &&
Constructible<Rep2, typename common_type<Rep1, Rep2>::type>::value>
duration<typename common_type<Rep1, Rep2>::type, Period>
operator/(const duration<Rep, Period>& d, const Rep2& s);
// Note: the above 3 signatures can be approximated with is_convertible if concepts do not
// make it into the language. Requiring only *explicit* convertibility between the Rep
// types is strongly desired. One way or another, Rep2 must be constrained. Otherwise
// the operators are overly generic.
template <class Rep1, class Period1, class Rep2, class Period2>
typename common_type<Rep1, Rep2>::type
operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
// time_point
// A time_point represents an epoch plus or minus a duration. The relationship between a time_point
// which represents "now" and the time_point's epoch is obtained via a clock. Each time_point is
// tied to a specific clock. Thus, for any time_point, one can find the duration between that
// point in time and now, and between that point in time, and its epoch.
//
// A time_point may be default constructed. This time_point represents the epoch. time_point has
// default copy semantics.
//
// time_point may be explicitly constructed by a duration having the same representation and period as
// the time_point. Any other duration which is implicitly convertible to the time_point's "native" duration can
// also be used to explicitly construct the time_point. The meaning of this construction is identical to
// time_point() + d.
//
// A time_point is implicitly constructible from another time_point if they share the same clock,
// and the duration of this time_point is implicitly constructible from the duration of the other
// time_point. A time_point constructed in this fashion will compare equal to the source time_point
// after the construction.
//
// A time_point supports the following member arithmetic:
//
// time_point& operator+=(duration d);
// time_point& operator-=(duration d);
//
// A time_point supports the following non-member arithmetic.
// Let T1 represent time_point<Clock, Duration1>,
// T2 represent time_point<Clock, Duration2>,
// and D represent duration<Rep3, Period3>. Note that T1 and T2 must have the same Clock.
// Attempts to interoperate times having different clocks results in a compile time failure.
//
// T2 operator+(T1, D); // return type is a time_point
// T2 operator+( D, T1); // return type is a time_point
// T2 operator-(T1, D); // return type is a time_point
// D operator-(T1, T2); // return type is a duration
//
// A time_point T1 is fully equality and less-than comparable with any other time_point T2 which
// has the same clock, and for which their durations are comparable.
//
// Times based on floating point representations are subject to round off error precisely the
// same way their representations are.
//
// Times based on integral representations are not subject to truncation error or round off
// error. A compile time error will result if truncation error is possible. Truncation error
// is only possible with construction or the member arithmetic (and won't compile). Non-member
// arithmetic and comparison is always exact. Overflow error with integral based times remains a
// possibility.
//
// A time_point is a thin wrapper around its representation.
// sizeof(time_point<Clock, Duration>) == sizeof(Duration) == sizeof(Duration::rep).
//
// A time_point can represent units as small as 10^-18 seconds and as large as 10^18 seconds. The range
// of a time_point is based on the range of its representation combined with its period.
//
// Because no two clocks report the exact same time, even clocks which nominally have the same
// epoch, are considered by this framework to have different epochs, if only by a few nanoseconds.
// Converting time_points from one clock to another will involve synchronization of the clocks,
// which can be viewed as a synchronization of their epochs. Such synchronization is clock specific
// and beyond the scope of this API. A future API, or a platform specific API, can easily
// write such a synchronization API, basing it on this API.
// The cost of not including a time_point class is the lack of the ability to safely interact with
// the concept of "epoch + duration". Without a separate type, the client is in danger of accidently
// writing code that boils down to "epoch1 + duration1" + "epoch2 + duration2". Algebraically this
// results in epoch1+epoch2 as a subexpression which is likely to be completely without meaning. What
// would it mean to add New Years 1970 to the point in time at which your computer booted up? Or for
// that matter, what is the meaning of "New Years 1970" + "New Years 1970"?
//
// Additionally this would force the duration type to play double duty as a time_point leading to
// client confusion. For example POSIX has timespec represent a duration in nanosleep, and yet the
// same type is used as a time_point in pthread_cond_timedwait and pthread_mutex_timedlock. The
// confusion seems even more likely with a function such as clock_nanosleep where timespec can mean
// either a duration or a time_point depending upon another argument to the function.
//
// In C++ we can easily mitigate such errors by detecting them at compile time. This is done through
// the use of distinct types for these distinct concepts (even though both types have identical layout!).
template <class Clock, class Duration = typename Clock::duration>
requires Duration is an instantiation of duration
class time_point
{
public:
typedef Clock clock;
typedef Duration duration;
typedef typename duration::rep rep;
typedef typename duration::period period;
private:
duration d_; // exposition only
public:
time_point(); // has value "epoch"
explicit time_point(const duration& d); // same as time_point() + d
// conversions
template <class Duration2>
requires Convertible<Duration2, duration>
time_point(const time_point<clock, Duration2>& t);
// observer
duration time_since_epoch() const;
// arithmetic
time_point& operator+=(const duration& d);
time_point& operator-=(const duration& d);
// special values
static time_point min();
static time_point max();
};
} // chrono
template <class Clock, class Duration1, class Duration2>
struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2> >
{
typedef chrono::time_point<Clock, typename common_type<Duration1, Duration2>::type> type;
};
namespace chrono {
template <class ToDuration, class Clock, class Duration>
time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
template <class Clock, class Duration1, class Duration2>
bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
template <class Clock, class Duration1, class Duration2>
bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
template <class Clock, class Duration1, class Duration2>
bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
template <class Clock, class Duration1, class Duration2>
bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
template <class Clock, class Duration1, class Duration2>
bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
template <class Clock, class Duration1, class Duration2>
bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
template <class Clock, class Duration1, class Rep2, class Period2>
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Clock, class Duration2>
time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
template <class Clock, class Duration1, class Rep2, class Period2>
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Clock, class Duration1, class Duration2>
typename common_type<Duration1, Duration2>::type
operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
// clocks
// A clock specifies a representation, and a period. These specifications are used to
// to define a clock's native duration and time_point types. A clock also has a function to get the current
// time_point. A clock need not have any state.
// The cost of not including separate types for clocks is that there is no better place to
// bundle the "native" duration and time_point types for a clock with the functionality to
// get the current time_point (what time is it now?). By bundling this information into a
// type, the extension to support multiple clocks is both easy and obvious. The ability to
// easily support multiple clocks in such a flexible yet simple and efficient manner is
// very important. A client might (for example) write code with the clock as a generic
// template parameter, and then easily experiment with different timers.
class system_clock
{
public:
typedef <unspecified> rep;
typedef ratio<unspecified, unspecified> period;
typedef chrono::duration<rep, period> duration;
typedef chrono::time_point<system_clock> time_point;
static const bool is_mononontic = <unspecified>;
static time_point now();
// Map to C API
static time_t to_time_t (const time_point& t);
static time_point from_time_t(time_t t);
};
class monotonic_clock // optional
{
public:
typedef <unspecified> rep;
typedef ratio<unspecified, unspecified> period;
typedef chrono::duration<rep, period> duration;
typedef chrono::time_point<unspecified, duration> time_point;
static const bool is_mononontic = true;
static time_point now();
};
class high_resolution_clock // optional
{
public:
typedef <unspecified> rep;
typedef ratio<unspecified, unspecified> period;
typedef chrono::duration<rep, period> duration;
typedef chrono::time_point<unspecified, duration> time_point;
static const bool is_mononontic = <unspecified>;
static time_point now();
};
// Note: These clocks may be three separate types, or typedefs to one or two common types.
} // chrono
//////////////////////////
// Threading interface //
//////////////////////////
// timed_mutex
struct timed_mutex
{
public:
timed_mutex();
~timed_mutex();
timed_mutex(const timed_mutex&) = delete;
timed_mutex& operator=(const timed_mutex&) = delete;
void lock();
bool try_lock();
template <class Rep, class Period>
bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
template <class Clock, class Duration>
bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
void unlock();
typedef unspecified native_handle_type; // optional. example: pthread_mutex_t*
native_handle_type native_handle(); // optional
};
// recursive_timed_mutex
struct recursive_timed_mutex
{
public:
recursive_timed_mutex();
~recursive_timed_mutex();
recursive_timed_mutex(const recursive_timed_mutex&) = delete;
recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
void lock();
bool try_lock();
template <class Rep, class Period>
bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
template <class Clock, class Duration>
bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
void unlock();
typedef unspecified native_handle_type; // optional. example: pthread_mutex_t*
native_handle_type native_handle(); // optional
};
// unique_lock
template <class Mutex>
class unique_lock
{
public:
typedef Mutex mutex_type;
unique_lock();
explicit unique_lock(mutex_type& m);
unique_lock(mutex_type& m, defer_lock_t);
unique_lock(mutex_type& m, try_to_lock_t);
unique_lock(mutex_type& m, adopt_lock_t);
template <class Rep, class Period>
unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_t);
template <class Clock, class Duration>
unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
~unique_lock();
unique_lock(unique_lock const&) = delete;
unique_lock& operator=(unique_lock const&) = delete;
unique_lock(unique_lock&& u);
unique_lock& operator=(unique_lock&& u);
void lock();
bool try_lock();
template <class Rep, class Period>
bool try_lock_for(const chrono::duration<Rep, Period>& rel_t);
template <class Clock, class Duration>
bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
void unlock();
bool owns_lock() const;
operator unspecified-bool-type () const;
mutex_type* mutex() const;
void swap(unique_lock&& u);
mutex_type* release();
};
// condition_variable
class condition_variable
{
public:
condition_variable();
~condition_variable();
condition_variable(const condition_variable&) = delete;
condition_variable& operator=(const condition_variable&) = delete;
void notify_one();
void notify_all();
void wait(unique_lock<mutex>& lock);
template <class Predicate>
void wait(unique_lock<mutex>& lock, Predicate pred);
template <class Clock, class Duration>
bool wait_until(unique_lock<mutex>& lock,
const chrono::time_point<Clock, Duration>& abs_time);
template <class Clock, class Duration, class Predicate>
bool wait_until(unique_lock<mutex>& lock,
const chrono::time_point<Clock, Duration>& abs_time,
Predicate pred);
template <class Rep, class Period>
bool wait_for(unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& rel_time);
template <class Rep, class Period, class Predicate>
bool wait_for(unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& rel_time,
Predicate pred);
typedef pthread_cond_t* native_handle_type;
native_handle_type native_handle();
};
// condition_variable_any
class condition_variable_any
{
public:
condition_variable_any();
~condition_variable_any();
condition_variable_any(const condition_variable_any&) = delete;
condition_variable_any& operator=(const condition_variable_any&) = delete;
void notify_one();
void notify_all();
template <class Lock>
void wait(Lock& lock);
template <class Lock, class Predicate>
void wait(Lock& lock, Predicate pred);
template <class Lock, class Clock, class Duration>
bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time);
template <class Lock, class Clock, class Duration, class Predicate>
bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time,
Predicate pred);
template <class Lock, class Rep, class Period>
bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
template <class Lock, class Rep, class Period, class Predicate>
bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
};
// sleep
namespace this_thread
{
template <class Rep, class Period>
void sleep_for(const chrono::duration<Rep, Period>& rel_time);
template <class Clock, class Duration>
void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
} // this_thread
} // std
*/
#include <ctime>
#include <climits>
#include <inttypes.h>
#include <limits>
#include "type_traits"
#define decltype __typeof__
namespace std
{
//////////////////////////////////////////////////////////
////////////////////// common_type ///////////////////////
//////////////////////////////////////////////////////////
#define VARIADIC_COMMON_TYPE 0
#if VARIADIC_COMMON_TYPE == 0
template <class T, class U = void, class V = void>
struct common_type
{
public:
typedef typename common_type<typename common_type<T, U>::type, V>::type type;
};
template <class T>
struct common_type<T, void, void>
{
public:
typedef T type;
};
template <class T, class U>
struct common_type<T, U, void>
{
private:
static T t();
static U u();
// static T&& t();
// static U&& u();
public:
typedef decltype(true ? t() : u()) type;
};
#else
template <class ...T> struct common_type;
template <class T>
struct common_type<T>
{
typedef T type;
};
template <class T, class U>
struct common_type<T, U>
{
private:
static T&& t();
static U&& u();
public:
typedef decltype(true ? t() : u()) type;
};
template <class T, class U, class ...V>
struct common_type<T, U, V...>
{
typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
};
#endif
//////////////////////////////////////////////////////////
/////////////////////// ratio ////////////////////////////
//////////////////////////////////////////////////////////
// __static_gcd
template <intmax_t X, intmax_t Y>
struct __static_gcd
{
static const intmax_t value = __static_gcd<Y, X % Y>::value;
};
template <intmax_t X>
struct __static_gcd<X, 0>
{
static const intmax_t value = X;
};
// __static_lcm
template <intmax_t X, intmax_t Y>
struct __static_lcm
{
static const intmax_t value = X / __static_gcd<X, Y>::value * Y;
};
template <intmax_t X>
struct __static_abs
{
static const intmax_t value = X < 0 ? -X : X;
};
template <intmax_t X>
struct __static_sign
{
static const intmax_t value = X == 0 ? 0 : (X < 0 ? -1 : 1);
};
template <intmax_t X, intmax_t Y, intmax_t = __static_sign<Y>::value>
class __ll_add;
template <intmax_t X, intmax_t Y>
class __ll_add<X, Y, 1>
{
static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
static const intmax_t max = -min;
static char test[X <= max - Y];
// static_assert(X <= max - Y, "overflow in __ll_add");
public:
static const intmax_t value = X + Y;
};
template <intmax_t X, intmax_t Y>
class __ll_add<X, Y, 0>
{
public:
static const intmax_t value = X;
};
template <intmax_t X, intmax_t Y>
class __ll_add<X, Y, -1>
{
static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
static const intmax_t max = -min;
static char test[min - Y <= X];
// static_assert(min - Y <= X, "overflow in __ll_add");
public:
static const intmax_t value = X + Y;
};
template <intmax_t X, intmax_t Y, intmax_t = __static_sign<Y>::value>
class __ll_sub;
template <intmax_t X, intmax_t Y>
class __ll_sub<X, Y, 1>
{
static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
static const intmax_t max = -min;
static char test[min + Y <= X];
// static_assert(min + Y <= X, "overflow in __ll_sub");
public:
static const intmax_t value = X - Y;
};
template <intmax_t X, intmax_t Y>
class __ll_sub<X, Y, 0>
{
public:
static const intmax_t value = X;
};
template <intmax_t X, intmax_t Y>
class __ll_sub<X, Y, -1>
{
static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
static const intmax_t max = -min;
static char test[X <= max + Y];
// static_assert(X <= max + Y, "overflow in __ll_sub");
public:
static const intmax_t value = X - Y;
};
template <intmax_t X, intmax_t Y>
class __ll_mul
{
static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
static const intmax_t min = nan + 1;
static const intmax_t max = -min;
static const intmax_t __a_x = __static_abs<X>::value;
static const intmax_t __a_y = __static_abs<Y>::value;
static char test1[X != nan];
static char test2[Y != nan];
static char test[__a_x <= max / __a_y];
// static_assert(X != nan && Y != nan && __a_x <= max / __a_y, "overflow in __ll_mul");
public:
static const intmax_t value = X * Y;
};
template <intmax_t Y>
class __ll_mul<0, Y>
{
public:
static const intmax_t value = 0;
};
template <intmax_t X>
class __ll_mul<X, 0>
{
public:
static const intmax_t value = 0;
};
template <>
class __ll_mul<0, 0>
{
public:
static const intmax_t value = 0;
};
// Not actually used but left here in case needed in future maintenance
template <intmax_t X, intmax_t Y>
class __ll_div
{
static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
static const intmax_t min = nan + 1;
static const intmax_t max = -min;
static char test1[X != nan];
static char test2[Y != nan];
static char test3[Y != 0];
// static_assert(X != nan && Y != nan && Y != 0, "overflow in __ll_div");
public:
static const intmax_t value = X / Y;
};
template <intmax_t N, intmax_t D = 1>
class ratio
{
static char test1[__static_abs<N>::value >= 0];
static char test2[__static_abs<D>::value > 0];
// static_assert(__static_abs<N>::value >= 0, "ratio numerator is out of range");
// static_assert(D != 0, "ratio divide by 0");
// static_assert(__static_abs<D>::value > 0, "ratio denominator is out of range");
static const intmax_t __na = __static_abs<N>::value;
static const intmax_t __da = __static_abs<D>::value;
static const intmax_t __s = __static_sign<N>::value * __static_sign<D>::value;
static const intmax_t __gcd = __static_gcd<__na, __da>::value;
public:
static const intmax_t num = __s * __na / __gcd;
static const intmax_t den = __da / __gcd;
};
template <class T> struct ___is_ratio : tmp::false_type {};
template <intmax_t N, intmax_t D> struct ___is_ratio<ratio<N, D> > : tmp::true_type {};
template <class T> struct __is_ratio : ___is_ratio<typename tmp::remove_cv<T>::type> {};
typedef ratio<1LL, 1000000000000000000LL> atto;
typedef ratio<1LL, 1000000000000000LL> femto;
typedef ratio<1LL, 1000000000000LL> pico;
typedef ratio<1LL, 1000000000LL> nano;
typedef ratio<1LL, 1000000LL> micro;
typedef ratio<1LL, 1000LL> milli;
typedef ratio<1LL, 100LL> centi;
typedef ratio<1LL, 10LL> deci;
typedef ratio< 10LL, 1LL> deca;
typedef ratio< 100LL, 1LL> hecto;
typedef ratio< 1000LL, 1LL> kilo;
typedef ratio< 1000000LL, 1LL> mega;
typedef ratio< 1000000000LL, 1LL> giga;
typedef ratio< 1000000000000LL, 1LL> tera;
typedef ratio< 1000000000000000LL, 1LL> peta;
typedef ratio<1000000000000000000LL, 1LL> exa;
template <class R1, class R2>
struct ratio_add
{
typedef ratio<__ll_add<__ll_mul<R1::num, R2::den>::value,
__ll_mul<R1::den, R2::num>::value>::value,
__ll_mul<R1::den, R2::den>::value> type;
};
template <class R1, class R2>
struct ratio_subtract
{
typedef ratio<__ll_sub<__ll_mul<R1::num, R2::den>::value,
__ll_mul<R1::den, R2::num>::value>::value,
__ll_mul<R1::den, R2::den>::value> type;
};
template <class R1, class R2>
struct ratio_multiply
{
typedef ratio<__ll_mul<R1::num, R2::num>::value, __ll_mul<R1::den, R2::den>::value> type;
};
template <class R1, class R2>
struct ratio_divide
{
typedef ratio<__ll_mul<R1::num, R2::den>::value, __ll_mul<R1::den, R2::num>::value> type;
};
// ratio_equal
template <class R1, class R2>
struct ratio_equal
: public tmp::integral_constant<bool, R1::num == R2::num && R1::den == R2::den> {};
template <class R1, class R2>
struct ratio_not_equal
: public tmp::integral_constant<bool, !ratio_equal<R1, R2>::value> {};
// ratio_less
// Protect against overflow, and still get the right answer as much as possible.
// This just demonstrates for fun how far you can push things without hitting
// overflow. The obvious and simple implementation is conforming.
template <class R1, class R2, bool ok1, bool ok2>
struct __ratio_less3 // true, true and false, false
{
static const bool value = __ll_mul<R1::num, R2::den>::value < __ll_mul<R2::num, R1::den>::value;
};
template <class R1, class R2>
struct __ratio_less3<R1, R2, true, false>
{
static const bool value = true;
};
template <class R1, class R2>
struct __ratio_less3<R1, R2, false, true>
{
static const bool value = false;
};
template <class R1, class R2, bool = R1::num < R1::den == R2::num < R2::den>
struct __ratio_less2 // N1 < D1 == N2 < D2
{
static const intmax_t max = -((1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
static const bool ok1 = R1::num <= max / R2::den;
static const bool ok2 = R2::num <= max / R1::den;
static const bool value = __ratio_less3<R1, R2, ok1, ok2>::value;
};
template <class R1, class R2>
struct __ratio_less2<R1, R2, false> // N1 < D1 != N2 < D2
{
static const bool value = R1::num < R1::den;
};
template <class R1, class R2, bool = R1::num < R1::den == R2::num < R2::den>
struct __ratio_less1 // N1 < D1 == N2 < D2
{
static const bool value = __ratio_less2<ratio<R1::num, R2::num>, ratio<R1::den, R2::den> >::value;
};
template <class R1, class R2>
struct __ratio_less1<R1, R2, false> // N1 < D1 != N2 < D2
{
static const bool value = R1::num < R1::den;
};
template <class R1, class R2, intmax_t S1 = __static_sign<R1::num>::value,
intmax_t S2 = __static_sign<R2::num>::value>
struct __ratio_less
{
static const bool value = S1 < S2;
};
template <class R1, class R2>
struct __ratio_less<R1, R2, 1LL, 1LL>
{
static const bool value = __ratio_less1<R1, R2>::value;
};
template <class R1, class R2>
struct __ratio_less<R1, R2, -1LL, -1LL>
{
static const bool value = __ratio_less1<ratio<-R2::num, R2::den>, ratio<-R1::num, R1::den> >::value;
};
template <class R1, class R2>
struct ratio_less
: public tmp::integral_constant<bool, __ratio_less<R1, R2>::value> {};
template <class R1, class R2>
struct ratio_less_equal
: public tmp::integral_constant<bool, !ratio_less<R2, R1>::value> {};
template <class R1, class R2>
struct ratio_greater
: public tmp::integral_constant<bool, ratio_less<R2, R1>::value> {};
template <class R1, class R2>
struct ratio_greater_equal
: public tmp::integral_constant<bool, !ratio_less<R1, R2>::value> {};
template <class R1, class R2>
struct __ratio_gcd
{
typedef ratio<__static_gcd<R1::num, R2::num>::value,
__static_lcm<R1::den, R2::den>::value> type;
};
//////////////////////////////////////////////////////////
////////////////////// duration //////////////////////////
//////////////////////////////////////////////////////////
namespace chrono
{
template <class RepType, class Period = ratio<1> > class duration;
template <class T> struct ___is_duration : tmp::false_type {};
template <class Rep, class Period> struct ___is_duration<duration<Rep, Period> > : tmp::true_type {};
template <class T> struct __is_duration : ___is_duration<typename tmp::remove_cv<T>::type> {};
// duration_cast
// duration_cast is the heart of this whole prototype. It can convert any
// duration to any other. It is also (implicitly) used in converting
// time_points. The conversion is always exact if possible. And it is
// always as efficient as hand written code. If different representations
// are involved, care is taken to never require implicit conversions.
// Instead static_cast is used explicitly for every required conversion.
// If there are a mixture of integral and floating point representations,
// the use of common_type ensures that the most logical "intermediate"
// representation is used.
template <class FromDuration, class ToDuration,
class Period = typename ratio_divide<typename FromDuration::period, typename ToDuration::period>::type,
bool = Period::num == 1,
bool = Period::den == 1>
struct __duration_cast;
// When the two periods are the same, all that is left to do is static_cast from
// the source representation to the target representation (which may be a no-op).
// This conversion is always exact as long as the static_cast from the source
// representation to the destination representation is exact.
template <class FromDuration, class ToDuration, class Period>
struct __duration_cast<FromDuration, ToDuration, Period, true, true>
{
ToDuration operator()(const FromDuration& fd) const
{
return ToDuration(static_cast<typename ToDuration::rep>(fd.count()));
}
};
// When the numerator of FromPeriod / ToPeriod is 1, then all we need to do is
// divide by the denominator of FromPeriod / ToPeriod. The common_type of
// the two representations is used for the intermediate computation before
// static_cast'ing to the destination.
// This conversion is generally not exact because of the division (but could be
// if you get lucky on the run time value of fd.count()).
template <class FromDuration, class ToDuration, class Period>
struct __duration_cast<FromDuration, ToDuration, Period, true, false>
{
ToDuration operator()(const FromDuration& fd) const
{
typedef typename common_type<typename ToDuration::rep, typename FromDuration::rep, intmax_t>::type C;
return ToDuration(static_cast<typename ToDuration::rep>(
static_cast<C>(fd.count()) / static_cast<C>(Period::den)));
}
};
// When the denomenator of FromPeriod / ToPeriod is 1, then all we need to do is
// multiply by the numerator of FromPeriod / ToPeriod. The common_type of
// the two representations is used for the intermediate computation before
// static_cast'ing to the destination.
// This conversion is always exact as long as the static_cast's involved are exact.
template <class FromDuration, class ToDuration, class Period>
struct __duration_cast<FromDuration, ToDuration, Period, false, true>
{
ToDuration operator()(const FromDuration& fd) const
{
typedef typename common_type<typename ToDuration::rep, typename FromDuration::rep, intmax_t>::type C;
return ToDuration(static_cast<typename ToDuration::rep>(
static_cast<C>(fd.count()) * static_cast<C>(Period::num)));
}
};
// When neither the numerator or denominator of FromPeriod / ToPeriod is 1, then we need to
// multiply by the numerator and divide by the denominator of FromPeriod / ToPeriod. The
// common_type of the two representations is used for the intermediate computation before
// static_cast'ing to the destination.
// This conversion is generally not exact because of the division (but could be
// if you get lucky on the run time value of fd.count()).
template <class FromDuration, class ToDuration, class Period>
struct __duration_cast<FromDuration, ToDuration, Period, false, false>
{
ToDuration operator()(const FromDuration& fd) const
{
typedef typename common_type<typename ToDuration::rep, typename FromDuration::rep, intmax_t>::type C;
return ToDuration(static_cast<typename ToDuration::rep>(
static_cast<C>(fd.count()) * static_cast<C>(Period::num) / static_cast<C>(Period::den)));
}
};
// Compile-time select the most efficient algorithm for the conversion...
template <class ToDuration, class Rep, class Period>
inline
typename tmp::enable_if
<
__is_duration<ToDuration>::value,
ToDuration
>::type
duration_cast(const duration<Rep, Period>& fd)
{
return __duration_cast<duration<Rep, Period>, ToDuration>()(fd);
}
// Support bidirectional (non-exact) conversions for floating point rep types
// (or user defined rep types which specialize treat_as_floating_point).
template <class Rep> struct treat_as_floating_point : tmp::is_floating_point<Rep> {};
template <class Rep>
struct duration_values
{
static Rep __min_imp(tmp::false_type) {return -max();}
static Rep __min_imp(tmp::true_type) {return zero();}
public:
static Rep zero() {return Rep(0);}
static Rep max() {return numeric_limits<Rep>::max();}
static Rep min() {return __min_imp(tmp::is_unsigned<Rep>());}
};
// duration
template <class Rep, class Period>
class duration
{
static char test0[!__is_duration<Rep>::value];
// static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration");
static char test1[__is_ratio<Period>::value];
// static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio");
static char test2[Period::num > 0];
// static_assert(Period::num > 0, "duration period must be positive");
public:
typedef Rep rep;
typedef Period period;
private:
rep rep_;
public:
duration() {} // = default;
template <class Rep2>
explicit duration(const Rep2& r,
typename tmp::enable_if
<
tmp::is_convertible<Rep2, rep>::value &&
(treat_as_floating_point<rep>::value ||
!treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value)
>::type* = 0)
: rep_(r) {}
// conversions
template <class Rep2, class Period2>
duration(const duration<Rep2, Period2>& d,
typename tmp::enable_if
<
treat_as_floating_point<rep>::value ||
(ratio_divide<Period2, period>::type::den == 1 && !treat_as_floating_point<Rep2>::value)
>::type* = 0)
: rep_(duration_cast<duration>(d).count()) {}
// observer
rep count() const {return rep_;}
// arithmetic
duration operator+() const {return *this;}
duration operator-() const {return duration(-rep_);}
duration& operator++() {++rep_; return *this;}
duration operator++(int) {return duration(rep_++);}
duration& operator--() {--rep_; return *this;}
duration operator--(int) {return duration(rep_--);}
duration& operator+=(const duration& d) {rep_ += d.count(); return *this;}
duration& operator-=(const duration& d) {rep_ -= d.count(); return *this;}
duration& operator*=(const rep& rhs) {rep_ *= rhs; return *this;}
duration& operator/=(const rep& rhs) {rep_ /= rhs; return *this;}
// special values
static duration zero() {return duration(duration_values<rep>::zero());}
static duration min() {return duration(duration_values<rep>::min());}
static duration max() {return duration(duration_values<rep>::max());}
};
typedef duration<long long, nano> nanoseconds;
typedef duration<long long, micro> microseconds;
typedef duration<long long, milli> milliseconds;
typedef duration<long long > seconds;
typedef duration< long, ratio< 60> > minutes;
typedef duration< long, ratio<3600> > hours;
} // chrono
template <class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2> >
{
typedef chrono::duration<typename common_type<Rep1, Rep2>::type,
typename __ratio_gcd<Period1, Period2>::type> type;
};
namespace chrono {
// Duration ==
template <class LhsDuration, class RhsDuration>
struct __duration_eq
{
bool operator()(const LhsDuration& lhs, const RhsDuration& rhs)
{
typedef typename common_type<LhsDuration, RhsDuration>::type CD;
return CD(lhs).count() == CD(rhs).count();
}
};
template <class LhsDuration>
struct __duration_eq<LhsDuration, LhsDuration>
{
bool operator()(const LhsDuration& lhs, const LhsDuration& rhs)
{return lhs.count() == rhs.count();}
};
template <class Rep1, class Period1, class Rep2, class Period2>
inline
bool
operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
return __duration_eq<duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
}
// Duration !=
template <class Rep1, class Period1, class Rep2, class Period2>
inline
bool
operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
return !(lhs == rhs);
}
// Duration <
template <class LhsDuration, class RhsDuration>
struct __duration_lt
{
bool operator()(const LhsDuration& lhs, const RhsDuration& rhs)
{
typedef typename common_type<LhsDuration, RhsDuration>::type CD;
return CD(lhs).count() < CD(rhs).count();
}
};
template <class LhsDuration>
struct __duration_lt<LhsDuration, LhsDuration>
{
bool operator()(const LhsDuration& lhs, const LhsDuration& rhs)
{return lhs.count() < rhs.count();}
};
template <class Rep1, class Period1, class Rep2, class Period2>
inline
bool
operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
return __duration_lt<duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
}
// Duration >
template <class Rep1, class Period1, class Rep2, class Period2>
inline
bool
operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
return rhs < lhs;
}
// Duration <=
template <class Rep1, class Period1, class Rep2, class Period2>
inline
bool
operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
return !(rhs < lhs);
}
// Duration >=
template <class Rep1, class Period1, class Rep2, class Period2>
inline
bool
operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
return !(lhs < rhs);
}
// Duration +
template <class Rep1, class Period1, class Rep2, class Period2>
inline
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type result = lhs;
result += rhs;
return result;
}
// Duration -
template <class Rep1, class Period1, class Rep2, class Period2>
inline
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type result = lhs;
result -= rhs;
return result;
}
// Duration *
template <class Rep1, class Period, class Rep2>
inline
typename tmp::enable_if
<
tmp::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>::value &&
tmp::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>::value,
duration<typename common_type<Rep1, Rep2>::type, Period>
>::type
operator*(const duration<Rep1, Period>& d, const Rep2& s)
{
typedef typename common_type<Rep1, Rep2>::type CR;
duration<CR, Period> r = d;
r *= static_cast<CR>(s);
return r;
}
template <class Rep1, class Period, class Rep2>
inline
typename tmp::enable_if
<
tmp::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>::value &&
tmp::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>::value,
duration<typename common_type<Rep1, Rep2>::type, Period>
>::type
operator*(const Rep1& s, const duration<Rep2, Period>& d)
{
return d * s;
}
// Duration /
template <class Duration, class Rep, bool = __is_duration<Rep>::value>
struct __duration_divide_result
{
};
template <class Duration, class Rep2,
bool = tmp::is_convertible<typename Duration::rep,
typename common_type<typename Duration::rep, Rep2>::type>::value &&
tmp::is_convertible<Rep2,
typename common_type<typename Duration::rep, Rep2>::type>::value>
struct __duration_divide_imp
{
};
template <class Rep1, class Period, class Rep2>
struct __duration_divide_imp<duration<Rep1, Period>, Rep2, true>
{
typedef duration<typename common_type<Rep1, Rep2>::type, Period> type;
};
template <class Rep1, class Period, class Rep2>
struct __duration_divide_result<duration<Rep1, Period>, Rep2, false>
: __duration_divide_imp<duration<Rep1, Period>, Rep2>
{
};
template <class Rep1, class Period, class Rep2>
inline
typename __duration_divide_result<duration<Rep1, Period>, Rep2>::type
operator/(const duration<Rep1, Period>& d, const Rep2& s)
{
typedef typename common_type<Rep1, Rep2>::type CR;
duration<CR, Period> r = d;
r /= static_cast<CR>(s);
return r;
}
template <class Rep1, class Period1, class Rep2, class Period2>
inline
typename common_type<Rep1, Rep2>::type
operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
{
typedef typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type CD;
return CD(lhs).count() / CD(rhs).count();
}
//////////////////////////////////////////////////////////
///////////////////// time_point /////////////////////////
//////////////////////////////////////////////////////////
template <class Clock, class Duration = typename Clock::duration>
class time_point
{
static char test1[__is_duration<Duration>::value];
// static_assert(__is_duration<Duration>::value,
// "Second template parameter of time_point must be a std::chrono::duration");
public:
typedef Clock clock;
typedef Duration duration;
typedef typename duration::rep rep;
typedef typename duration::period period;
private:
duration d_;
public:
time_point() : d_(duration::zero()) {}
explicit time_point(const duration& d) : d_(d) {}
// conversions
template <class Duration2>
time_point(const time_point<clock, Duration2>& t,
typename tmp::enable_if
<
tmp::is_convertible<Duration2, duration>::value
>::type* = 0)
: d_(t.time_since_epoch()) {}
// observer
duration time_since_epoch() const {return d_;}
// arithmetic
time_point& operator+=(const duration& d) {d_ += d; return *this;}
time_point& operator-=(const duration& d) {d_ -= d; return *this;}
// special values
static time_point min() {return time_point(duration::min());}
static time_point max() {return time_point(duration::max());}
};
} // chrono
template <class Clock, class Duration1, class Duration2>
struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2> >
{
typedef chrono::time_point<Clock, typename common_type<Duration1, Duration2>::type> type;
};
namespace chrono {
template <class ToDuration, class Clock, class Duration>
inline
time_point<Clock, ToDuration>
time_point_cast(const time_point<Clock, Duration>& t)
{
return time_point<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()));
}
// time_point ==
template <class Clock, class Duration1, class Duration2>
inline
bool
operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs)
{
return lhs.time_since_epoch() == rhs.time_since_epoch();
}
// time_point !=
template <class Clock, class Duration1, class Duration2>
inline
bool
operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs)
{
return !(lhs == rhs);
}
// time_point <
template <class Clock, class Duration1, class Duration2>
inline
bool
operator<(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs)
{
return lhs.time_since_epoch() < rhs.time_since_epoch();
}
// time_point >
template <class Clock, class Duration1, class Duration2>
inline
bool
operator>(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs)
{
return rhs < lhs;
}
// time_point <=
template <class Clock, class Duration1, class Duration2>
inline
bool
operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs)
{
return !(rhs < lhs);
}
// time_point >=
template <class Clock, class Duration1, class Duration2>
inline
bool
operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs)
{
return !(lhs < rhs);
}
// time_point operator+(time_point x, duration y);
template <class Clock, class Duration1, class Rep2, class Period2>
inline
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs)
{
typedef time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type> TimeResult;
TimeResult r(lhs);
r += rhs;
return r;
}
// time_point operator+(duration x, time_point y);
template <class Rep1, class Period1, class Clock, class Duration2>
inline
time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs)
{
return rhs + lhs;
}
// time_point operator-(time_point x, duration y);
template <class Clock, class Duration1, class Rep2, class Period2>
inline
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs)
{
return lhs + (-rhs);
}
// duration operator-(time_point x, time_point y);
template <class Clock, class Duration1, class Duration2>
inline
typename common_type<Duration1, Duration2>::type
operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs)
{
return lhs.time_since_epoch() - rhs.time_since_epoch();
}
//////////////////////////////////////////////////////////
/////////////////////// clocks ///////////////////////////
//////////////////////////////////////////////////////////
// If you're porting, clocks are the system-specific (non-portable) part.
// You'll need to know how to get the current time and implement that under now().
// You'll need to know what units (tick period) and representation makes the most
// sense for your clock and set those accordingly.
// If you know how to map this clock to time_t (perhaps your clock is std::time, which
// makes that trivial), then you can fill out system_clock's to_time_t() and from_time_t().
class system_clock
{
public:
typedef microseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef chrono::time_point<system_clock> time_point;
static const bool is_monotonic = false;
static time_point now();
static time_t to_time_t (const time_point& t);
static time_point from_time_t(time_t t);
};
class monotonic_clock
{
public:
typedef nanoseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef chrono::time_point<monotonic_clock> time_point;
static const bool is_monotonic = true;
static time_point now();
};
typedef monotonic_clock high_resolution_clock;
} // chrono
} // std
// clocks.cpp
#include <sys/time.h> //for gettimeofday and timeval
#include <mach/mach_time.h> // mach_absolute_time, mach_timebase_info_data_t
namespace std {
namespace chrono {
// system_clock
// gettimeofday is the most precise "system time" available on this platform.
// It returns the number of microseconds since New Years 1970 in a struct called timeval
// which has a field for seconds and a field for microseconds.
// Fill in the timeval and then convert that to the time_point
system_clock::time_point
system_clock::now()
{
timeval tv;
gettimeofday(&tv, 0);
return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
}
// Take advantage of the fact that on this platform time_t is nothing but
// an integral count of seconds since New Years 1970 (same epoch as timeval).
// Just get the duration out of the time_point and truncate it to seconds.
time_t
system_clock::to_time_t(const time_point& t)
{
return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
}
// Just turn the time_t into a count of seconds and construct a time_point with it.
system_clock::time_point
system_clock::from_time_t(time_t t)
{
return system_clock::time_point(seconds(t));
}
// monotonic_clock
// Note, in this implementation monotonic_clock and high_resolution_clock
// are the same clock. They are both based on mach_absolute_time().
// mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of
// nanoseconds since the computer booted up. MachInfo.numer and MachInfo.denom
// are run time constants supplied by the OS. This clock has no relationship
// to the Gregorian calendar. It's main use is as a high resolution timer.
// MachInfo.numer / MachInfo.denom is often 1 on the latest equipment. Specialize
// for that case as an optimization.
static
monotonic_clock::rep
monotonic_simplified()
{
return mach_absolute_time();
}
static
double
compute_monotonic_factor()
{
mach_timebase_info_data_t MachInfo;
mach_timebase_info(&MachInfo);
return static_cast<double>(MachInfo.numer) / MachInfo.denom;
}
static
monotonic_clock::rep
monotonic_full()
{
static const double factor = compute_monotonic_factor();
return static_cast<monotonic_clock::rep>(mach_absolute_time() * factor);
}
typedef monotonic_clock::rep (*FP)();
static
FP
init_monotonic_clock()
{
mach_timebase_info_data_t MachInfo;
mach_timebase_info(&MachInfo);
if (MachInfo.numer == MachInfo.denom)
return &monotonic_simplified;
return &monotonic_full;
}
monotonic_clock::time_point
monotonic_clock::now()
{
static FP fp = init_monotonic_clock();
return time_point(duration(fp()));
}
// clocks.cpp end
} } // std::chrono
//////////////////////////////////////////////////////////
///////////// simulated thread interface /////////////////
//////////////////////////////////////////////////////////
#include <iostream>
namespace std {
void __print_time(chrono::system_clock::time_point t)
{
using namespace chrono;
time_t c_time = system_clock::to_time_t(t);
std::tm* tmptr = std::localtime(&c_time);
system_clock::duration d = t.time_since_epoch();
std::cout << tmptr->tm_hour << ':' << tmptr->tm_min << ':' << tmptr->tm_sec
<< '.' << (d - duration_cast<seconds>(d)).count();
}
namespace this_thread {
template <class Rep, class Period>
void sleep_for(const chrono::duration<Rep, Period>& d)
{
chrono::microseconds t = chrono::duration_cast<chrono::microseconds>(d);
if (t < d)
++t;
if (t > chrono::microseconds(0))
std::cout << "sleep_for " << t.count() << " microseconds\n";
}
template <class Clock, class Duration>
void sleep_until(const chrono::time_point<Clock, Duration>& t)
{
using namespace chrono;
typedef time_point<Clock, Duration> Time;
typedef system_clock::time_point SysTime;
if (t > Clock::now())
{
typedef typename common_type<typename Time::duration, typename SysTime::duration>::type D;
/* auto */ D d = t - Clock::now();
microseconds us = duration_cast<microseconds>(d);
if (us < d)
++us;
SysTime st = system_clock::now() + us;
std::cout << "sleep_until ";
__print_time(st);
std::cout << " which is " << (st - system_clock::now()).count() << " microseconds away\n";
}
}
} // this_thread
struct mutex {};
struct timed_mutex
{
bool try_lock() {std::cout << "timed_mutex::try_lock()\n";}
template <class Rep, class Period>
bool try_lock_for(const chrono::duration<Rep, Period>& d)
{
chrono::microseconds t = chrono::duration_cast<chrono::microseconds>(d);
if (t <= chrono::microseconds(0))
return try_lock();
std::cout << "try_lock_for " << t.count() << " microseconds\n";
return true;
}
template <class Clock, class Duration>
bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
{
using namespace chrono;
typedef time_point<Clock, Duration> Time;
typedef system_clock::time_point SysTime;
if (t <= Clock::now())
return try_lock();
typedef typename common_type<typename Time::duration, typename Clock::duration>::type D;
/* auto */ D d = t - Clock::now();
microseconds us = duration_cast<microseconds>(d);
SysTime st = system_clock::now() + us;
std::cout << "try_lock_until ";
__print_time(st);
std::cout << " which is " << (st - system_clock::now()).count() << " microseconds away\n";
}
};
struct condition_variable
{
template <class Rep, class Period>
bool wait_for(mutex&, const chrono::duration<Rep, Period>& d)
{
chrono::microseconds t = chrono::duration_cast<chrono::microseconds>(d);
std::cout << "wait_for " << t.count() << " microseconds\n";
return true;
}
template <class Clock, class Duration>
bool wait_until(mutex&, const chrono::time_point<Clock, Duration>& t)
{
using namespace chrono;
typedef time_point<Clock, Duration> Time;
typedef system_clock::time_point SysTime;
if (t <= Clock::now())
return false;
typedef typename common_type<typename Time::duration, typename Clock::duration>::type D;
/* auto */ D d = t - Clock::now();
microseconds us = duration_cast<microseconds>(d);
SysTime st = system_clock::now() + us;
std::cout << "wait_until ";
__print_time(st);
std::cout << " which is " << (st - system_clock::now()).count() << " microseconds away\n";
}
};
} // std
//////////////////////////////////////////////////////////
/////////////////// End of implemetation ////////////////
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//////////// Simple sleep and wait examples //////////////
//////////////////////////////////////////////////////////
std::mutex m;
std::timed_mutex mut;
std::condition_variable cv;
void basic_examples()
{
std::cout << "Running basic examples\n";
using namespace std;
using namespace std::chrono;
system_clock::time_point time_limit = system_clock::now() + seconds(4) + milliseconds(500);
this_thread::sleep_for(seconds(3));
this_thread::sleep_for(nanoseconds(300));
this_thread::sleep_until(time_limit);
// this_thread::sleep_for(time_limit); // desired compile-time error
// this_thread::sleep_until(seconds(3)); // desired compile-time error
mut.try_lock_for(milliseconds(30));
mut.try_lock_until(time_limit);
// mut.try_lock_for(time_limit); // desired compile-time error
// mut.try_lock_until(milliseconds(30)); // desired compile-time error
cv.wait_for(m, minutes(1)); // real code would put this in a loop
cv.wait_until(m, time_limit); // real code would put this in a loop
// For those who prefer floating point
this_thread::sleep_for(duration<double>(0.25));
this_thread::sleep_until(system_clock::now() + duration<double>(1.5));
}
//////////////////////////////////////////////////////////
//////////////////// User1 Example ///////////////////////
//////////////////////////////////////////////////////////
namespace User1
{
// Example type-safe "physics" code interoperating with std::chrono::duration types
// and taking advantage of the std::ratio infrastructure and design philosophy.
// length - mimics std::chrono::duration except restricts representation to double.
// Uses std::ratio facilities for length units conversions.
template <class Ratio>
class length
{
public:
typedef Ratio ratio;
private:
double len_;
public:
length() : len_(1) {}
length(const double& len) : len_(len) {}
// conversions
template <class R>
length(const length<R>& d)
: len_(d.count() * std::ratio_divide<Ratio, R>::type::den /
std::ratio_divide<Ratio, R>::type::num) {}
// observer
double count() const {return len_;}
// arithmetic
length& operator+=(const length& d) {len_ += d.count(); return *this;}
length& operator-=(const length& d) {len_ -= d.count(); return *this;}
length operator+() const {return *this;}
length operator-() const {return length(-len_);}
length& operator*=(double rhs) {len_ *= rhs; return *this;}
length& operator/=(double rhs) {len_ /= rhs; return *this;}
};
// Sparse sampling of length units
typedef length<std::ratio<1> > meter; // set meter as "unity"
typedef length<std::centi> centimeter; // 1/100 meter
typedef length<std::kilo> kilometer; // 1000 meters
typedef length<std::ratio<254, 10000> > inch; // 254/10000 meters
// length takes ratio instead of two integral types so that definitions can be made like so:
typedef length<std::ratio_multiply<std::ratio<12>, inch::ratio>::type> foot; // 12 inchs
typedef length<std::ratio_multiply<std::ratio<5280>, foot::ratio>::type> mile; // 5280 feet
// Need a floating point definition of seconds
typedef std::chrono::duration<double> seconds; // unity
// Demo of (scientific) support for sub-nanosecond resolutions
typedef std::chrono::duration<double, std::pico> picosecond; // 10^-12 seconds
typedef std::chrono::duration<double, std::femto> femtosecond; // 10^-15 seconds
typedef std::chrono::duration<double, std::atto> attosecond; // 10^-18 seconds
// A very brief proof-of-concept for SIUnits-like library
// Hard-wired to floating point seconds and meters, but accepts other units (shown in testUser1())
template <class R1, class R2>
class quantity
{
double q_;
public:
quantity() : q_(1) {}
double get() const {return q_;}
void set(double q) {q_ = q;}
};
template <>
class quantity<std::ratio<1>, std::ratio<0> >
{
double q_;
public:
quantity() : q_(1) {}
quantity(seconds d) : q_(d.count()) {} // note: only User1::seconds needed here
double get() const {return q_;}
void set(double q) {q_ = q;}
};
template <>
class quantity<std::ratio<0>, std::ratio<1> >
{
double q_;
public:
quantity() : q_(1) {}
quantity(meter d) : q_(d.count()) {} // note: only User1::meter needed here
double get() const {return q_;}
void set(double q) {q_ = q;}
};
template <>
class quantity<std::ratio<0>, std::ratio<0> >
{
double q_;
public:
quantity() : q_(1) {}
quantity(double d) : q_(d) {}
double get() const {return q_;}
void set(double q) {q_ = q;}
};
// Example SI-Units
typedef quantity<std::ratio<0>, std::ratio<0> > Scalar;
typedef quantity<std::ratio<1>, std::ratio<0> > Time; // second
typedef quantity<std::ratio<0>, std::ratio<1> > Distance; // meter
typedef quantity<std::ratio<-1>, std::ratio<1> > Speed; // meter/second
typedef quantity<std::ratio<-2>, std::ratio<1> > Acceleration; // meter/second^2
template <class R1, class R2, class R3, class R4>
quantity<typename std::ratio_subtract<R1, R3>::type, typename std::ratio_subtract<R2, R4>::type>
operator/(const quantity<R1, R2>& x, const quantity<R3, R4>& y)
{
typedef quantity<typename std::ratio_subtract<R1, R3>::type, typename std::ratio_subtract<R2, R4>::type> R;
R r;
r.set(x.get() / y.get());
return r;
}
template <class R1, class R2, class R3, class R4>
quantity<typename std::ratio_add<R1, R3>::type, typename std::ratio_add<R2, R4>::type>
operator*(const quantity<R1, R2>& x, const quantity<R3, R4>& y)
{
typedef quantity<typename std::ratio_add<R1, R3>::type, typename std::ratio_add<R2, R4>::type> R;
R r;
r.set(x.get() * y.get());
return r;
}
template <class R1, class R2>
quantity<R1, R2>
operator+(const quantity<R1, R2>& x, const quantity<R1, R2>& y)
{
typedef quantity<R1, R2> R;
R r;
r.set(x.get() + y.get());
return r;
}
template <class R1, class R2>
quantity<R1, R2>
operator-(const quantity<R1, R2>& x, const quantity<R1, R2>& y)
{
typedef quantity<R1, R2> R;
R r;
r.set(x.get() - y.get());
return r;
}
// Example type-safe physics function
Distance
compute_distance(Speed v0, Time t, Acceleration a)
{
return v0 * t + Scalar(.5) * a * t * t; // if a units mistake is made here it won't compile
}
} // User1
#include <iostream>
// Exercise example type-safe physics function and show interoperation
// of custom time durations (User1::seconds) and standard time durations (std::hours).
// Though input can be arbitrary (but type-safe) units, output is always in SI-units
// (a limitation of the simplified Units lib demoed here).
void testUser1()
{
std::cout << "*************\n";
std::cout << "* testUser1 *\n";
std::cout << "*************\n";
User1::Distance d( User1::mile(110) );
User1::Time t( std::chrono::hours(2) );
User1::Speed s = d / t;
std::cout << "Speed = " << s.get() << " meters/sec\n";
User1::Acceleration a = User1::Distance( User1::foot(32.2) ) / User1::Time() / User1::Time();
std::cout << "Acceleration = " << a.get() << " meters/sec^2\n";
User1::Distance df = compute_distance(s, User1::Time( User1::seconds(0.5) ), a);
std::cout << "Distance = " << df.get() << " meters\n";
std::cout << "There are " << User1::mile::ratio::den << '/' << User1::mile::ratio::num << " miles/meter";
User1::meter mt = 1;
User1::mile mi = mt;
std::cout << " which is approximately " << mi.count() << '\n';
std::cout << "There are " << User1::mile::ratio::num << '/' << User1::mile::ratio::den << " meters/mile";
mi = 1;
mt = mi;
std::cout << " which is approximately " << mt.count() << '\n';
User1::attosecond as(1);
User1::seconds sec = as;
std::cout << "1 attosecond is " << sec.count() << " seconds\n";
std::cout << "sec = as; // compiles\n";
sec = User1::seconds(1);
as = sec;
std::cout << "1 second is " << as.count() << " attoseconds\n";
std::cout << "as = sec; // compiles\n";
std::cout << "\n";
}
//////////////////////////////////////////////////////////
//////////////////// User2 Example ///////////////////////
//////////////////////////////////////////////////////////
// Demonstrate User2:
// A "saturating" signed integral type is developed. This type has +/- infinity and a nan
// (like IEEE floating point) but otherwise obeys signed integral arithmetic.
// This class is subsequently used as the rep in std::chrono::duration to demonstrate a
// duration class that does not silently ignore overflow.
#include <ostream>
#include <stdexcept>
#include <climits>
namespace User2
{
template <class I>
class saturate
{
public:
typedef I int_type;
static const int_type nan = int_type(int_type(1) << (sizeof(int_type) * CHAR_BIT - 1));
static const int_type neg_inf = nan + 1;
static const int_type pos_inf = -neg_inf;
private:
int_type i_;
// static_assert(std::is_integral<int_type>::value && std::is_signed<int_type>::value,
// "saturate only accepts signed integral types");
// static_assert(nan == -nan && neg_inf < pos_inf,
// "saturate assumes two's complement hardware for signed integrals");
public:
saturate() : i_(nan) {}
explicit saturate(int_type i) : i_(i) {}
// explicit
operator int_type() const;
saturate& operator+=(saturate x);
saturate& operator-=(saturate x) {return *this += -x;}
saturate& operator*=(saturate x);
saturate& operator/=(saturate x);
saturate& operator%=(saturate x);
saturate operator- () const {return saturate(-i_);}
saturate& operator++() {*this += saturate(int_type(1)); return *this;}
saturate operator++(int) {saturate tmp(*this); ++(*this); return tmp;}
saturate& operator--() {*this -= saturate(int_type(1)); return *this;}
saturate operator--(int) {saturate tmp(*this); --(*this); return tmp;}
friend saturate operator+(saturate x, saturate y) {return x += y;}
friend saturate operator-(saturate x, saturate y) {return x -= y;}
friend saturate operator*(saturate x, saturate y) {return x *= y;}
friend saturate operator/(saturate x, saturate y) {return x /= y;}
friend saturate operator%(saturate x, saturate y) {return x %= y;}
friend bool operator==(saturate x, saturate y)
{
if (x.i_ == nan || y.i_ == nan)
return false;
return x.i_ == y.i_;
}
friend bool operator!=(saturate x, saturate y) {return !(x == y);}
friend bool operator<(saturate x, saturate y)
{
if (x.i_ == nan || y.i_ == nan)
return false;
return x.i_ < y.i_;
}
friend bool operator<=(saturate x, saturate y)
{
if (x.i_ == nan || y.i_ == nan)
return false;
return x.i_ <= y.i_;
}
friend bool operator>(saturate x, saturate y)
{
if (x.i_ == nan || y.i_ == nan)
return false;
return x.i_ > y.i_;
}
friend bool operator>=(saturate x, saturate y)
{
if (x.i_ == nan || y.i_ == nan)
return false;
return x.i_ >= y.i_;
}
friend std::ostream& operator<<(std::ostream& os, saturate s)
{
switch (s.i_)
{
case pos_inf:
return os << "inf";
case nan:
return os << "nan";
case neg_inf:
return os << "-inf";
};
return os << s.i_;
}
};
template <class I>
saturate<I>::operator int_type() const
{
switch (i_)
{
case nan:
case neg_inf:
case pos_inf:
throw std::out_of_range("saturate special value can not convert to int_type");
}
return i_;
}
template <class I>
saturate<I>&
saturate<I>::operator+=(saturate x)
{
switch (i_)
{
case pos_inf:
switch (x.i_)
{
case neg_inf:
case nan:
i_ = nan;
}
return *this;
case nan:
return *this;
case neg_inf:
switch (x.i_)
{
case pos_inf:
case nan:
i_ = nan;
}
return *this;
}
switch (x.i_)
{
case pos_inf:
case neg_inf:
case nan:
i_ = x.i_;
return *this;
}
if (x.i_ >= 0)
{
if (i_ < pos_inf - x.i_)
i_ += x.i_;
else
i_ = pos_inf;
return *this;
}
if (i_ > neg_inf - x.i_)
i_ += x.i_;
else
i_ = neg_inf;
return *this;
}
template <class I>
saturate<I>&
saturate<I>::operator*=(saturate x)
{
switch (i_)
{
case 0:
switch (x.i_)
{
case pos_inf:
case neg_inf:
case nan:
i_ = nan;
}
return *this;
case pos_inf:
switch (x.i_)
{
case nan:
case 0:
i_ = nan;
return *this;
}
if (x.i_ < 0)
i_ = neg_inf;
return *this;
case nan:
return *this;
case neg_inf:
switch (x.i_)
{
case nan:
case 0:
i_ = nan;
return *this;
}
if (x.i_ < 0)
i_ = pos_inf;
return *this;
}
switch (x.i_)
{
case 0:
i_ = 0;
return *this;
case nan:
i_ = nan;
return *this;
case pos_inf:
if (i_ < 0)
i_ = neg_inf;
else
i_ = pos_inf;
return *this;
case neg_inf:
if (i_ < 0)
i_ = pos_inf;
else
i_ = neg_inf;
return *this;
}
int s = (i_ < 0 ? -1 : 1) * (x.i_ < 0 ? -1 : 1);
i_ = i_ < 0 ? -i_ : i_;
int_type x_i_ = x.i_ < 0 ? -x.i_ : x.i_;
if (i_ <= pos_inf / x_i_)
i_ *= x_i_;
else
i_ = pos_inf;
i_ *= s;
return *this;
}
template <class I>
saturate<I>&
saturate<I>::operator/=(saturate x)
{
switch (x.i_)
{
case pos_inf:
case neg_inf:
switch (i_)
{
case pos_inf:
case neg_inf:
case nan:
i_ = nan;
break;
default:
i_ = 0;
break;
}
return *this;
case nan:
i_ = nan;
return *this;
case 0:
switch (i_)
{
case pos_inf:
case neg_inf:
case nan:
return *this;
case 0:
i_ = nan;
return *this;
}
if (i_ > 0)
i_ = pos_inf;
else
i_ = neg_inf;
return *this;
}
switch (i_)
{
case 0:
case nan:
return *this;
case pos_inf:
case neg_inf:
if (x.i_ < 0)
i_ = -i_;
return *this;
}
i_ /= x.i_;
return *this;
}
template <class I>
saturate<I>&
saturate<I>::operator%=(saturate x)
{
// *this -= *this / x * x; // definition
switch (x.i_)
{
case nan:
case neg_inf:
case 0:
case pos_inf:
i_ = nan;
return *this;
}
switch (i_)
{
case neg_inf:
case pos_inf:
i_ = nan;
case nan:
return *this;
}
i_ %= x.i_;
return *this;
}
// Demo overflow-safe integral durations ranging from picoseconds resolution to millennium resolution
typedef std::chrono::duration<saturate<long long>, std::pico > picoseconds;
typedef std::chrono::duration<saturate<long long>, std::nano > nanoseconds;
typedef std::chrono::duration<saturate<long long>, std::micro > microseconds;
typedef std::chrono::duration<saturate<long long>, std::milli > milliseconds;
typedef std::chrono::duration<saturate<long long> > seconds;
typedef std::chrono::duration<saturate<long long>, std::ratio< 60LL> > minutes;
typedef std::chrono::duration<saturate<long long>, std::ratio< 3600LL> > hours;
typedef std::chrono::duration<saturate<long long>, std::ratio< 86400LL> > days;
typedef std::chrono::duration<saturate<long long>, std::ratio< 31556952LL> > years;
typedef std::chrono::duration<saturate<long long>, std::ratio<31556952000LL> > millennium;
} // User2
// Demonstrate custom promotion rules (needed only if there are no implicit conversions)
namespace User2 { namespace detail {
template <class T1, class T2, bool = tmp::is_integral<T1>::value>
struct promote_helper;
template <class T1, class T2>
struct promote_helper<T1, saturate<T2>, true> // integral
{
typedef typename std::common_type<T1, T2>::type rep;
typedef User2::saturate<rep> type;
};
template <class T1, class T2>
struct promote_helper<T1, saturate<T2>, false> // floating
{
typedef T1 type;
};
} }
namespace std
{
template <class T1, class T2>
struct common_type<User2::saturate<T1>, User2::saturate<T2> >
{
typedef typename common_type<T1, T2>::type rep;
typedef User2::saturate<rep> type;
};
template <class T1, class T2>
struct common_type<T1, User2::saturate<T2> >
: User2::detail::promote_helper<T1, User2::saturate<T2> > {};
template <class T1, class T2>
struct common_type<User2::saturate<T1>, T2>
: User2::detail::promote_helper<T2, User2::saturate<T1> > {};
// Demonstrate specialization of duration_values:
namespace chrono {
template <class I>
struct duration_values<User2::saturate<I> >
{
typedef User2::saturate<I> Rep;
public:
static Rep zero() {return Rep(0);}
static Rep max() {return Rep(Rep::pos_inf-1);}
static Rep min() {return -max();}
};
}
}
#include <iostream>
void testUser2()
{
std::cout << "*************\n";
std::cout << "* testUser2 *\n";
std::cout << "*************\n";
using namespace User2;
typedef seconds::rep sat;
years yr(sat(100));
std::cout << "100 years expressed as years = " << yr.count() << '\n';
nanoseconds ns = yr;
std::cout << "100 years expressed as nanoseconds = " << ns.count() << '\n';
ns += yr;
std::cout << "200 years expressed as nanoseconds = " << ns.count() << '\n';
ns += yr;
std::cout << "300 years expressed as nanoseconds = " << ns.count() << '\n';
// yr = ns; // does not compile
std::cout << "yr = ns; // does not compile\n";
// picoseconds ps1 = yr; // does not compile, compile-time overflow in ratio arithmetic
std::cout << "ps = yr; // does not compile\n";
ns = yr;
picoseconds ps = ns;
std::cout << "100 years expressed as picoseconds = " << ps.count() << '\n';
ps = ns / sat(1000);
std::cout << "0.1 years expressed as picoseconds = " << ps.count() << '\n';
yr = years(sat(-200000000));
std::cout << "200 million years ago encoded in years: " << yr.count() << '\n';
days d = std::chrono::duration_cast<days>(yr);
std::cout << "200 million years ago encoded in days: " << d.count() << '\n';
millennium c = std::chrono::duration_cast<millennium>(yr);
std::cout << "200 million years ago encoded in millennium: " << c.count() << '\n';
std::cout << "Demonstrate \"uninitialized protection\" behavior:\n";
seconds sec;
for (++sec; sec < seconds(sat(10)); ++sec)
;
std::cout << sec.count() << '\n';
std::cout << "\n";
}
void testStdUser()
{
std::cout << "***************\n";
std::cout << "* testStdUser *\n";
std::cout << "***************\n";
using namespace std::chrono;
hours hr = hours(100);
std::cout << "100 hours expressed as hours = " << hr.count() << '\n';
nanoseconds ns = hr;
std::cout << "100 hours expressed as nanoseconds = " << ns.count() << '\n';
ns += hr;
std::cout << "200 hours expressed as nanoseconds = " << ns.count() << '\n';
ns += hr;
std::cout << "300 hours expressed as nanoseconds = " << ns.count() << '\n';
// hr = ns; // does not compile
std::cout << "hr = ns; // does not compile\n";
// hr * ns; // does not compile
std::cout << "hr * ns; // does not compile\n";
duration<double> fs(2.5);
std::cout << "duration<double> has count() = " << fs.count() << '\n';
// seconds sec = fs; // does not compile
std::cout << "seconds sec = duration<double> won't compile\n";
seconds sec = duration_cast<seconds>(fs);
std::cout << "seconds has count() = " << sec.count() << '\n';
std::cout << "\n";
}
// timeval clock demo
// Demonstrate the use of a timeval-like struct to be used as the representation
// type for both duraiton and time_point.
namespace timeval_demo
{
class xtime {
private:
long tv_sec;
long tv_usec;
void fixup() {
if (tv_usec < 0) {
tv_usec += 1000000;
--tv_sec;
}
}
public:
explicit xtime(long sec, long usec) {
tv_sec = sec;
tv_usec = usec;
if (tv_usec < 0 || tv_usec >= 1000000) {
tv_sec += tv_usec / 1000000;
tv_usec %= 1000000;
fixup();
}
}
explicit xtime(long long usec)
{
tv_usec = static_cast<long>(usec % 1000000);
tv_sec = static_cast<long>(usec / 1000000);
fixup();
}
// explicit
operator long long() const {return static_cast<long long>(tv_sec) * 1000000 + tv_usec;}
xtime& operator += (xtime rhs) {
tv_sec += rhs.tv_sec;
tv_usec += rhs.tv_usec;
if (tv_usec >= 1000000) {
tv_usec -= 1000000;
++tv_sec;
}
return *this;
}
xtime& operator -= (xtime rhs) {
tv_sec -= rhs.tv_sec;
tv_usec -= rhs.tv_usec;
fixup();
return *this;
}
xtime& operator %= (xtime rhs) {
long long t = tv_sec * 1000000 + tv_usec;
long long r = rhs.tv_sec * 1000000 + rhs.tv_usec;
t %= r;
tv_sec = t / 1000000;
tv_usec = t % 1000000;
fixup();
return *this;
}
friend xtime operator+(xtime x, xtime y) {return x += y;}
friend xtime operator-(xtime x, xtime y) {return x -= y;}
friend xtime operator%(xtime x, xtime y) {return x %= y;}
friend bool operator==(xtime x, xtime y)
{ return (x.tv_sec == y.tv_sec && x.tv_usec == y.tv_usec); }
friend bool operator<(xtime x, xtime y) {
if (x.tv_sec == y.tv_sec)
return (x.tv_usec < y.tv_usec);
return (x.tv_sec < y.tv_sec);
}
friend bool operator!=(xtime x, xtime y) { return !(x == y); }
friend bool operator> (xtime x, xtime y) { return y < x; }
friend bool operator<=(xtime x, xtime y) { return !(y < x); }
friend bool operator>=(xtime x, xtime y) { return !(x < y); }
friend std::ostream& operator<<(std::ostream& os, xtime x)
{return os << '{' << x.tv_sec << ',' << x.tv_usec << '}';}
};
class xtime_clock
{
public:
typedef xtime