//  boost timer.hpp header file  ---------------------------------------------//

#ifndef BOOST_TIMER_HPP
#define BOOST_TIMER_HPP

#include <boost/config.hpp>
#include <ctime>
#include <boost/limits.hpp>
#include <cassert>

# ifdef BOOST_NO_STDC_NAMESPACE
    namespace std { using ::clock_t; using ::clock; }
# endif

# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# include <windows.h>
# else
# include <sys/time.h>
# include <sys/times.h>
# endif

# if  _MSC_VER < 1200
# define CLK_TCK CLOCKS_PER_SEC
# endif

namespace boost {

//  timer  -------------------------------------------------------------------//

class walltime_timer
{
public:
    walltime_timer() 
    {
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
        _start_time = std::clock();
# else
        int res = gettimeofday(&_start_time, NULL);
        assert (res == 0);
# endif            
    }
    void restart()
    {
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)        
        _start_time = std::clock();
# else
        int res = gettimeofday(&_start_time, NULL);
        assert (res == 0);
# endif        
    }
    
    double elapsed() const
    {
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)        
        return double(std::clock() - _start_time) / double(CLOCKS_PER_SEC);
# else
        struct timeval _now;
        int res;
        res = gettimeofday(&_now, NULL);
        assert(res == 0);
        return double(_now.tv_sec - _start_time.tv_sec) +
            (double(_now.tv_usec - _start_time.tv_usec) / double(1000000));
# endif
    }
    
    double elapsed_max() const
    {
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)                
        return (double(std::numeric_limits<std::clock_t>::max())
                - double(_start_time)) / double(CLOCKS_PER_SEC);
# else
        return (double(std::numeric_limits<long>::max()) - double(_start_time.tv_sec));
# endif
    }
        
    double elapsed_min() const
    {
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
        return double(1)/double(CLOCKS_PER_SEC);
# else
        return double(1) / double (1000000);
# endif        
    }
    
private:
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)    
    std::clock_t _start_time;
# else
    struct timeval _start_time;
# endif    
}; //walltime_timer

class process_timer
{
public:
    process_timer()
    {
        restart();
    }

    void restart()
    {
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
        FILETIME tmp_val, tmp_sys, tmp_usr;
        assert(
            GetProcessTimes(GetCurrentProcess(), &tmp_val, &tmp_val, &tmp_sys, &tmp_usr)
            != 0);
        _start_systime.LowPart = tmp_sys.dwLowDateTime;
        _start_systime.HighPart = tmp_sys.dwHighDateTime;
        _start_usrtime.LowPart = tmp_usr.dwLowDateTime;
        _start_usrtime.HighPart = tmp_usr.dwHighDateTime;
# else
        struct tms tmp_val;
        assert(times(&tmp_val) != (std::clock_t)-1);
        _start_systime = tmp_val.tms_stime;
        _start_usrtime = tmp_val.tms_utime;
# endif        
    }

    double elapsed_sys() const
    {
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
        SYSTEMTIME tmp_systime;
        FILETIME tmp_val, tmp_sysnow;
        ULARGE_INTEGER tmp_int;
        assert(
            GetProcessTimes(GetCurrentProcess(), &tmp_val, &tmp_val, &tmp_sysnow, &tmp_val)
            != 0);
        tmp_int.LowPart = tmp_sysnow.dwLowDateTime;
        tmp_int.HighPart = tmp_sysnow.dwHighDateTime;
        tmp_int.LowPart -= _start_systime.LowPart;
        tmp_int.HighPart -= _start_systime.HighPart;
        
        tmp_sysnow.dwLowDateTime = tmp_int.LowPart;
        tmp_sysnow.dwHighDateTime = tmp_int.HighPart;
        
        assert(
            FileTimeToSystemTime(&tmp_sysnow, &tmp_systime)
            != 0);
        return (double)((tmp_systime.wDay - 1) * 24 * 60 * 60) +
            (double)(tmp_systime.wHour * 60 * 60) +
            (double)(tmp_systime.wMinute * 60) +
            (double)(tmp_systime.wSecond) +
            ((double)(tmp_systime.wMilliseconds) / double(1000));
# else
        struct tms tmp_val;
        assert(times(&tmp_val) != (std::clock_t)-1);
        return ((double)tmp_val.tms_stime - (double)_start_systime) / (double)sysconf(_SC_CLK_TCK);
    
# endif
    }

    double elapsed_usr() const
    {
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
        SYSTEMTIME tmp_usrtime;
        FILETIME tmp_val, tmp_usrnow;
        ULARGE_INTEGER tmp_int;
        assert(
            GetProcessTimes(GetCurrentProcess(), &tmp_val, &tmp_val, &tmp_val, &tmp_usrnow)
            != 0);
        tmp_int.LowPart = tmp_usrnow.dwLowDateTime;
        tmp_int.HighPart = tmp_usrnow.dwHighDateTime;
        tmp_int.LowPart -= _start_usrtime.LowPart;
        tmp_int.HighPart -= _start_usrtime.HighPart;
        
        tmp_usrnow.dwLowDateTime = tmp_int.LowPart;
        tmp_usrnow.dwHighDateTime = tmp_int.HighPart;
        
        assert(
            FileTimeToSystemTime(&tmp_usrnow, &tmp_usrtime)
            != 0);
        
        return (double)((tmp_usrtime.wDay - 1) * 24 * 60 * 60) +
            (double)(tmp_usrtime.wHour * 60 * 60) +
            (double)(tmp_usrtime.wMinute * 60) +
            (double)(tmp_usrtime.wSecond) +
            ((double)(tmp_usrtime.wMilliseconds) / double(1000));
# else
        struct tms tmp_val;
        assert(times(&tmp_val) != (std::clock_t)-1);
        return ((double)tmp_val.tms_utime - (double)_start_usrtime) / (double)sysconf(_SC_CLK_TCK);
    
# endif
    }
    
private:
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
    ULARGE_INTEGER _start_systime;
    ULARGE_INTEGER _start_usrtime;
# else
    std::clock_t _start_systime;
    std::clock_t _start_usrtime;
# endif        
}; //process_timer

//timer is preserved for backward compatibility   
typedef process_timer timer; 
    
} // namespace boost

#endif  // BOOST_TIMER_HPP