/ray/src/lib/htime.cc

Go to the documentation of this file.

/*
 * lib/htime.cc
 * 
 * Implementation of methods supporting class HTime. 
 * 
 * Copyright (c) 2001--2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#include <lib/htime.h>

#include <stdio.h>   /* for snprintf() */
#include <ctype.h>


// Used constants: 
const int64_t HTime::conv_fact[HTime::_tslast]=
{ 1LL, 1000LL, 1000000LL, 60000000LL, 3600000000LL, 86400000000LL };

const int64_t HTime::round_delta[HTime::_tslast]=
{ 0LL,  500LL,  500000LL, 30000000LL, 1800000000LL, 43200000000LL };

const double HTime::conv_factD[HTime::_tslast]=
{ 1.0, 1000.0, 1000000.0, 60000000.0, 3600000000.0, 86400000000.0 };


static const char *_is_invalid_str="[invalid time]";


#if HTIME_WITH_MOST_CURRENT
// Static data: 
HTime HTime::most_current(HTime::Curr);
FastMutex HTime::most_current_mutex;
#endif


void HTime::_SetVal(long val,TimeSpec sp,timeval *tv)
{
    tv->tv_usec=0L;
    switch(sp)
    {
        case usec:
        {
            register long m=val/1000000;
            if(val<0)  --m;
            tv->tv_sec=m;
            tv->tv_usec=val-m*1000000;
        }  break;
        case msec:
        {
            register long m=val/1000;
            if(val<0)  --m;
            tv->tv_sec=m;
            tv->tv_usec=1000*(val-m*1000);
        }  break;
        case seconds:  tv->tv_sec=val;        break;
        case minutes:  tv->tv_sec=val*60;     break;
        case hours:    tv->tv_sec=val*3600;   break;
        case days:     tv->tv_sec=val*86400;  break;
        default:  tv->tv_sec=0;  break;
    }
}

void HTime::_SetValL(int64_t val,TimeSpec sp,timeval *tv)
{
    switch(sp)
    {
        case usec:
        {
            register int64_t m=val/1000000;
            if(val<0)  --m;
            tv->tv_sec=m;
            tv->tv_usec=val-m*1000000;
        }  break;
        case msec:
        {
            register int64_t m=val/1000;
            if(val<0)  --m;
            tv->tv_sec=m;
            tv->tv_usec=1000*(val-m*1000);
        }  break;
        case seconds:
            tv->tv_sec=val;
            tv->tv_usec=0L;
            break;
        default:  _SetVal(val,sp,tv);
    }
}


HTime &HTime::Add(long val,TimeSpec sp)
{
    if(!IsInvalid())
    {
        timeval tmp;
        _SetVal(val,sp,&tmp);
        tv.tv_sec+=tmp.tv_sec;
        tv.tv_usec+=tmp.tv_usec;
        _Normalize(&tv);
    }
    return(*this);
}


HTime &HTime::Sub(long val,TimeSpec sp)
{
    if(!IsInvalid())
    {
        timeval tmp;
        _SetVal(val,sp,&tmp);
        tv.tv_sec-=tmp.tv_sec;
        tv.tv_usec-=tmp.tv_usec;
        _Normalize(&tv);
    }
    return(*this);
}


int64_t HTime::_Delta(const HTime *endtime) const
{
    // May not be called if time is invalid. 
    timeval tmp;
    const timeval *end;
    if(endtime)
    {  end=&endtime->tv;  }
    else
    {  do_gettimeofday(&tmp);  end=&tmp;  }
    return(
        (int64_t(end->tv_sec)*int64_t(1000000) + int64_t(end->tv_usec)) - 
        (int64_t(  tv.tv_sec)*int64_t(1000000) + int64_t(  tv.tv_usec)) );
}


long HTime::MsecElapsed() const
{
    timeval current;
    do_gettimeofday(&current);
    return(
        (current.tv_sec  - tv.tv_sec )*1000L + 
        (current.tv_usec - tv.tv_usec)/1000L );
}

long HTime::MsecElapsedR() const
{
    timeval current;
    long du;
    do_gettimeofday(&current);
    du = (current.tv_usec - tv.tv_usec);
    return(
        (current.tv_sec  - tv.tv_sec)*1000L + 
        ((du<0L) ? (du-500) : (du+500) )/1000L );
}


// NOTE on sec and usec values: 
// True value is always sec+usec/1000000. 
// However, usec is ALWAYS in range 0...999999; NEVER negative. 

HTime HTime::operator-(const HTime &start) const
{
    HTime r(Invalid);
    
    if(!IsInvalid() && !start.IsInvalid())
    {
        r.tv.tv_sec= tv.tv_sec- start.tv.tv_sec;
        r.tv.tv_usec=tv.tv_usec-start.tv.tv_usec;
        _Normalize(&r.tv);
    }
    
    return(r);
}

HTime &HTime::operator-=(const HTime &start)
{
    if(!IsInvalid())
    {
        if(start.IsInvalid())
        {  SetInvalid();  }
        else
        {
            tv.tv_sec-= start.tv.tv_sec;
            tv.tv_usec-=start.tv.tv_usec;
            _Normalize(&tv);
        }
    }
    return(*this);
}


HTime HTime::operator+(const HTime &start) const
{
    HTime r(Invalid);
    
    if(!IsInvalid() && !start.IsInvalid())
    {
        r.tv.tv_sec= tv.tv_sec+ start.tv.tv_sec;
        r.tv.tv_usec=tv.tv_usec+start.tv.tv_usec;
        _Normalize(&r.tv);
    }
    
    return(r);
}

HTime &HTime::operator+=(const HTime &start)
{
    if(!IsInvalid())
    {
        if(start.IsInvalid())
        {  SetInvalid();  }
        else
        {
            tv.tv_sec+= start.tv.tv_sec;
            tv.tv_usec+=start.tv.tv_usec;
            _Normalize(&tv);
        }
    }
    return(*this);
}


HTime &HTime::operator-()
{
    if(!IsInvalid())
    {
        tv.tv_sec=-tv.tv_sec;
        tv.tv_usec=-tv.tv_usec;
        _Normalize(&tv);
    }
    return(*this);
}


HTime &HTime::Div(int fact)
{
    if(!IsInvalid())
    {
        if(!fact)
        {  SetInvalid();  }
        else
        {
            if(fact<0)
            {
                tv.tv_sec=-tv.tv_sec;
                tv.tv_usec=-tv.tv_usec;
                _Normalize(&tv);
                fact=-fact;
            }
            
            // This may overflow if fact is large 
            // (around 2000 on 32bit systems). 
            tv.tv_usec=((tv.tv_sec%fact)*1000000+tv.tv_usec)/fact;
            tv.tv_sec/=fact;
            _Normalize(&tv);
        }
    }
    return(*this);
}


char *HTime::PrintTime(char *buf,size_t len,int local,int with_msec) const
{
    // Negative times do not make sense here. 
    // (Or should that be before 1970?!)
    if(tv.tv_sec<0)  // This check is correct and sufficient. (usec NEVER negative)
    {  snprintf(buf,len,"[negative time]");  return(buf);  }
    if(IsInvalid())
    {  snprintf(buf,len,_is_invalid_str);  return(buf);  }
    
    time_t timep=tv.tv_sec;
    int msec=(tv.tv_usec+500)/1000;
    if(msec>=1000)
    {  ++timep;  msec-=1000;  }
    if(msec>=500 && !with_msec)  ++timep;  
    
    struct tm stm;
    if(local)  localtime_r(&timep,&stm);
    else       gmtime_r(&timep,&stm);
    
    char *ptr=buf;
    char *end=buf+len;
    ptr+=strftime(ptr,end-buf,"%a %b %d %Y, %H:%M:%S",&stm);
    if(with_msec && end>buf)
    {  ptr+=snprintf(ptr,end-ptr,".%03d",msec);  }
    if(end>buf)
    {  strftime(ptr,end-buf," %Z",&stm);  }
    
    return(buf);
}


char *HTime::PrintElapsed(char *buf,size_t len,int with_msec) const
{
    if(IsInvalid())
    {  snprintf(buf,len,_is_invalid_str);  return(buf);  }
    
    char *ptr=buf;
    char *end=buf+len;
    
    long sec,msec;
    if(tv.tv_sec>=0)  // This check is correct and sufficient. (usec NEVER negative)
    {
        sec=tv.tv_sec;
        msec=(tv.tv_usec+500)/1000;
    }
    else
    {
        sec=-tv.tv_sec-1;
        msec=((1000000-tv.tv_usec)+500)/1000;
        *(ptr++)='-';
    }
    if(msec>=1000)
    {  --sec;  msec-=1000;  }
    // Correct rounding. (sec>=0 here because negative case handeled above). 
    if(!with_msec && msec>=500)
    {  ++sec;  }
    
    long hours=(sec/3600);
    if(hours>48)
    {
        ptr+=snprintf(ptr,end-ptr,"%ldd ",hours/24);
        hours%=24;
    }
    snprintf(ptr,end-ptr,with_msec ? "%02ld:%02ld:%02ld.%03ld" : "%02ld:%02ld:%02ld",
        hours,
        (sec/60)%60,
        sec%60,
        msec);
    
    return(buf);
}


//                            ** WARNING: **
// DO NOT TOUCH THIS FUNCTION UNLESS YOU REALLY KNOW WHAT YOU ARE DOING. 
int HTime::_DoReadTime(const char *str)
{
    // First, set up t with current local time: 
    time_t timep;
    ::time(&timep);
    struct tm t;
    ::localtime_r(&timep,&t);
    
    // state: 
    //   0 -> decide
    //   1 -> read date 15.06.[2002]
    //   2 -> read date 2002/06/15
    //   3 -> read time 17:22[:32]
    // done: bit 1,2 -> date
    //       bit   3 -> time
    //       ( so that we can check (done & (1<<state)) )
    short int state=0,done=0;
    int mode=0;  // mode=1 for "+"; mode=-1 for "-". 
    
    const char *s=str;
    int tmp;
    char *end;
    while(isspace(*s))  ++s;
    if(!strncmp(s,"now",3) || !strncmp(s,"NOW",3))
    {
        s+=3;
        while(isspace(*s))  ++s;
        if(*s)  // specified something after "now"
        {
            if(*s=='+')  mode=1;
            else if(*s=='-')  mode=-1;
            else  return(-2);
            // In this case I only allow to add a time, not a date. 
            ++s;  done|=6;
            
            // Special cases: "now + DD" and "now + :SS": 
            while(isspace(*s))  ++s;
            // DO NOT modify s below here. 
            short int issec = (*s==':') ? 1 : 0;
            tmp=(int)strtol(s+issec,&end,10);
            while(isspace(*end))  ++end;
            if(!(*end) && tmp>=0 && end>s+issec)
            {
                if(issec)  t.tm_sec+=mode*tmp;
                else       t.tm_mday+=mode*tmp;
                s=end;   // --> *s='\0'
            }
            // fall through to rest
        }
        // If !(*s) we will not enter the while loop and set 
        // current date and time. 
    }
    
    // Prevent any negative values...
    if(strchr(s,'-'))
    {  return(-1);  }
    
    int data[3];
    int di=0;  // data index
    while(*s)
    {
        while(isspace(*s) || (state==0 && *s==','))  ++s;
        if(!(*s))  break;
        
        tmp=(int)strtol(s,&end,10);
        if(s==end)
        {
            //fprintf(stderr,"format error: %s\n",s);
            return(-1);
        }
        s=end;
        
        switch(state)
        {
            case 0:  // decide what to do
                switch(*s)
                {
                    case '.':  state=1;  break;
                    case '/':  state=2;  break;
                    case ':':  state=3;  break;
                    default:
                        //fprintf(stderr,"format error: %s\n",s);
                        return(-1);
                }
                if(state)
                {
                    if(done & (1<<state))
                    {
                        //fprintf(stderr,"specified more than once\n");
                        return(-2);
                    }
                    data[di++]=tmp;
                    ++s;
                }
                break;
            case 1:  // "15.06.2002" or "15.06."
                if(*s=='.' && di==1)  // month
                {
                    data[di++]=tmp;
                    ++s;
                    if(!(*s) || isspace(*s) || *s==',')
                    {  goto datedone1;  }
                }
                else if(di==2)  // year
                {
                    t.tm_year=tmp-1900;
                    datedone1:
                    t.tm_mday=data[0];
                    t.tm_mon=data[1]-1;
                    state=0;  di=0;  done|=6;
                }
                else
                {
                    //fprintf(stderr,"format error: %s\n",s);
                    return(-1);
                }
                break;
            case 2:  // "2002/06/15"
                if(*s=='/' && di==1)  // month
                {
                    data[di++]=tmp;
                    ++s;
                }
                else if(di==2)   // day
                {
                    t.tm_mday=tmp;
                    t.tm_mon=data[1]-1;
                    t.tm_year=data[0]-1900;
                    state=0;  di=0;  done|=6;
                }
                else
                {
                    //fprintf(stderr,"format error: %s\n",s);
                    return(-1);
                }
                break;
            case 3:  // "17:22:32" or "17:22"
                if((*s==':' || !(*s) || isspace(*s) || *s==',') && di==1)  // minutes
                {
                    data[di++]=tmp;
                    tmp=0;
                    if(*s==':')  ++s;
                    if(!(*s) || isspace(*s) || *s==',')  goto  timedone;
                }
                else if(di==2)  // seconds
                {
                    data[di++]=tmp;  // yes! [DO NOT REMOVE]
                    timedone:
                    if(mode==0)
                    {
                        t.tm_hour=data[0];
                        t.tm_min=data[1];
                        t.tm_sec=tmp;
                    }
                    else
                    {
                                 t.tm_sec+=mode*data[--di];
                        if(di) { t.tm_min+=mode*data[--di];
                        if(di)   t.tm_hour+=mode*data[--di]; }
                    }
                    state=0;  di=0;  done|=8;
                }
                else
                {
                    //fprintf(stderr,"format error: %s\n",s);
                    return(-1);
                }
                break;
        }
    }
    if(di)
    {
        //fprintf(stderr,"format error: di=%d\n",di);
        return(-1);
    }
    
    timep=mktime(&t);
    if(timep<0)
    {
        //fprintf(stderr,"mktime error\n");
        return(-3);
    }
    
    // Store it...
    tv.tv_sec=timep;
    tv.tv_usec=0;
    
    // Check: This may show a time difference becuase LOCAL time 
    //        was read in. 
    //fprintf(stderr,"SUCCESS= %s",ctime(&timep));  // <-- NOT thread-safe!
    
    return(0);
}

---