comparison DEPENDENCIES/generic/include/boost/chrono/time_point.hpp @ 16:2665513ce2d3

Add boost headers

+//  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_FORCEINLINE BOOST_CONSTEXPR
+        time_point() : d_(duration::zero())
+        {}
+        BOOST_FORCEINLINE BOOST_CONSTEXPR
+        explicit time_point(const duration& d)
+            : d_(d)
+        {}
+
+        // conversions
+        template <class Duration2>
+        BOOST_FORCEINLINE 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