/home/vlg/develop/libASSA/libassa/assa/TimeVal.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                          TimeVal.h
//------------------------------------------------------------------------------
//  Copyright (c) 1999 by Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
//  Created: 09/28/1999
//------------------------------------------------------------------------------
#ifndef TIME_VAL_H
#define TIME_VAL_H

#include <sys/time.h>       // gettimeofday(3)
#include <unistd.h>     // gettimeofday(3)

#include <string> 
using std::string;

namespace ASSA {

class TimeVal : public timeval
{
public:
    enum { 
        gmt,                    
        loc                     
    };

    TimeVal ();

    TimeVal (long sec_, long msec_);

    TimeVal (double d_);

    TimeVal (const timeval& tv_);

    TimeVal (const TimeVal& tv_); 

    operator double () const;

    void sec (long sec_) { tv_sec = sec_; }

    long sec (void) const { return tv_sec; }

    void msec (long msec_) { tv_usec = msec_; }

    long msec (void) const { return tv_usec; }

    long millisec () const;

    void tz (int tz_) { m_tz = tz_; }

    int tz (void) const { return m_tz; }

    TimeVal& operator= (const TimeVal& tv_);

    TimeVal& operator+= (const TimeVal& rhs_);

    TimeVal& operator-= (const TimeVal& rhs_);

    friend TimeVal operator+(const TimeVal& lhs_, const TimeVal& rhs_);

    friend TimeVal operator-(const TimeVal& lhs_, const TimeVal& rhs_);

    bool operator< (const TimeVal& rhs_) const;

    bool operator==(const TimeVal& rhs_) const;

    friend bool operator> (const TimeVal& lhs_, const TimeVal& rhs_);

    friend bool operator!=(const TimeVal& lhs_, const TimeVal& rhs_);

    friend bool operator<=(const TimeVal& lhs_, const TimeVal& rhs_);

    friend bool operator>=(const TimeVal& lhs_, const TimeVal& rhs_);

    string fmtString (const char* fmt_ = NULL) const;

    string fmt_hh_mm_ss () const;

    string fmt_hh_mm_ss_mls () const;

    string fmt_mm_ss () const;

    string fmt_mm_ss_mls () const;

    string fmt_ss_mls () const;

    void dump_to_log (const string& name_ = "") const;

    static TimeVal zeroTime () { return m_zero; }

    static TimeVal gettimeofday ();

protected:
    void init (long, long, int);

private:
    void normalize ();

private:
    int m_tz;

    static TimeVal m_zero;
};
//------------------------------------------------------------------------------
// Inlines
//------------------------------------------------------------------------------

inline void
TimeVal::
init (long s_, long ms_, int tz_)
{
    tv_sec = s_;
    tv_usec = ms_;
    m_tz = tz_;
    normalize ();
}

inline 
TimeVal::
TimeVal ()
{
    init (0, 0, gmt);
}

inline 
TimeVal::
TimeVal (long sec_, long msec_) 
{
    init (sec_, msec_, gmt);
}

inline 
TimeVal::
TimeVal (double d_)
    : m_tz (gmt)
{
    long l = long(d_);
    tv_sec = l;
    tv_usec = (long) ((d_ - double(l))*1000000.0);
    normalize();
}

inline 
TimeVal::
TimeVal (const timeval& tv_)
{
    init (tv_.tv_sec, tv_.tv_usec, gmt);
}

inline 
TimeVal::
TimeVal (const TimeVal& tv_)
{
    init (tv_.tv_sec, tv_.tv_usec, tv_.m_tz);
}

inline 
TimeVal::operator double () const
{ 
    return tv_sec + tv_usec / 1000000.0;
}

inline long
TimeVal::
millisec () const
{
    return (msec () % 1000000) / 1000;
}

inline string
TimeVal::
fmt_hh_mm_ss () const
{
    return fmtString ("%T");
}

inline string
TimeVal::
fmt_mm_ss () const
{
    return fmtString ("%M:%S");
}

//------------------------------------------------------------------------------
// Friend functions
//------------------------------------------------------------------------------

inline TimeVal&
TimeVal::
operator=(const TimeVal& tv_)
{
    init (tv_.tv_sec, tv_.tv_usec, tv_.m_tz);
    return *this;
}

inline TimeVal
operator+(const TimeVal& lhs_, const TimeVal& rhs_)
{
    TimeVal temp(lhs_);
    temp += rhs_;
    temp.normalize ();
    return temp;
}

inline TimeVal
operator-(const TimeVal& lhs_, const TimeVal& rhs_)
{
    TimeVal temp(lhs_);
    temp -= rhs_;
    temp.normalize ();
    return temp;
}

inline bool 
TimeVal::
operator<(const TimeVal& rhs_) const
{
    return (tv_sec < rhs_.tv_sec
        || (tv_sec == rhs_.tv_sec && tv_usec < rhs_.tv_usec) ) ;
}

inline bool 
TimeVal::
operator==(const TimeVal& rhs_) const
{
    return !(*this < rhs_ || rhs_ < *this);
}

inline bool
operator> (const TimeVal& lhs_, const TimeVal& rhs_)
{
    return rhs_ < lhs_;
}

inline bool 
operator!=(const TimeVal& lhs_, const TimeVal& rhs_)
{
    return !( lhs_ == rhs_ );
}

inline bool
operator<=(const TimeVal& lhs_, const TimeVal& rhs_)
{
    return !(rhs_ < lhs_);
}

inline bool
operator>=(const TimeVal& lhs_, const TimeVal& rhs_)
{
    return !(lhs_ < rhs_);
}

} // end namespace ASSA

#endif /* TIME_VAL_H */  

---