/usr/include/boost/chrono
Edit: /usr/include/boost/chrono/duration.hpp (30251B)
// duration.hpp --------------------------------------------------------------//
// Copyright 2008 Howard Hinnant
// Copyright 2008 Beman Dawes
// Copyright 2009-2011 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
/*
This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
Many thanks to Howard for making his code available under the Boost license.
The original code was modified to conform to Boost conventions and to section
20.9 Time utilities [time] of the C++ committee's working paper N2798.
See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
time2_demo contained this comment:
Much thanks to Andrei Alexandrescu,
Walter Brown,
Peter Dimov,
Jeff Garland,
Terry Golubiewski,
Daniel Krugler,
Anthony Williams.
*/
#ifndef BOOST_CHRONO_DURATION_HPP
#define BOOST_CHRONO_DURATION_HPP
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_CHRONO_USES_MPL_ASSERT)
#define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION "A duration representation can not be a duration"
#define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO "Second template parameter of duration must be a boost::ratio"
#define BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE "duration period must be positive"
#define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_CHRONO_DURATION "Second template parameter of time_point must be a boost::chrono::duration"
#endif
#ifndef BOOST_CHRONO_HEADER_ONLY
// this must occur after all of the includes and before any code appears:
#include // must be the last #include
#endif
//----------------------------------------------------------------------------//
// //
// 20.9 Time utilities [time] //
// synopsis //
// //
//----------------------------------------------------------------------------//
namespace boost {
namespace chrono {
template >
class duration;
namespace detail
{
template
struct is_duration
: boost::false_type {};
template
struct is_duration >
: boost::true_type {};
template ::value>
struct duration_divide_result
{
};
template ::type>::value))
&& ((boost::is_convertible::type>::value))
)
>
struct duration_divide_imp
{
};
template
struct duration_divide_imp, Rep2, true>
{
typedef duration::type, Period> type;
};
template
struct duration_divide_result, Rep2, false>
: duration_divide_imp, Rep2>
{
};
///
template ::value>
struct duration_divide_result2
{
};
template ::type>::value))
&& ((boost::is_convertible::type>::value))
)
>
struct duration_divide_imp2
{
};
template
struct duration_divide_imp2, true>
{
//typedef typename common_type::type type;
typedef double type;
};
template
struct duration_divide_result2, false>
: duration_divide_imp2 >
{
};
///
template ::value>
struct duration_modulo_result
{
};
template ::type>::value
//&&
boost::is_convertible::type>::value
)
>
struct duration_modulo_imp
{
};
template
struct duration_modulo_imp, Rep2, true>
{
typedef duration::type, Period> type;
};
template
struct duration_modulo_result, Rep2, false>
: duration_modulo_imp, Rep2>
{
};
} // namespace detail
} // namespace chrono
// common_type trait specializations
template
struct common_type,
chrono::duration >;
namespace chrono {
// customization traits
template struct treat_as_floating_point;
template struct duration_values;
// convenience typedefs
typedef duration nanoseconds; // at least 64 bits needed
typedef duration microseconds; // at least 55 bits needed
typedef duration milliseconds; // at least 45 bits needed
typedef duration seconds; // at least 35 bits needed
typedef duration > minutes; // at least 29 bits needed
typedef duration > hours; // at least 23 bits needed
//----------------------------------------------------------------------------//
// duration helpers //
//----------------------------------------------------------------------------//
namespace detail
{
// 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
struct duration_cast_aux;
// 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
struct duration_cast_aux
{
BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const
{
return ToDuration(static_cast(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
struct duration_cast_aux
{
BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const
{
typedef typename common_type<
typename ToDuration::rep,
typename FromDuration::rep,
boost::intmax_t>::type C;
return ToDuration(static_cast(
static_cast(fd.count()) / static_cast(Period::den)));
}
};
// When the denominator 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
struct duration_cast_aux
{
BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const
{
typedef typename common_type<
typename ToDuration::rep,
typename FromDuration::rep,
boost::intmax_t>::type C;
return ToDuration(static_cast(
static_cast(fd.count()) * static_cast(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
struct duration_cast_aux
{
BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const
{
typedef typename common_type<
typename ToDuration::rep,
typename FromDuration::rep,
boost::intmax_t>::type C;
return ToDuration(static_cast(
static_cast(fd.count()) * static_cast(Period::num)
/ static_cast(Period::den)));
}
};
template
struct duration_cast {
typedef typename ratio_divide::type Period;
typedef duration_cast_aux<
FromDuration,
ToDuration,
Period,
Period::num == 1,
Period::den == 1
> Aux;
BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const
{
return Aux()(fd);
}
};
} // namespace detail
//----------------------------------------------------------------------------//
// //
// 20.9.2 Time-related traits [time.traits] //
// //
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
// 20.9.2.1 treat_as_floating_point [time.traits.is_fp] //
// Probably should have been treat_as_floating_point. Editor notifed. //
//----------------------------------------------------------------------------//
// Support bidirectional (non-exact) conversions for floating point rep types
// (or user defined rep types which specialize treat_as_floating_point).
template
struct treat_as_floating_point : boost::is_floating_point {};
//----------------------------------------------------------------------------//
// 20.9.2.2 duration_values [time.traits.duration_values] //
//----------------------------------------------------------------------------//
namespace detail {
template ::value>
struct chrono_numeric_limits {
static BOOST_CHRONO_LIB_CONSTEXPR T lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW {return (std::numeric_limits::min) ();}
};
template
struct chrono_numeric_limits {
static BOOST_CHRONO_LIB_CONSTEXPR T lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW {return (std::numeric_limits::min) ();}
};
template <>
struct chrono_numeric_limits {
static BOOST_CHRONO_LIB_CONSTEXPR float lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW
{
return -(std::numeric_limits::max) ();
}
};
template <>
struct chrono_numeric_limits {
static BOOST_CHRONO_LIB_CONSTEXPR double lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW
{
return -(std::numeric_limits::max) ();
}
};
template <>
struct chrono_numeric_limits {
static BOOST_CHRONO_LIB_CONSTEXPR long double lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW
{
return -(std::numeric_limits::max)();
}
};
template
struct numeric_limits : chrono_numeric_limits::type>
{};
}
template
struct duration_values
{
static BOOST_CONSTEXPR Rep zero() {return Rep(0);}
static BOOST_CHRONO_LIB_CONSTEXPR Rep max BOOST_PREVENT_MACRO_SUBSTITUTION ()
{
return (std::numeric_limits::max)();
}
static BOOST_CHRONO_LIB_CONSTEXPR Rep min BOOST_PREVENT_MACRO_SUBSTITUTION ()
{
return detail::numeric_limits::lowest();
}
};
} // namespace chrono
//----------------------------------------------------------------------------//
// 20.9.2.3 Specializations of common_type [time.traits.specializations] //
//----------------------------------------------------------------------------//
template
struct common_type,
chrono::duration >
{
typedef chrono::duration::type,
typename boost::ratio_gcd::type> type;
};
//----------------------------------------------------------------------------//
// //
// 20.9.3 Class template duration [time.duration] //
// //
//----------------------------------------------------------------------------//
namespace chrono {
template
class BOOST_SYMBOL_VISIBLE duration
{
//BOOST_CHRONO_STATIC_ASSERT(boost::is_integral::value, BOOST_CHRONO_A_DURATION_REPRESENTATION_MUST_BE_INTEGRAL, ());
BOOST_CHRONO_STATIC_ASSERT(!boost::chrono::detail::is_duration::value,
BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION, ());
BOOST_CHRONO_STATIC_ASSERT(boost::ratio_detail::is_ratio::value,
BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO, ());
BOOST_CHRONO_STATIC_ASSERT(Period::num>0,
BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE, ());
public:
typedef Rep rep;
typedef Period period;
private:
rep rep_;
public:
#if defined BOOST_CHRONO_DURATION_DEFAULTS_TO_ZERO
BOOST_FORCEINLINE BOOST_CONSTEXPR
duration() : rep_(duration_values::zero()) { }
#elif defined BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
BOOST_CONSTEXPR duration() {}
#else
BOOST_CONSTEXPR duration() = default;
#endif
template
BOOST_SYMBOL_VISIBLE BOOST_FORCEINLINE BOOST_CONSTEXPR
explicit duration(const Rep2& r
, typename boost::enable_if <
mpl::and_ <
boost::is_convertible,
mpl::or_ <
treat_as_floating_point,
mpl::and_ <
mpl::not_ < treat_as_floating_point >,
mpl::not_ < treat_as_floating_point >
>
>
>
>::type* = 0
) : rep_(r) { }
#if defined BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
duration& operator=(const duration& rhs)
{
if (&rhs != this) rep_= rhs.rep_;
return *this;
}
#else
duration& operator=(const duration& rhs) = default;
#endif
// conversions
template
BOOST_FORCEINLINE BOOST_CONSTEXPR
duration(const duration& d
, typename boost::enable_if <
mpl::or_ <
treat_as_floating_point,
mpl::and_ <
chrono_detail::is_evenly_divisible_by,
mpl::not_ < treat_as_floating_point >
>
>
>::type* = 0
)
: rep_(chrono::detail::duration_cast, duration>()(d).count()) {}
// observer
BOOST_CONSTEXPR
rep count() const {return rep_;}
// arithmetic
BOOST_CONSTEXPR
duration operator+() const {return duration(rep_);;}
BOOST_CONSTEXPR
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;}
duration& operator%=(const rep& rhs) {rep_ %= rhs; return *this;}
duration& operator%=(const duration& rhs)
{
rep_ %= rhs.count(); return *this;
}
// 20.9.3.4 duration special values [time.duration.special]
static BOOST_CONSTEXPR duration zero()
{
return duration(duration_values::zero());
}
static BOOST_CHRONO_LIB_CONSTEXPR duration min BOOST_PREVENT_MACRO_SUBSTITUTION ()
{
return duration((duration_values::min)());
}
static BOOST_CHRONO_LIB_CONSTEXPR duration max BOOST_PREVENT_MACRO_SUBSTITUTION ()
{
return duration((duration_values::max)());
}
};
//----------------------------------------------------------------------------//
// 20.9.3.5 duration non-member arithmetic [time.duration.nonmember] //
//----------------------------------------------------------------------------//
// Duration +
template
inline BOOST_CONSTEXPR
typename common_type, duration >::type
operator+(const duration& lhs,
const duration& rhs)
{
typedef typename common_type,
duration >::type common_duration;
return common_duration(common_duration(lhs).count()+common_duration(rhs).count());
}
// Duration -
template
inline BOOST_CONSTEXPR
typename common_type, duration >::type
operator-(const duration& lhs,
const duration& rhs)
{
typedef typename common_type,
duration >::type common_duration;
return common_duration(common_duration(lhs).count()-common_duration(rhs).count());
}
// Duration *
template
inline BOOST_CONSTEXPR
typename boost::enable_if <
mpl::and_ <
boost::is_convertible::type>,
boost::is_convertible::type>
>,
duration::type, Period>
>::type
operator*(const duration& d, const Rep2& s)
{
typedef typename common_type::type common_rep;
typedef duration common_duration;
return common_duration(common_duration(d).count()*static_cast(s));
}
template
inline BOOST_CONSTEXPR
typename boost::enable_if <
mpl::and_ <
boost::is_convertible::type>,
boost::is_convertible::type>
>,
duration::type, Period>
>::type
operator*(const Rep1& s, const duration& d)
{
return d * s;
}
// Duration /
template
inline BOOST_CONSTEXPR
typename boost::disable_if ,
typename boost::chrono::detail::duration_divide_result<
duration, Rep2>::type
>::type
operator/(const duration& d, const Rep2& s)
{
typedef typename common_type::type common_rep;
typedef duration common_duration;
return common_duration(common_duration(d).count()/static_cast(s));
}
template
inline BOOST_CONSTEXPR
typename common_type::type
operator/(const duration& lhs, const duration& rhs)
{
typedef typename common_type,
duration >::type common_duration;
return common_duration(lhs).count() / common_duration(rhs).count();
}
#ifdef BOOST_CHRONO_EXTENSIONS
template
inline BOOST_CONSTEXPR
typename boost::disable_if ,
typename boost::chrono::detail::duration_divide_result2<
Rep1, duration >::type
>::type
operator/(const Rep1& s, const duration& d)
{
typedef typename common_type::type common_rep;
typedef duration common_duration;
return static_cast(s)/common_duration(d).count();
}
#endif
// Duration %
template
inline BOOST_CONSTEXPR
typename boost::disable_if ,
typename boost::chrono::detail::duration_modulo_result<
duration, Rep2>::type
>::type
operator%(const duration& d, const Rep2& s)
{
typedef typename common_type::type common_rep;
typedef duration common_duration;
return common_duration(common_duration(d).count()%static_cast(s));
}
template
inline BOOST_CONSTEXPR
typename common_type, duration >::type
operator%(const duration& lhs,
const duration& rhs) {
typedef typename common_type,
duration >::type common_duration;
return common_duration(common_duration(lhs).count()%common_duration(rhs).count());
}
//----------------------------------------------------------------------------//
// 20.9.3.6 duration comparisons [time.duration.comparisons] //
//----------------------------------------------------------------------------//
namespace detail
{
template
struct duration_eq
{
BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const
{
typedef typename common_type::type common_duration;
return common_duration(lhs).count() == common_duration(rhs).count();
}
};
template
struct duration_eq
{
BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const LhsDuration& rhs) const
{
return lhs.count() == rhs.count();
}
};
template
struct duration_lt
{
BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const
{
typedef typename common_type::type common_duration;
return common_duration(lhs).count() < common_duration(rhs).count();
}
};
template
struct duration_lt
{
BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const LhsDuration& rhs) const
{
return lhs.count() < rhs.count();
}
};
} // namespace detail
// Duration ==
template
inline BOOST_CONSTEXPR
bool
operator==(const duration& lhs,
const duration& rhs)
{
return boost::chrono::detail::duration_eq<
duration, duration >()(lhs, rhs);
}
// Duration !=
template
inline BOOST_CONSTEXPR
bool
operator!=(const duration& lhs,
const duration& rhs)
{
return !(lhs == rhs);
}
// Duration <
template
inline BOOST_CONSTEXPR
bool
operator< (const duration& lhs,
const duration& rhs)
{
return boost::chrono::detail::duration_lt<
duration, duration >()(lhs, rhs);
}
// Duration >
template
inline BOOST_CONSTEXPR
bool
operator> (const duration& lhs,
const duration& rhs)
{
return rhs < lhs;
}
// Duration <=
template
inline BOOST_CONSTEXPR
bool
operator<=(const duration& lhs,
const duration& rhs)
{
return !(rhs < lhs);
}
// Duration >=
template
inline BOOST_CONSTEXPR
bool
operator>=(const duration& lhs,
const duration& rhs)
{
return !(lhs < rhs);
}
//----------------------------------------------------------------------------//
// 20.9.3.7 duration_cast [time.duration.cast] //
//----------------------------------------------------------------------------//
// Compile-time select the most efficient algorithm for the conversion...
template
inline BOOST_CONSTEXPR
typename boost::enable_if <
boost::chrono::detail::is_duration, ToDuration>::type
duration_cast(const duration& fd)
{
return boost::chrono::detail::duration_cast<
duration, ToDuration>()(fd);
}
} // namespace chrono
} // namespace boost
#ifndef BOOST_CHRONO_HEADER_ONLY
// the suffix header occurs after all of our code:
#include // pops abi_prefix.hpp pragmas
#endif
#endif // BOOST_CHRONO_DURATION_HPP