SbTime.h

Go to the documentation of this file.

/*
 *
 *  Copyright (C) 2000 Silicon Graphics, Inc.  All Rights Reserved.
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  Further, this software is distributed without any warranty that it is
 *  free of the rightful claim of any third person regarding infringement
 *  or the like.  Any license provided herein, whether implied or
 *  otherwise, applies only to this software file.  Patent licenses, if
 *  any, provided herein do not apply to combinations of this program with
 *  other software, or any other product whatsoever.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 *  Mountain View, CA  94043, or:
 *
 *  http://www.sgi.com
 *
 *  For further information regarding this notice, see:
 *
 *  http://oss.sgi.com/projects/GenInfo/NoticeExplan/
 *
 */
 
 
/*
 * Copyright (C) 1990,91   Silicon Graphics, Inc.
 *
 _______________________________________________________________________
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 |
 |   $Revision: 1.3 $
 |
 |   Description:
 |      This file defines the SbTime class for manipulating times
 |
 |   Classes:
 |      SbTime
 |
 |   Author(s)          : Nick Thompson
 |
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 _______________________________________________________________________
 */
 
#ifndef _SB_TIME_
#define _SB_TIME_
 
#include <Inventor/system/SbSystem.h>
#ifdef WIN32
#include <sys/timeb.h>
#else
#include <sys/time.h>
#endif
#include <math.h>
#include <limits.h>
#include <Inventor/SbBasic.h>
#include <Inventor/SbString.h>
 
 
 
 
class INVENTOR_API SbTime {
  public:
 
    SbTime()                                    {}
 
    SbTime(double sec);
 
    SbTime(time_t sec, long usec)               
        { t.tv_sec = static_cast<long>(sec); t.tv_usec = usec; }
 
  private:
    SbTime(uint32_t msec);
  public:
 
    SbTime(const struct timeval *tv)
        { t.tv_sec = tv->tv_sec; t.tv_usec = tv->tv_usec; }
 
    static SbTime               getTimeOfDay();
 
    void                        setToTimeOfDay();
 
    static SbTime               zero()
        { return SbTime(0, 0); }
 
#ifndef INT32_MAX
#define INT32_MAX INT_MAX
#endif // !INT32_MAX
 
#ifdef WIN32
#undef max
#endif
 
    static SbTime               max()
        { return SbTime(INT32_MAX, 999999); }
 
    void                setValue(double sec)
#ifdef __sgi
        { t.tv_sec = time_t(trunc(sec));
#else
        { t.tv_sec = time_t(int(sec));
#endif // __sgi
          t.tv_usec = long((sec - t.tv_sec) * 1000000.0); }
 
    void                setValue(time_t sec, long usec)         
        { t.tv_sec = static_cast<long>(sec); t.tv_usec = usec; }
 
    void                setValue(const struct timeval *tv)
        { t.tv_sec = tv->tv_sec; t.tv_usec = tv->tv_usec; }
 
    void                setMsecValue(unsigned long msec)        // System long
        { t.tv_sec = time_t(msec/1000);
          t.tv_usec = long(1000 * (msec % 1000)); }
 
    double              getValue() const
        { return (double) t.tv_sec + (double) t.tv_usec / 1000000.0; }
 
    void                getValue(time_t &sec, long &usec) const  
        { sec = t.tv_sec; usec = t.tv_usec; }
 
    void                getValue(struct timeval *tv) const
        { tv->tv_sec = t.tv_sec; tv->tv_usec = t.tv_usec; }
 
    unsigned long       getMsecValue() const                    // System long
        { return t.tv_sec * 1000 + t.tv_usec / 1000; }
 
    SbString                    format(const char *fmt = "%S.%i") const;
 
    SbString                    formatDate(const char *fmt = "%A, %D %r") const;
 
    friend INVENTOR_API SbTime          operator +(const SbTime &t0, const SbTime &t1);
 
    friend INVENTOR_API SbTime          operator -(const SbTime &t0, const SbTime &t1);
 
    SbTime &                    operator +=(const SbTime &tm)
        { return (*this = *this + tm); }
 
    SbTime &                    operator -=(const SbTime &tm)
        { return (*this = *this - tm); }
 
    SbTime                      operator -() const
        { return (t.tv_usec == 0) ? SbTime(- t.tv_sec, 0)
              : SbTime(- t.tv_sec - 1, 1000000 - t.tv_usec); }
 
    friend INVENTOR_API SbTime          operator *(const SbTime &tm, double s);
 
    friend INVENTOR_API SbTime          operator *(double s, const SbTime &tm);
 
    SbTime &                    operator *=(double s)
        { *this = *this * s; return *this; }
 
    friend INVENTOR_API SbTime          operator /(const SbTime &tm, double s);
 
    SbTime &                    operator /=(double s)
        { return (*this = *this / s); }
 
    double                      operator /(const SbTime &tm) const
        { return getValue() / tm.getValue(); }
 
    SbTime                      operator %(const SbTime &tm) const
        { return *this - tm * floor(*this / tm); }
 
    bool                           operator ==(const SbTime &tm) const
        { return (t.tv_sec == tm.t.tv_sec) && (t.tv_usec == tm.t.tv_usec); }
 
    bool                           operator !=(const SbTime &tm) const
        { return ! (*this == tm); }
 
    inline bool                 operator <(const SbTime &tm) const;
    inline bool                 operator >(const SbTime &tm) const;
    inline bool                 operator <=(const SbTime &tm) const;
    inline bool                 operator >=(const SbTime &tm) const;
 
  private:
    struct timeval              t;
};
 
INVENTOR_API SbTime          operator +(const SbTime &t0, const SbTime &t1);
INVENTOR_API SbTime          operator -(const SbTime &t0, const SbTime &t1);
INVENTOR_API SbTime          operator *(const SbTime &tm, double s);
inline INVENTOR_API SbTime   operator *(double s, const SbTime &tm)
{ return tm * s; }
INVENTOR_API SbTime          operator /(const SbTime &tm, double s);
 
 
inline bool
SbTime::operator <(const SbTime &tm) const
{
    if ((t.tv_sec < tm.t.tv_sec) ||
        (t.tv_sec == tm.t.tv_sec && t.tv_usec < tm.t.tv_usec))
        return TRUE;
    else
        return FALSE;
}
 
inline bool
SbTime::operator >(const SbTime &tm) const
{
    if ((t.tv_sec > tm.t.tv_sec) ||
        (t.tv_sec == tm.t.tv_sec && t.tv_usec > tm.t.tv_usec))
        return TRUE;
    else
        return FALSE;
}
 
inline bool
SbTime::operator <=(const SbTime &tm) const
{
    if ((t.tv_sec < tm.t.tv_sec) ||
        (t.tv_sec == tm.t.tv_sec && t.tv_usec <= tm.t.tv_usec))
        return TRUE;
    else
        return FALSE;
}
 
inline bool
SbTime::operator >=(const SbTime &tm) const
{
    if ((t.tv_sec > tm.t.tv_sec) ||
        (t.tv_sec == tm.t.tv_sec && t.tv_usec >= tm.t.tv_usec))
        return TRUE;
    else
        return FALSE;
}
 
 
#endif /* _SB_TIME_ */