/home/mhx/git/github/libmoost/include/moost/utils/stopwatch.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_UTILS_STOPWATCH_HPP__
#define MOOST_UTILS_STOPWATCH_HPP__

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/cstdint.hpp>
#include <boost/noncopyable.hpp>

namespace moost { namespace utils {

   class stopwatch : boost::noncopyable
   {
   public:

      typedef boost::int64_t elapsed_t;

      stopwatch()
      {
         restart();
      }

      void restart()
      {
         start_ = boost::posix_time::microsec_clock::universal_time();
      }

      elapsed_t elapsed_ns() const // nanosecs
      {
         boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
         return (now - start_).total_nanoseconds();
      }

      elapsed_t elapsed_us() const // microsecs (default)
      {
         boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
         return (now - start_).total_microseconds();
      }

      elapsed_t elapsed_ms() const // millisecs
      {
         boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
         return (now - start_).total_milliseconds();
      }

      elapsed_t elapsed_secs() const // secs
      {
         boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
         return (now - start_).total_seconds();
      }

      elapsed_t elapsed() const
      {
         return elapsed_us();
      }

   private:
      boost::posix_time::ptime start_;
   };

   class scoped_stopwatch : boost::noncopyable
   {
   public:
      enum granularity
      {
         nanosecs, microsecs, millisecs, secs
      };

      typedef stopwatch::elapsed_t elapsed_t;

      scoped_stopwatch(
         elapsed_t & future, // This is a future, which will be assigned elapsed on destruction
         granularity const g = microsecs, // This is the granularity of elapsed (default is microsecs)
         bool const a = false // If true add elapsed to future else assign elapsed to future
         )
         : future_(future), granularity_(g), accumulate_(a)
      {
      }

      ~scoped_stopwatch()
      {
         elapsed_t e;

         switch(granularity_)
         {
         case secs:
            e = sw_.elapsed_secs();
            break;
         case millisecs:
            e = sw_.elapsed_ms();
            break;
         case microsecs:
            e = sw_.elapsed_us();
            break;
         case nanosecs:
            e = sw_.elapsed_ns();
            break;
         default:
            e = sw_.elapsed();
            break;
         }

         future_ = e + (accumulate_ ? future_ : 0);
      }

   private:
      stopwatch sw_;
      elapsed_t & future_;
      granularity const granularity_;
      bool const accumulate_;
   };

}}

#endif // MOOST_UTILS_STOPWATCH_HPP__