TimeValue.h

Go to the documentation of this file.

  /* Copyright 2006-2008 Savarese Software Research Corporation
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.savarese.com/software/ApacheLicense-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  #ifndef __SSRC_WISP_UTILITY_TIME_VALUE_H
  #define __SSRC_WISP_UTILITY_TIME_VALUE_H
  
  #include <ssrc/wisp-packages.h>
  
  #include <cstdint>
  #include <stdexcept>
  #include <limits>
  #include <ctime>
  #include <time.h>
  
  #if defined(WISP_HAVE_MACH_CLOCK_H)
  #include <mach/mach_host.h>
  #include <mach/clock.h>
  #endif
  
  __BEGIN_NS_SSRC_WISP_UTILITY
  
  #define __WISP_BILLION 1000000000
  
  class TimeValue {
   timespec _time;
  
  
  #ifdef WISP_HAVE_CLOCK_GETTIME
   static int gettime(::clockid_t clk_id, timespec *tp) {
   return ::clock_gettime(clk_id, tp);
   }
  #elif defined(WISP_HAVE_CLOCK_GET_TIME)
   static int gettime(::clock_id_t clk_id, timespec *tp) {
   ::clock_serv_t clock_serv;
   ::mach_timespec_t mtp;
   int result = -1;
  
   if((::host_get_clock_service(mach_host_self(), clk_id, &clock_serv) ==
   KERN_SUCCESS))
   {
   if(::clock_get_time(clock_serv, &mtp) == KERN_SUCCESS) {
   tp->tv_sec = mtp.tv_sec;
   tp->tv_nsec = mtp.tv_nsec;
   result = 0;
   }
   }
   return result;
   }
  #else
  # error "System does not implement POSIX clock_gettime or MACH clock_get_time."
  #endif
  
  public:
   typedef std::int64_t ms_type;
   typedef time_t sec_type;
   typedef long nsec_type;
   typedef std::numeric_limits<sec_type> sec_type_traits;
  
   static sec_type now_seconds() {
   return std::time(0);
   }
  
   static TimeValue time() {
   return TimeValue().now();
   }
  
   TimeValue() {
   _time.tv_sec = _time.tv_nsec = 0;
   }
  
   TimeValue(const sec_type seconds,
   const nsec_type nanoseconds)
   SSRC_DECL_THROW(std::invalid_argument)
   {
   if(seconds < 0 || nanoseconds < 0)
   throw std::invalid_argument("negative time");
  
   if(nanoseconds >= __WISP_BILLION) {
   _time.tv_sec = seconds + nanoseconds / __WISP_BILLION;
   _time.tv_nsec = nanoseconds % __WISP_BILLION;
   } else {
   _time.tv_sec = seconds;
   _time.tv_nsec = nanoseconds;
   }
   }
  
   explicit TimeValue(const ms_type millisec) {
   _time.tv_sec = millisec / 1000;
   _time.tv_nsec = (millisec % 1000) * 1000000;
   }
  
   TimeValue & now() {
  #ifdef WISP_HAVE_CLOCK_GETTIME
   gettime(CLOCK_REALTIME, &_time);
  #elif defined(WISP_HAVE_CLOCK_GET_TIME)
   gettime(CALENDAR_CLOCK, &_time);
  #endif
   return *this;
   }
  
   TimeValue & now_mono() {
  #ifdef WISP_HAVE_CLOCK_GETTIME
   gettime(CLOCK_MONOTONIC, &_time);
  #elif defined(WISP_HAVE_CLOCK_GET_TIME)
   gettime(SYSTEM_CLOCK, &_time);
  #endif
   return *this;
   }
  
   ms_type to_milliseconds() const {
   return (static_cast<ms_type>(_time.tv_sec)*1000 +
   (_time.tv_nsec + 999999)/1000000);
   }
  
   sec_type seconds() const throw () {
   return _time.tv_sec;
   }
  
   nsec_type nanoseconds() const throw () {
   return _time.tv_nsec;
   }
  
   TimeValue & operator+=(const TimeValue & t2) {
   _time.tv_sec+=t2._time.tv_sec;
   _time.tv_nsec+=t2._time.tv_nsec;
  
   if(_time.tv_nsec >= __WISP_BILLION) {
   ++_time.tv_sec;
   _time.tv_nsec-=__WISP_BILLION;
   }
  
   return *this;
   }
  
   TimeValue & operator-=(const TimeValue & t2) {
   _time.tv_sec-=t2._time.tv_sec;
   _time.tv_nsec-=t2._time.tv_nsec;
  
   if(_time.tv_nsec < 0) {
   --_time.tv_sec;
   _time.tv_nsec+=__WISP_BILLION;
   }
  
   return *this;
   }
  
   friend bool operator==(const TimeValue & t1, const TimeValue & t2) {
   return (t1._time.tv_sec == t2._time.tv_sec &&
   t1._time.tv_nsec == t2._time.tv_nsec);
   }
  
   friend bool operator<(const TimeValue & t1, const TimeValue & t2) {
   return (t1._time.tv_sec < t2._time.tv_sec ||
   (t1._time.tv_sec == t2._time.tv_sec &&
   t1._time.tv_nsec < t2._time.tv_nsec));
   }
  
   template<class Archive>
   void serialize(Archive & ar, const unsigned int) {
   ar & _time.tv_sec & _time.tv_nsec;
   }
  };
  
  inline TimeValue operator-(const TimeValue & t1, const TimeValue & t2) {
   TimeValue result(t1);
   return (result-=t2);
  }
  
  inline TimeValue operator+(const TimeValue & t1, const TimeValue & t2) {
   TimeValue result(t1);
   return (result+=t2);
  }
  
  const TimeValue InfiniteTimeValue =
   TimeValue(TimeValue::sec_type_traits::max(), 0);
  
  #undef __WISP_BILLION
  
  __END_NS_SSRC_WISP_UTILITY
  
  #endif