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

//  Copyright Beman Dawes 1994-99.  Distributed under the Boost

//  Software License, Version 1.0. (See accompanying file

//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/timer for documentation.

//  Revision History

//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)

//  12 Jan 01  Change to inline implementation to allow use without library

//             builds. See docs for more rationale. (Beman Dawes) 

//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)

//  16 Jul 99  Second beta

//   6 Jul 99  Initial boost version

#ifndef BOOST_TIMER_HPP

#define BOOST_TIMER_HPP

#include <boost/config.hpp>

#include <ctime>

#include <boost/limits.hpp>

# ifdef BOOST_NO_STDC_NAMESPACE

    namespace std { using ::clock_t; using ::clock; }

# endif

namespace boost {

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

//  A timer object measures elapsed time.

//  It is recommended that implementations measure wall clock rather than CPU

//  time since the intended use is performance measurement on systems where

//  total elapsed time is more important than just process or CPU time.

//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours

//  due to implementation limitations.  The accuracy of timings depends on the

//  accuracy of timing information provided by the underlying platform, and

//  this varies a great deal from platform to platform.

class timer

{

 public:

         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0

//         timer( const timer& src );      // post: elapsed()==src.elapsed()

//        ~timer(){}

//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()

  void   restart() { _start_time = std::clock(); } // post: elapsed()==0

  double elapsed() const                  // return elapsed time in seconds

    { return  double(std::clock() - _start_time) / CLK_TCK; }

  double elapsed_max() const   // return estimated maximum value for elapsed()

  // Portability warning: elapsed_max() may return too high a value on systems

  // where std::clock_t overflows or resets at surprising values.

  {

    return (double((std::numeric_limits<std::clock_t>::max)())

       - double(_start_time)) / double(CLK_TCK); 

  }

  double elapsed_min() const            // return minimum value for elapsed()

   { return double(1)/double(CLK_TCK); }

 private:

  std::clock_t _start_time;

}; // timer

} // namespace boost

#endif  // BOOST_TIMER_HPP