1 files changed, 237 insertions, 0 deletions
diff --git a/src/boost/libs/chrono/example/timeval_demo.cpp b/src/boost/libs/chrono/example/timeval_demo.cpp
new file mode 100644
index 000000000..2294489d5
--- /dev/null
+++ b/src/boost/libs/chrono/example/timeval_demo.cpp
@@ -0,0 +1,237 @@
+//  timeval_demo.cpp  ----------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+//  Copyright 2009 Vicente J. Botet Escriba
+//  Copyright (c) Microsoft Corporation 2014
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+/*
+This code was extracted by Vicente J. Botet Escriba from Beman Dawes time2_demo.cpp which
+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.
+*/
+#define _CRT_SECURE_NO_WARNINGS  // disable VC++ foolishness
+
+#include <boost/chrono/chrono.hpp>
+#include <boost/type_traits.hpp>
+
+#include <iostream>
+
+#if defined(BOOST_CHRONO_MAC_API)
+#include <sys/time.h> //for gettimeofday and timeval
+#endif
+
+#if defined(BOOST_CHRONO_WINDOWS_API)
+#    include <windows.h>
+#endif
+
+#if defined(BOOST_CHRONO_WINDOWS_API)
+
+namespace
+{
+  #if defined UNDER_CE || BOOST_PLAT_WINDOWS_RUNTIME
+  // Windows CE and Windows store does not define timeval
+  struct timeval {
+          long    tv_sec;         /* seconds */
+          long    tv_usec;        /* and microseconds */
+  };
+  #endif
+
+  int gettimeofday(struct timeval * tp, void *)
+  {
+    FILETIME ft;
+  #if defined(UNDER_CE)
+    // Windows CE does not define GetSystemTimeAsFileTime so we do it in two steps.
+    SYSTEMTIME st;
+    ::GetSystemTime( &st );
+    ::SystemTimeToFileTime( &st, &ft );
+  #else
+    ::GetSystemTimeAsFileTime( &ft );  // never fails
+  #endif
+    long long t = (static_cast<long long>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+  # if !defined( BOOST_MSVC ) || BOOST_MSVC > 1300 // > VC++ 7.0
+    t -= 116444736000000000LL;
+  # else
+    t -= 116444736000000000;
+  # endif
+    t /= 10;  // microseconds
+    tp->tv_sec = static_cast<long>( t / 1000000UL);
+    tp->tv_usec = static_cast<long>( t % 1000000UL);
+    return 0;
+  }
+}  // unnamed namespace
+
+#endif
+
+//  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 = static_cast<long>(t / 1000000);
+        tv_usec = static_cast<long>(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                                  rep;
+    typedef boost::micro                           period;
+    typedef boost::chrono::duration<rep, period>   duration;
+    typedef boost::chrono::time_point<xtime_clock> time_point;
+
+    static time_point now();
+};
+
+
+xtime_clock::time_point
+xtime_clock::now()
+{
+#if defined(BOOST_CHRONO_WINDOWS_API)
+    timeval tv;
+    gettimeofday(&tv, 0);
+    xtime xt( tv.tv_sec, tv.tv_usec);
+    return time_point(duration(xt));
+
+#elif defined(BOOST_CHRONO_MAC_API)
+
+    timeval tv;
+    gettimeofday(&tv, 0);
+    xtime xt( tv.tv_sec, tv.tv_usec);
+    return time_point(duration(xt));
+
+#elif defined(BOOST_CHRONO_POSIX_API)
+    //time_point t(0,0);
+
+    timespec ts;
+    ::clock_gettime( CLOCK_REALTIME, &ts );
+
+    xtime xt( ts.tv_sec, ts.tv_nsec/1000);
+    return time_point(duration(xt));
+#endif  // POSIX
+
+}
+
+void test_xtime_clock()
+{
+    using namespace boost::chrono;
+    std::cout << "timeval_demo system clock test\n";
+    std::cout << "sizeof xtime_clock::time_point = " << sizeof(xtime_clock::time_point) << '\n';
+    std::cout << "sizeof xtime_clock::duration = " << sizeof(xtime_clock::duration) << '\n';
+    std::cout << "sizeof xtime_clock::rep = " << sizeof(xtime_clock::rep) << '\n';
+    xtime_clock::duration delay(milliseconds(5));
+    xtime_clock::time_point start = xtime_clock::now();
+
+    while (xtime_clock::now() - start <= delay)
+    {
+    }
+    xtime_clock::time_point stop = xtime_clock::now();
+    xtime_clock::duration elapsed = stop - start;
+    std::cout << "paused " << nanoseconds(elapsed).count() << " nanoseconds\n";
+}
+
+}  // timeval_demo
+
+int main()
+{
+    timeval_demo::test_xtime_clock();
+    return 0;
+}
+