ctime.hpp

#ifndef DDF_CTIME_HPP
#define DDF_CTIME_HPP

#include <boost/cstdint.hpp>
#include <boost/thread/xtime.hpp>
#include <boost/thread/thread.hpp>
#include <iosfwd>
#include <iostream>

namespace jafar
{
  namespace ddf
  {

    class time
    {
    public:
      typedef time_t       sec_t;
      typedef suseconds_t  usec_t;
      static const int UsecPerSec = 1000000;

    private:
      enum Type
        { // ORDER MATTERS
          Normal,
          Infty
        };
        
      Type   m_type;
      sec_t  m_sec;
      usec_t m_usec;
           
      explicit time(Type mode)
        : m_type(mode), m_sec(0), m_usec(0) {}

      void assign(sec_t sec, usec_t usec);
      int compare(time const& other) const;

    public:
        
      explicit time(sec_t sec = 0, usec_t usec = 0): m_type(Normal)
      {
        // operator + and operator - rely on this
        assign(sec, usec);
      }

      explicit time(double d): m_type(Normal)
      {
        sec_t sec = static_cast<sec_t> (d);
        usec_t usec = static_cast<usec_t> (UsecPerSec * (d- (double) sec));
        assign(sec, usec);
      }

      explicit time(timeval const& t): m_type(Normal), m_sec(t.tv_sec), m_usec(t.tv_usec) {}

      bool is_normal() const { return m_type == Normal; }
      bool is_infty() const  { return m_type == Infty; }
      bool is_null() const   { return m_type == Normal && !m_sec && !m_usec; }

      static time infty() { return time(Infty); }
      static time null()  { return time(); }
      static time current();

      static time from_ms(int msecs) { return time(0, msecs * 1000); }
      static time from_us(int usecs) { return time(0, usecs); }

      time_t s() const { return m_sec; }
      time_t ms() const { return m_usec / 1000; }
      time_t us() const { return m_usec; }
   
      timeval to_timeval() const
      {
        timeval tv = { m_sec, m_usec };
        return tv;
      }

      timespec to_timespec() const
      {
        timespec ts = { m_sec, m_usec * 1000 };
        return ts;
      }

      double to_double() const
      {
        return (double) (m_sec + ((double) m_usec) / ((double) UsecPerSec));
      }

      boost::xtime to_xtime() const;

      void sleep_period() const
      {
        timeval tv = to_timeval();
        select(0,0,0,0,&tv);
      }

      void sleep_until() const
      {
        boost::thread::sleep(to_xtime());
      }

      bool check_close(time const& other, time const& epsilon) const;

      bool operator > (const time& t) const;
      bool operator >= (const time& t) const;
      bool operator < (const time& t) const;
      bool operator <= (const time& t) const;
      bool operator == (const time& t) const;
      bool operator != (const time& t) const;
      time operator - (const time& other) const;
      time operator + (const time& other) const;
      time operator / (double divider) const;
      time operator * (double multipl) const;
      void operator = (const time& other);

      friend std::istream& operator >> (std::istream& stream, time& t);
      friend std::ostream& operator << (std::ostream& stream, const time& t);
    };
    
    std::ostream& operator << (std::ostream& stream, const time& t);
    
  } // namespace ddf
} // namespace jafar
#endif