380 lines
13 KiB
C++
380 lines
13 KiB
C++
// duration.hpp --------------------------------------------------------------//
|
|
|
|
// Copyright 2008 Howard Hinnant
|
|
// Copyright 2008 Beman Dawes
|
|
// Copyright 2009-2012 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_TIME_POINT_HPP
|
|
#define BOOST_CHRONO_TIME_POINT_HPP
|
|
|
|
#include <boost/chrono/duration.hpp>
|
|
#include <iostream>
|
|
|
|
#ifndef BOOST_CHRONO_HEADER_ONLY
|
|
// this must occur after all of the includes and before any code appears:
|
|
#include <boost/config/abi_prefix.hpp> // must be the last #include
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------//
|
|
// //
|
|
// 20.9 Time utilities [time] //
|
|
// synopsis //
|
|
// //
|
|
//----------------------------------------------------------------------------//
|
|
|
|
namespace boost {
|
|
namespace chrono {
|
|
|
|
template <class Clock, class Duration = typename Clock::duration>
|
|
class time_point;
|
|
|
|
|
|
} // namespace chrono
|
|
|
|
|
|
// common_type trait specializations
|
|
|
|
template <class Clock, class Duration1, class Duration2>
|
|
struct common_type<chrono::time_point<Clock, Duration1>,
|
|
chrono::time_point<Clock, Duration2> >;
|
|
|
|
|
|
//----------------------------------------------------------------------------//
|
|
// 20.9.2.3 Specializations of common_type [time.traits.specializations] //
|
|
//----------------------------------------------------------------------------//
|
|
|
|
|
|
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 {
|
|
|
|
// time_point arithmetic
|
|
template <class Clock, class Duration1, class Rep2, class Period2>
|
|
inline BOOST_CONSTEXPR
|
|
time_point<Clock,
|
|
typename common_type<Duration1, duration<Rep2, Period2> >::type>
|
|
operator+(
|
|
const time_point<Clock, Duration1>& lhs,
|
|
const duration<Rep2, Period2>& rhs);
|
|
template <class Rep1, class Period1, class Clock, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
time_point<Clock,
|
|
typename common_type<duration<Rep1, Period1>, Duration2>::type>
|
|
operator+(
|
|
const duration<Rep1, Period1>& lhs,
|
|
const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Rep2, class Period2>
|
|
inline BOOST_CONSTEXPR
|
|
time_point<Clock,
|
|
typename common_type<Duration1, duration<Rep2, Period2> >::type>
|
|
operator-(
|
|
const time_point<Clock, Duration1>& lhs,
|
|
const duration<Rep2, Period2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
typename common_type<Duration1, Duration2>::type
|
|
operator-(
|
|
const time_point<Clock, Duration1>& lhs,
|
|
const time_point<Clock,
|
|
Duration2>& rhs);
|
|
|
|
// time_point comparisons
|
|
template <class Clock, class Duration1, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
bool operator==(
|
|
const time_point<Clock, Duration1>& lhs,
|
|
const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
bool operator!=(
|
|
const time_point<Clock, Duration1>& lhs,
|
|
const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
bool operator< (
|
|
const time_point<Clock, Duration1>& lhs,
|
|
const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
bool operator<=(
|
|
const time_point<Clock, Duration1>& lhs,
|
|
const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
bool operator> (
|
|
const time_point<Clock, Duration1>& lhs,
|
|
const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
bool operator>=(
|
|
const time_point<Clock, Duration1>& lhs,
|
|
const time_point<Clock, Duration2>& rhs);
|
|
|
|
// time_point_cast
|
|
template <class ToDuration, class Clock, class Duration>
|
|
inline BOOST_CONSTEXPR
|
|
time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
|
|
|
|
//----------------------------------------------------------------------------//
|
|
// //
|
|
// 20.9.4 Class template time_point [time.point] //
|
|
// //
|
|
//----------------------------------------------------------------------------//
|
|
|
|
template <class Clock, class Duration>
|
|
class time_point
|
|
{
|
|
BOOST_CHRONO_STATIC_ASSERT(boost::chrono::detail::is_duration<Duration>::value,
|
|
BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_CHRONO_DURATION, (Duration));
|
|
public:
|
|
typedef Clock clock;
|
|
typedef Duration duration;
|
|
typedef typename duration::rep rep;
|
|
typedef typename duration::period period;
|
|
typedef Duration difference_type;
|
|
|
|
private:
|
|
duration d_;
|
|
|
|
public:
|
|
BOOST_CONSTEXPR
|
|
time_point() : d_(duration::zero())
|
|
{}
|
|
BOOST_CONSTEXPR explicit time_point(const duration& d)
|
|
: d_(d)
|
|
{}
|
|
|
|
// conversions
|
|
template <class Duration2>
|
|
BOOST_CONSTEXPR
|
|
time_point(const time_point<clock, Duration2>& t
|
|
, typename boost::enable_if
|
|
<
|
|
boost::is_convertible<Duration2, duration>
|
|
>::type* = 0
|
|
)
|
|
: d_(t.time_since_epoch())
|
|
{
|
|
}
|
|
// observer
|
|
|
|
BOOST_CONSTEXPR
|
|
duration time_since_epoch() const
|
|
{
|
|
return d_;
|
|
}
|
|
|
|
// arithmetic
|
|
|
|
#ifdef BOOST_CHRONO_EXTENSIONS
|
|
BOOST_CONSTEXPR
|
|
time_point operator+() const {return *this;}
|
|
BOOST_CONSTEXPR
|
|
time_point operator-() const {return time_point(-d_);}
|
|
time_point& operator++() {++d_; return *this;}
|
|
time_point operator++(int) {return time_point(d_++);}
|
|
time_point& operator--() {--d_; return *this;}
|
|
time_point operator--(int) {return time_point(d_--);}
|
|
|
|
time_point& operator+=(const rep& r) {d_ += duration(r); return *this;}
|
|
time_point& operator-=(const rep& r) {d_ -= duration(r); return *this;}
|
|
|
|
#endif
|
|
|
|
time_point& operator+=(const duration& d) {d_ += d; return *this;}
|
|
time_point& operator-=(const duration& d) {d_ -= d; return *this;}
|
|
|
|
// special values
|
|
|
|
static BOOST_CHRONO_LIB_CONSTEXPR time_point
|
|
min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
|
{
|
|
return time_point((duration::min)());
|
|
}
|
|
static BOOST_CHRONO_LIB_CONSTEXPR time_point
|
|
max BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
|
{
|
|
return time_point((duration::max)());
|
|
}
|
|
};
|
|
|
|
//----------------------------------------------------------------------------//
|
|
// 20.9.4.5 time_point non-member arithmetic [time.point.nonmember] //
|
|
//----------------------------------------------------------------------------//
|
|
|
|
// time_point operator+(time_point x, duration y);
|
|
|
|
template <class Clock, class Duration1, class Rep2, class Period2>
|
|
inline BOOST_CONSTEXPR
|
|
time_point<Clock,
|
|
typename common_type<Duration1, duration<Rep2, Period2> >::type>
|
|
operator+(const time_point<Clock, Duration1>& lhs,
|
|
const duration<Rep2, Period2>& rhs)
|
|
{
|
|
typedef typename common_type<Duration1, duration<Rep2, Period2> >::type CDuration;
|
|
typedef time_point<
|
|
Clock,
|
|
CDuration
|
|
> TimeResult;
|
|
return TimeResult(lhs.time_since_epoch() + CDuration(rhs));
|
|
}
|
|
|
|
// time_point operator+(duration x, time_point y);
|
|
|
|
template <class Rep1, class Period1, class Clock, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
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 BOOST_CONSTEXPR
|
|
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 BOOST_CONSTEXPR
|
|
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();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
// 20.9.4.6 time_point comparisons [time.point.comparisons] //
|
|
//----------------------------------------------------------------------------//
|
|
|
|
// time_point ==
|
|
|
|
template <class Clock, class Duration1, class Duration2>
|
|
inline BOOST_CONSTEXPR
|
|
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 BOOST_CONSTEXPR
|
|
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 BOOST_CONSTEXPR
|
|
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 BOOST_CONSTEXPR
|
|
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 BOOST_CONSTEXPR
|
|
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 BOOST_CONSTEXPR
|
|
bool
|
|
operator>=(const time_point<Clock, Duration1>& lhs,
|
|
const time_point<Clock, Duration2>& rhs)
|
|
{
|
|
return !(lhs < rhs);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
// 20.9.4.7 time_point_cast [time.point.cast] //
|
|
//----------------------------------------------------------------------------//
|
|
|
|
template <class ToDuration, class Clock, class Duration>
|
|
inline BOOST_CONSTEXPR
|
|
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()));
|
|
}
|
|
|
|
} // namespace chrono
|
|
} // namespace boost
|
|
|
|
#ifndef BOOST_CHRONO_HEADER_ONLY
|
|
// the suffix header occurs after all of our code:
|
|
#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
|
|
#endif
|
|
|
|
#endif // BOOST_CHRONO_TIME_POINT_HPP
|