Moving third party sources to third_party folder so that they can be easily distinguished. This should help package maintainers.

src/third_party/boost/timers.hpp

@@ -0,0 +1,30 @@
+#ifndef _BOOST_TIMERS_HPP
+#define _BOOST_TIMERS_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+// -------------------------- Includes --------------------------
+
+// Speeds up compilation a bit on msvc
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#pragma once
+#define _WINSOCKAPI_
+#endif
+
+#include <boost/config.hpp>
+
+#include "timers/timer.hpp"
+#include "timers/portable.hpp"
+
+#ifdef BOOST_WINDOWS
+    #include "timers/win32.hpp"
+#else
+    #include "timers/posix.hpp"
+#endif
+
+#endif // _BOOST_TIMERS_HPP

src/third_party/boost/timers/portable.hpp

@@ -0,0 +1,46 @@
+#ifndef _BOOST_TIMERS_PORTABLE_HPP
+#define _BOOST_TIMERS_PORTABLE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+#include "timer.hpp"
+#include "portable/clock_device.hpp"
+#include "portable/date_time_devices.hpp"
+#include "portable/time_device.hpp"
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace portable
+{
+
+    // boost::date_time devices
+    typedef timer<microsec_device>      microsec_timer;
+    typedef timer<second_device>        second_timer;
+
+    // std::clock() device
+    typedef timer<clock_device>         clock_timer;
+
+    // std::time() device
+    typedef timer<time_device>          time_timer;
+
+    // Typedef which timer is the best
+    typedef microsec_timer              best_timer;
+
+} // namespace portable
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_PORTABLE_HPP

src/third_party/boost/timers/portable/clock_device.hpp

@@ -0,0 +1,84 @@
+ #ifndef _BOOST_TIMERS_PORTABLE_CLOCK_DEVICE_HPP
+#define _BOOST_TIMERS_PORTABLE_CLOCK_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Standard headers
+#include <ctime>
+
+// Boost headers
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace portable
+{
+
+//! The clock_device class is based on std::clock() to compute the time
+class clock_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit clock_device() : m_running(false), m_start(0), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start() 
+    {
+        if(!m_running)
+        {
+            m_start     = std::clock();
+            m_running   = true;
+        }
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_running)
+        {
+            std::clock_t current = std::clock();
+            double seconds = (current - m_start) / static_cast<double>(CLOCKS_PER_SEC);
+            m_elapsed += posix_time::milliseconds(static_cast<int64_t>(seconds * 1000.0));
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed   = time_duration_type(0,0,0);
+        m_start     = 0;
+        m_running   = false;
+    }
+
+
+  private:
+
+    bool                        m_running;
+    mutable std::clock_t        m_start;
+    mutable time_duration_type  m_elapsed;
+
+};
+
+} // namespace portable
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_PORTABLE_CLOCK_DEVICE_HPP

src/third_party/boost/timers/portable/date_time_devices.hpp

@@ -0,0 +1,80 @@
+#ifndef _BOOST_TIMERS_PORTABLE_DATE_TIME_DEVICES_HPP
+#define _BOOST_TIMERS_PORTABLE_DATE_TIME_DEVICES_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace portable
+{
+
+//! The date_time device
+template <class Clock, class Time = posix_time::ptime>
+class date_time_device
+{
+
+  public:
+
+    typedef Clock clock_type;
+    typedef Time  time_type;
+    typedef typename clock_type::time_duration_type time_duration_type;
+
+    explicit date_time_device() : m_start(date_time::not_a_date_time), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start()
+    {
+        if(m_start.is_not_a_date_time())
+            m_start = clock_type::local_time();
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(!m_start.is_not_a_date_time())
+        {
+            time_type current(clock_type::local_time());
+            m_elapsed += (current - m_start);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_start   = date_time::not_a_date_time;
+        m_elapsed = time_duration_type(0,0,0);
+    }
+
+
+  private:
+
+    mutable time_type           m_start;
+    mutable time_duration_type  m_elapsed;
+
+};
+
+// Convenience typedefs
+typedef date_time_device<posix_time::microsec_clock>    microsec_device;
+typedef date_time_device<posix_time::second_clock>      second_device;
+
+} // namespace portable
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_PORTABLE_DATE_TIME_DEVICES_HPP

src/third_party/boost/timers/portable/time_device.hpp

@@ -0,0 +1,76 @@
+#ifndef _BOOST_TIMERS_PORTABLE_TIME_DEVICE_HPP
+#define _BOOST_TIMERS_PORTABLE_TIME_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Standard headers
+#include <ctime>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace portable
+{
+
+//! The time_device class is based on std::time() to compute the time
+class time_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit time_device() : m_start(0), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start() 
+    {
+        if(!m_start)
+            m_start = std::time(0);
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start)
+        {
+            std::time_t current = std::time(0);
+            long seconds = static_cast<long>(current - m_start);
+            m_elapsed += posix_time::seconds(seconds);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start = 0;
+    }
+
+
+  private:
+
+    mutable std::time_t         m_start;
+    mutable time_duration_type  m_elapsed;
+
+};
+
+} // namespace portable
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_PORTABLE_TIME_DEVICE_HPP

src/third_party/boost/timers/posix.hpp

@@ -0,0 +1,45 @@
+#ifndef _BOOST_TIMERS_POSIX_HPP
+#define _BOOST_TIMERS_POSIX_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+#include "timer.hpp"
+#include "posix/ftime_device.hpp"
+#include "posix/gru_device.hpp"
+#include "posix/gtod_device.hpp"
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace posix
+{
+
+    // ftime() device
+    typedef timer<ftime_device>     ftime_timer;
+
+    // getcputime() device
+    typedef timer<gru_device>       gru_timer;
+
+    // gettimeofday() device
+    typedef timer<gtod_device>      gtod_timer;
+
+    // Typedef which timer is the best
+    typedef gtod_timer              best_timer;
+
+} // namespace posix
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_POSIX_HPP

src/third_party/boost/timers/posix/ftime_device.hpp

@@ -0,0 +1,86 @@
+#ifndef _BOOST_TIMERS_POSIX_FTIME_DEVICE_HPP
+#define _BOOST_TIMERS_POSIX_FTIME_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Boost headers
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Linux headers
+#include <sys/timeb.h>
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace posix
+{
+
+//! The gtod_device class is based on gettimeofday() to compute the time
+class ftime_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit ftime_device() : m_elapsed(0, 0, 0)
+    {
+        std::memset(&m_start, 0, sizeof(timeb));
+    }
+
+    void start() 
+    {
+        if(!is_time(m_start))
+            ftime(&m_start);
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(is_time(m_start))
+        {
+            timeb current;
+            ftime(&current);
+            int64_t seconds = current.time - m_start.time;
+            int64_t milliseconds = current.millitm - m_start.millitm;
+            m_elapsed += posix_time::milliseconds(seconds * 1000 + milliseconds);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        std::memset(&m_start, 0, sizeof(timeb));
+    }
+
+
+  private:
+
+    bool is_time(const timeb& value) const
+    {
+        return value.time != 0;
+    }
+
+    mutable timeb               m_start;
+    mutable time_duration_type  m_elapsed;
+
+};
+
+} // namespace posix
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_POSIX_FTIME_DEVICE_HPP

src/third_party/boost/timers/posix/gru_device.hpp

@@ -0,0 +1,88 @@
+#ifndef _BOOST_TIMERS_POSIX_GRU_DEVICE_HPP
+#define _BOOST_TIMERS_POSIX_GRU_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Boost headers
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Linux headers
+#include <sys/times.h>
+#include <sys/resource.h>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace posix
+{
+
+//! The gru_device class is based on getrusage() to compute the time
+class gru_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit gru_device() : m_elapsed(0, 0, 0)
+    {
+        std::memset(&m_start, 0, sizeof(timeval));
+    }
+
+    void start() 
+    {
+        if(!is_time(m_start))
+            getrusage(RUSAGE_SELF, &m_start);
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(is_time(m_start))
+        {
+            rusage current;
+            getrusage(RUSAGE_SELF, &current);
+            int64_t seconds = current.ru_utime.tv_sec - m_start.ru_utime.tv_sec;
+            int64_t microseconds = current.ru_utime.tv_usec - m_start.ru_utime.tv_usec;
+            m_elapsed += posix_time::microseconds(seconds * 1000000 + microseconds);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        std::memset(&m_start, 0, sizeof(timeval));
+    }
+
+
+  private:
+
+    bool is_time(const rusage& value) const
+    {
+        return value.ru_utime.tv_sec || value.ru_utime.tv_usec;
+    }
+
+    mutable rusage              m_start;
+    mutable time_duration_type  m_elapsed;
+
+};
+
+} // namespace posix
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_POSIX_GRU_DEVICE_HPP

src/third_party/boost/timers/posix/gtod_device.hpp

@@ -0,0 +1,86 @@
+#ifndef _BOOST_TIMERS_POSIX_GTOD_DEVICE_HPP
+#define _BOOST_TIMERS_POSIX_GTOD_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Boost headers
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Linux headers
+#include <sys/time.h>
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace posix
+{
+
+//! The gtod_device class is based on gettimeofday() to compute the time
+class gtod_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit gtod_device() : m_elapsed(0, 0, 0)
+    {
+        std::memset(&m_start, 0, sizeof(timeval));
+    }
+
+    void start() 
+    {
+        if(!is_time(m_start))
+            gettimeofday(&m_start, 0);
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(is_time(m_start))
+        {
+            timeval current;
+            gettimeofday(&current, 0);
+            int64_t seconds = current.tv_sec - m_start.tv_sec;
+            int64_t microseconds = current.tv_usec - m_start.tv_usec;
+            m_elapsed += posix_time::microseconds(seconds * 1000000 + microseconds);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        std::memset(&m_start, 0, sizeof(timeval));
+    }
+
+
+  private:
+
+    bool is_time(const timeval& value) const
+    {
+        return value.tv_sec || value.tv_usec;
+    }
+
+    mutable timeval             m_start;
+    mutable time_duration_type  m_elapsed;
+
+};
+
+} // namespace posix
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_POSIX_GTOD_DEVICE_HPP

src/third_party/boost/timers/timer.hpp

@@ -0,0 +1,112 @@
+#ifndef _BOOST_TIMERS_TIMER_HPP
+#define _BOOST_TIMERS_TIMER_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+
+namespace timers
+{
+
+//! The timer class takes a device type that's used for the elapsed time computation.
+//! Calling start(), pause() or resume() twice has no special effects.
+template<class Device>
+class timer
+{
+
+  public:
+
+    typedef Device                                      device_type;
+    typedef typename device_type::time_duration_type    time_duration_type;
+
+    enum start_options { auto_start = 1, manual_start };
+
+    //! By default, start the timer without any time offset
+    explicit timer(time_duration_type initial_duration = time_duration_type(0, 0, 0), start_options start_op = auto_start)
+    : m_elapsed(initial_duration), m_running(false)
+    {
+        if(start_op == auto_start)
+            start();
+    }
+
+    //! Starts the timer
+    void start() 
+    {
+        if(!m_running)
+        {
+            m_device.start();
+            m_running = true;
+        }
+    }
+
+    //! Restarts the timer
+    void restart()
+    {
+        reset();
+        start();
+    }
+
+    //! Returns the elapsed time
+    time_duration_type elapsed() const
+    {
+        return m_running ? (m_device.elapsed() + m_elapsed) : m_elapsed;
+    }
+
+    //! Pauses the timer
+    void pause()
+    {
+        if(m_running)
+        {
+            m_elapsed += m_device.elapsed();
+            m_device.reset();
+            m_running = false;
+        }
+    }
+
+    //! Resumes the timer
+    void resume()
+    {
+        if(!m_running)
+        {
+            m_device.start();
+            m_running = true;
+        }
+    }
+
+    //! Resets the timer
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_device.reset();
+        m_running = false;
+    }
+
+    //! Tells wether the timer is currently running or not
+    bool is_running() const
+    {
+        return m_running;
+    }
+
+
+  private:
+
+    mutable device_type         m_device;
+    mutable time_duration_type  m_elapsed;
+    bool                        m_running;
+
+};
+
+} // namespace timers
+
+} // namespace boost
+
+#endif // _BOOST_TIMERS_TIMER_HPP

src/third_party/boost/timers/win32.hpp

@@ -0,0 +1,57 @@
+#ifndef _BOOST_TIMERS_WIN32_HPP
+#define _BOOST_TIMERS_WIN32_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+#include "timer.hpp"
+#include "win32/gpt_device.hpp"
+#include "win32/gtc_device.hpp"
+#include "win32/gtt_device.hpp"
+#include "win32/gstaft_device.hpp"
+#include "win32/qpc_device.hpp"
+#include "win32/tgt_device.hpp"
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace win32
+{
+
+    // GetProcessTimes() device
+    typedef timer<gpt_device>       gpt_timer;
+
+    // GetThreadTimes() device
+    typedef timer<gtt_device>       gtt_timer;
+
+    // GetTickCount() device
+    typedef timer<gtc_device>       gtc_timer;
+
+    // GetSystemTimeAsFileTime() device
+    typedef timer<gstaft_device>    gstaft_timer;
+
+    // QueryPerformanceCounter() device
+    typedef timer<qpc_device>       qpc_timer;
+
+    // timeGetTime() device
+    typedef timer<tgt_device>       tgt_timer;
+
+    // Typedef which timer is the best
+    typedef qpc_timer               best_timer;
+
+} // namespace win32
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_WIN32_HPP

src/third_party/boost/timers/win32/gpt_device.hpp

@@ -0,0 +1,97 @@
+#ifndef _BOOST_TIMERS_WIN32_GPT_DEVICE_HPP
+#define _BOOST_TIMERS_WIN32_GPT_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Standard headers
+#include <utility>
+
+// Boost headers
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace win32
+{
+
+//! The gtt_device class is based on GetThreadTimes() to compute the time
+class gpt_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit gpt_device() : m_start(0, 0), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start() 
+    {
+        if(!is_time(m_start))
+        {
+            FILETIME tmp1, tmp2;
+            GetProcessTimes(GetCurrentProcess(), &tmp1, &tmp2, reinterpret_cast<LPFILETIME>(&m_start.first), reinterpret_cast<LPFILETIME>(&m_start.second));
+        }
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(is_time(m_start))
+        {
+            std::pair<uint64_t, uint64_t> current;
+            FILETIME tmp1, tmp2;
+            GetProcessTimes(GetCurrentProcess(), &tmp1, &tmp2, reinterpret_cast<LPFILETIME>(&current.first), reinterpret_cast<LPFILETIME>(&current.second));
+            // diff is measured in 100ns intervals...
+            uint64_t diff = (current.first - m_start.first) + (current.second - m_start.second);
+            // ... so we must divide by 10 to get nanoseconds
+            uint64_t nanoseconds = static_cast<uint64_t>(diff / 10.0);
+            m_elapsed += posix_time::milliseconds(static_cast<int64_t>(nanoseconds / 1000.0));
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start.first = m_start.second = 0;
+    }
+
+
+  private:
+
+    bool is_time(const std::pair<uint64_t, uint64_t>& time) const
+    {
+        return (time.first != 0 || time.second != 0);
+    }
+
+    mutable std::pair<uint64_t, uint64_t>   m_start;
+    mutable time_duration_type              m_elapsed;
+
+};
+
+} // namespace win32
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP

src/third_party/boost/timers/win32/gstaft_device.hpp

@@ -0,0 +1,86 @@
+#ifndef _BOOST_TIMERS_WIN32_GSTAFT_DEVICE_HPP
+#define _BOOST_TIMERS_WIN32_GSTAFT_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Boost headers
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace win32
+{
+
+//! The gstaft_device class is based on GetSystemTimeAsFileTime() to compute the time
+class gstaft_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit gstaft_device() : m_elapsed(0, 0, 0)
+    {
+        std::memset(&m_start, 0, sizeof(ULARGE_INTEGER));
+    }
+
+    void start() 
+    {
+        if(!m_start.QuadPart)
+            GetSystemTimeAsFileTime(reinterpret_cast<LPFILETIME>(&m_start));
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start.QuadPart)
+        {
+            ULARGE_INTEGER current;
+            GetSystemTimeAsFileTime(reinterpret_cast<LPFILETIME>(&current));
+            // diff is measured in 100ns intervals...
+            uint64_t diff = current.QuadPart - m_start.QuadPart;
+            // ... so we must divide by 10 to get nanoseconds
+            uint64_t nanoseconds = static_cast<uint64_t>(diff / 10.0);
+            m_elapsed += posix_time::milliseconds(static_cast<int64_t>(nanoseconds / 1000.0));
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        std::memset(&m_start, 0, sizeof(ULARGE_INTEGER));
+    }
+
+
+  private:
+
+    mutable ULARGE_INTEGER     m_start;
+    mutable time_duration_type m_elapsed;
+
+};
+
+} // namespace win32
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_WIN32_GSTAFT_DEVICE_HPP

src/third_party/boost/timers/win32/gtc_device.hpp

@@ -0,0 +1,81 @@
+#ifndef _BOOST_TIMERS_WIN32_GTC_DEVICE_HPP
+#define _BOOST_TIMERS_WIN32_GTC_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Boost headers
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace win32
+{
+
+//! The gtc_device class is based on GetTickCount() to compute the time
+class gtc_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit gtc_device() : m_start(0), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start() 
+    {
+        if(!m_start)
+            m_start = GetTickCount();
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start)
+        {
+            uint32_t current = GetTickCount();
+            uint64_t milliseconds = current - m_start;
+            m_elapsed += posix_time::milliseconds(milliseconds);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start = 0;
+    }
+
+
+  private:
+
+    mutable uint32_t m_start;
+    mutable time_duration_type m_elapsed;
+
+};
+
+} // namespace win32
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_WIN32_GTC_DEVICE_HPP

src/third_party/boost/timers/win32/gtt_device.hpp

@@ -0,0 +1,97 @@
+#ifndef _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP
+#define _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Standard headers
+#include <utility>
+
+// Boost headers
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace win32
+{
+
+//! The gtt_device class is based on GetThreadTimes() to compute the time
+class gtt_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit gtt_device() : m_start(0, 0), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start() 
+    {
+        if(!is_time(m_start))
+        {
+            FILETIME tmp1, tmp2;
+            GetThreadTimes(GetCurrentThread(), &tmp1, &tmp2, reinterpret_cast<LPFILETIME>(&m_start.first), reinterpret_cast<LPFILETIME>(&m_start.second));
+        }
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(is_time(m_start))
+        {
+            std::pair<uint64_t, uint64_t> current;
+            FILETIME tmp1, tmp2;
+            GetThreadTimes(GetCurrentThread(), &tmp1, &tmp2, reinterpret_cast<LPFILETIME>(&current.first), reinterpret_cast<LPFILETIME>(&current.second));
+            // diff is measured in 100ns intervals...
+            uint64_t diff = (current.first - m_start.first) + (current.second - m_start.second);
+            // ... so we must divide by 10 to get nanoseconds
+            uint64_t nanoseconds = static_cast<uint64_t>(diff / 10.0);
+            m_elapsed += posix_time::milliseconds(static_cast<int64_t>(nanoseconds / 1000.0));
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start.first = m_start.second = 0;
+    }
+
+
+  private:
+
+    bool is_time(const std::pair<uint64_t, uint64_t>& time) const
+    {
+        return (time.first != 0 || time.second != 0);
+    }
+
+    mutable std::pair<uint64_t, uint64_t>   m_start;
+    mutable time_duration_type              m_elapsed;
+
+};
+
+} // namespace win32
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_WIN32_GTT_DEVICE_HPP

src/third_party/boost/timers/win32/qpc_device.hpp

@@ -0,0 +1,104 @@
+#ifndef _BOOST_TIMERS_WIN32_QPC_DEVICE_HPP
+#define _BOOST_TIMERS_WIN32_QPC_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Boost headers
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace win32
+{
+
+class qpc_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit qpc_device() : m_elapsed(0, 0, 0)
+    {
+        #ifdef BOOST_QPC_SET_AFFINITY
+        m_affinity = SetThreadAffinityMask(GetCurrentThread(), 1);
+        #endif
+
+        m_start.QuadPart = 0;
+        if(!QueryPerformanceFrequency(&m_frequency))
+            throw_exception(std::runtime_error("qpc_device: QueryPerformanceFrequency() indicated there's no high-resolution performance counter"));
+
+        // Make it so we have the future results directly in milliseconds
+        m_frequency.QuadPart /= 1000;
+    }
+
+    ~qpc_device()
+    {
+        #ifdef BOOST_QPC_SET_AFFINITY
+        SetThreadAffinityMask(GetCurrentThread(), m_affinity);
+        #endif
+    }
+
+    void start() 
+    {
+        if(!m_start.QuadPart && !QueryPerformanceCounter(&m_start))
+            throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed"));
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start.QuadPart)
+        {
+            LARGE_INTEGER current;
+            if(!QueryPerformanceCounter(&current))
+                throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed"));
+            int64_t milliseconds = (current.QuadPart - m_start.QuadPart) / m_frequency.QuadPart;
+            m_elapsed += posix_time::milliseconds(milliseconds);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start.QuadPart = 0;
+    }
+
+
+  private:
+
+    LARGE_INTEGER               m_frequency;
+    mutable LARGE_INTEGER       m_start;
+    mutable time_duration_type  m_elapsed;
+
+    #ifdef BOOST_QPC_SET_AFFINITY
+    DWORD_PTR                   m_affinity;
+    #endif
+
+};
+
+} // namespace win32
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_WIN32_QUERYPERFORMANCECOUNTER_HPP

src/third_party/boost/timers/win32/tgt_device.hpp

@@ -0,0 +1,95 @@
+#ifndef _BOOST_TIMERS_WIN32_TGT_DEVICE_HPP
+#define _BOOST_TIMERS_WIN32_TGT_DEVICE_HPP
+
+// (C) Copyright Vaucher Philippe 2007
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2007
+
+
+// -------------------------- Includes --------------------------
+
+// Boost headers
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+// Automagically link winmm.lib if we can
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#pragma comment(lib, "winmm.lib")
+#endif
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+namespace timers
+{
+namespace win32
+{
+
+//! The tgt_device class is based on timeGetTime() to compute the time
+class tgt_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit tgt_device() : m_start(0), m_elapsed(0, 0, 0)
+    {
+        #ifndef BOOST_TGT_DEFAULT_RES
+        timeBeginPeriod(1);
+        #endif
+    }
+
+    ~tgt_device()
+    {
+        #ifndef BOOST_TGT_DEFAULT_RES
+        timeEndPeriod(1);
+        #endif
+    }
+
+    void start() 
+    {
+        if(!m_start)
+            m_start = timeGetTime();
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start)
+        {
+            uint32_t current = timeGetTime();
+            int64_t milliseconds = current - m_start;
+            m_elapsed += posix_time::milliseconds(milliseconds);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start = 0;
+    }
+
+
+  private:
+
+    mutable uint32_t            m_start;
+    mutable time_duration_type  m_elapsed;
+
+};
+
+} // namespace win32
+} // namespace timers
+} // namespace boost
+
+#endif // _BOOST_TIMERS_WIN32_TGT_DEVICE_HPP