27 Time library [time]

27.4 Time-related traits [time.traits]

27.4.1 treat_­as_­floating_­point [time.traits.is.fp]

🔗
template<class Rep> struct treat_as_floating_point : is_floating_point<Rep> { };
1
#
The duration template uses the treat_­as_­floating_­point trait to help determine if a duration object can be converted to another duration with a different tick period.
If treat_­as_­floating_­point_­v<Rep> is true, then implicit conversions are allowed among durations.
Otherwise, the implicit convertibility depends on the tick periods of the durations.
[Note
:
The intention of this trait is to indicate whether a given class behaves like a floating-point type, and thus allows division of one value by another with acceptable loss of precision.
If treat_­as_­floating_­point_­v<Rep> is false, Rep will be treated as if it behaved like an integral type for the purpose of these conversions.
— end note
]

27.4.2 duration_­values [time.traits.duration.values]

🔗
template<class Rep> struct duration_values { public: static constexpr Rep zero() noexcept; static constexpr Rep min() noexcept; static constexpr Rep max() noexcept; };
1
#
The duration template uses the duration_­values trait to construct special values of the duration's representation (Rep).
This is done because the representation might be a class type with behavior which requires some other implementation to return these special values.
In that case, the author of that class type should specialize duration_­values to return the indicated values.
🔗
static constexpr Rep zero() noexcept;
2
#
Returns: Rep(0).
[Note
:
Rep(0) is specified instead of Rep() because Rep() may have some other meaning, such as an uninitialized value.
— end note
]
3
#
Remarks: The value returned shall be the additive identity.
🔗
static constexpr Rep min() noexcept;
4
#
Returns: numeric_­limits<Rep>​::​lowest().
5
#
Remarks: The value returned shall compare less than or equal to zero().
🔗
static constexpr Rep max() noexcept;
6
#
Returns: numeric_­limits<Rep>​::​max().
7
#
Remarks: The value returned shall compare greater than zero().

27.4.3 Specializations of common_­type [time.traits.specializations]

🔗
template<class Rep1, class Period1, class Rep2, class Period2> struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>> { using type = chrono::duration<common_type_t<Rep1, Rep2>, see below>; };
1
#
The period of the duration indicated by this specialization of common_­type is the greatest common divisor of Period1 and Period2.
[Note
:
This can be computed by forming a ratio of the greatest common divisor of Period1​::​num and Period2​::​num and the least common multiple of Period1​::​den and Period2​::​den.
— end note
]
2
#
[Note
:
The typedef name type is a synonym for the duration with the largest tick period possible where both duration arguments will convert to it without requiring a division operation.
The representation of this type is intended to be able to hold any value resulting from this conversion with no truncation error, although floating-point durations may have round-off errors.
— end note
]
🔗
template<class Clock, class Duration1, class Duration2> struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>> { using type = chrono::time_point<Clock, common_type_t<Duration1, Duration2>>; };
3
#
The common type of two time_­point types is a time_­point with the same clock as the two types and the common type of their two durations.

27.4.4 Class template is_­clock [time.traits.is.clock]

🔗
template<class T> struct is_clock;
1
#
is_­clock is a Cpp17UnaryTypeTrait ([meta.rqmts]) with a base characteristic of true_­type if T meets the Cpp17Clock requirements ([time.clock.req]), otherwise false_­type.
For the purposes of the specification of this trait, the extent to which an implementation determines that a type cannot meet the Cpp17Clock requirements is unspecified, except that as a minimum a type T shall not qualify as a Cpp17Clock unless it meets all of the following conditions:
  • (1.1)
    the qualified-ids T​::​rep, T​::​period, T​::​duration, and T​::​time_­point are valid and each denotes a type ([temp.deduct]),
  • (1.2)
    the expression T​::​is_­steady is well-formed when treated as an unevaluated operand,
  • (1.3)
    the expression T​::​now() is well-formed when treated as an unevaluated operand.
2
#
The behavior of a program that adds specializations for is_­clock is undefined.