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 <ctime>
#include <time.h>

#if defined(WISP_HAVE_MACH_CLOCK_H)
#include <mach/mach_host.h>
#include <mach/clock.h>
#endif

#include <boost/integer_traits.hpp>

__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 boost::integer_traits<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::const_max, 0);

#undef __WISP_BILLION

__END_NS_SSRC_WISP_UTILITY

#endif