clstimer.cpp

set of classes for timing applications

#include "clstimer.h"
#include <string.h>
#include <stdio.h>
#include <time.h>

//#############################################################################

clsTimer::clsTimer():
    m_lStartHour ( 0 ),
    m_lStartMin ( 0 ),
    m_lIntervalSec ( 0 ),
    m_lStartEntered ( false ),
    m_lIntervalEntered ( false ),
    m_lNextTime ( 0 )
{
}

//#############################################################################

clsTimer::~clsTimer()
{
}

//#############################################################################

long   clsTimer::SetStartTime    ( long lStartTime )
{
    tm* pTime;

    if ( ! lStartTime ) lStartTime = time(0);
    pTime = localtime( (time_t*)&lStartTime );
    return SetStartTime ( pTime->tm_hour , pTime->tm_min );
}

//#############################################################################

long   clsTimer::SetStartTime    ( long iHour , long iMinute )
{
    if ( iMinute < 0 ) iMinute = 0;
    if ( iMinute > 59 )
    {
        iHour += (iMinute / 60);
        iMinute = iMinute % 60;
    }
    if ( iHour < 0 ) iHour = 0;
    if ( iHour > 23 ) iHour = iHour % 24;

    //m_lStartEntered = true;
    m_lStartHour = iHour;
    m_lStartMin  = iMinute;

    m_lNextTime = 0;

    return true;
}

//#############################################################################

long   clsTimer::SetInterval     ( long iHour , long iMinute , long iSec )
{
    if ( iSec < 0 ) iSec = 0;
    if ( iSec > 59 )
    {
        iMinute += ( iMinute / 60 );
        iSec = iSec % 60;
    }

    if ( iMinute < 0 ) iMinute = 0;
    if ( iMinute > 59 )
    {
        iHour += (iMinute / 60);
        iMinute = iMinute % 60;
    }

    if ( iHour < 0 ) iHour = 0;
    if ( iHour > 24 ) iHour = 24;

    //if ( ! ( iHour || iMinute || iSec ) ) return false;

    //m_lIntervalEntered = true;

    m_lIntervalSec = iSec + ( iMinute * 60 ) + ( iHour * 3600 );

    //m_lNextTime = 0;

    return true;
}

//#############################################################################

long   clsTimer::SetInterval     ( long iSec )
{
    if ( iSec < 0 ) return false;
    m_lIntervalSec = iSec;
    //m_lNextTime = 0;
    //m_lIntervalEntered = true;
    return true;
}

//#############################################################################

long  clsTimer::UpdateNextTime  ( )
{
    tm*    pTime;
    tm     myTime;
    time_t tTimeNow = time(0);
    time_t tTimeNext;

    //prvo provjerimo jeli pocetni interval
    //da ne bi trazili sljedece vrijeme na interval nula
    //tada samo vratimo pocetno vrijeme (ili vrijeme koje je
    //zadnje izracunato
    if ( ! m_lIntervalSec ) return m_lNextTime;

    //struct tm *localtime(const time_t *timep);
    pTime = localtime( &tTimeNow );
    memcpy ( &myTime , pTime , sizeof(tm) );
    myTime.tm_sec  = 0;
    myTime.tm_hour = m_lStartHour;
    myTime.tm_min  = m_lStartMin;
    tTimeNext = mktime ( &myTime );
    if ( tTimeNow < tTimeNext ) //ako je pocetak tek poslije zapocmi dan prije
        tTimeNext -= ( 24 * 3600 );//smanji pocetak za jedan dan

    while ( tTimeNow >= tTimeNext )
    {
        tTimeNext += m_lIntervalSec;
    }

    m_lNextTime = tTimeNext;

    return m_lNextTime;
}

//#############################################################################

long    clsTimer::IsIntervalOver  ( )
{
    if ( m_lNextTime < time(0) )
        return true;
    return false;
}

//#############################################################################

char*    clsTimer::GetTimeString ( long lUnixTime )
{
    static long lMyUnixTime = -1;
    static char cTime[40];

    if ( lMyUnixTime == lUnixTime ) return cTime;
    lMyUnixTime = lUnixTime;

    tm*  pTm;
    pTm = localtime ( (const time_t*) &lUnixTime );
    sprintf ( cTime , "%02d.%02d.%02d %02d:%02d:%02d" ,
              pTm->tm_mday , pTm->tm_mon + 1 , pTm->tm_year+1900 ,
              pTm->tm_hour , pTm->tm_min , pTm->tm_sec );

    return cTime;
}

//#############################################################################

long     clsTimer::AddInterval     ( long lUnixTime , unsigned long lIntervalType , unsigned long lIntervalAmount )
{
    tm  oTmpTime;
    localtime_r ( &lUnixTime , &oTmpTime );
    return AddInterval ( oTmpTime , lIntervalType , lIntervalAmount );
}

//#############################################################################

long     clsTimer::AddInterval     ( tm& rTm , unsigned long lIntervalType , unsigned long lIntervalAmount )
{
    //TODO: ovo nevaljaaaaaa!!!!!!!!!!!
    switch ( lIntervalType )
    {
        case eitDays:
            rTm.tm_mday += lIntervalAmount;
            break;

        case eitWeeks:
            rTm.tm_mday += ( 7 * lIntervalAmount);
            break;

        case eitMonths:
            rTm.tm_mon += lIntervalAmount;
            break;

        case eitYears:
            rTm.tm_year += lIntervalAmount;
            break;

        default:
            return 0;
    }
    AdjustDstError  ( rTm );
    return mktime ( &rTm );
}

//#############################################################################

long     clsTimer::AdjustDstError  ( tm& rTm )
{
    tm            sTmpTime;
    tm*           pTmpTime;
    unsigned long lTime;
    //sada provjeri je li dodje do greske radi ukljucenja daylight saving time
    memcpy ( & sTmpTime , & rTm , sizeof ( struct tm ) );
    lTime = (unsigned long) mktime ( & sTmpTime );
    pTmpTime = localtime ( (const time_t*) & lTime );
    //ako je sat pobucan znaci da je greska
    if ( rTm.tm_hour != pTmpTime->tm_hour )
    {
        //ako nije stvar u DST onda ne znam u cemu je
        if ( rTm.tm_isdst == pTmpTime->tm_isdst )
            return false;
        //podesi DST na novu vrijednost i probaj ponovo
        rTm.tm_isdst = pTmpTime->tm_isdst;
        memcpy ( & sTmpTime , & rTm , sizeof ( struct tm ) );
        lTime = (unsigned long) mktime ( & sTmpTime );
        pTmpTime = localtime ( (const time_t*) & lTime );
        //ako je opet greska onda stvarno je nesto pobucano
        if ( rTm.tm_hour != pTmpTime->tm_hour )
            return false;
    }
    memcpy ( &rTm , pTmpTime , sizeof ( struct tm ));
    return true;
}

//#############################################################################

/*
long     clsTimer::GetStartStopTime( unsigned long lType , unsigned long lAmount , long& lStart , long& lStop )
{
    long lNow = time(0);
    switch ( lType )
    {
        case eitDays:
            break;
        case eitWeeks:
            break;
        case eitMonths:
            break;
        case eitYears:
            break;
        default:
            lStart = 0;
            lStop = 0;
            break;
    }
    return 0;
}
*/

//#############################################################################

//lIntervalType - day, week, month...
//lIntervalAmount - 0 current, -1 previous, +1 next...
long     clsTimer::GetStartTime    ( int lIntervalType , int lIntervalAmount )
{
    long lRet = 0;
    long lNow = time(0);

    tm*  pTm;
    pTm = localtime ( (const time_t*) &lNow );
    tm sTmpTime = *pTm;

    switch ( lIntervalType )
    {
        case eitDays:
            sTmpTime.tm_hour = 0;
            sTmpTime.tm_min = 0;
            sTmpTime.tm_sec = 0;
            lRet = mktime ( &sTmpTime );
            lRet += ( lIntervalAmount * 86400 );
            break;

        case eitWeeks:
        {
            sTmpTime.tm_hour = 0;
            sTmpTime.tm_min = 0;
            sTmpTime.tm_sec = 0;
            int iDayOfWeek = ( sTmpTime.tm_wday + 6 ) % 7;
            lRet = mktime ( &sTmpTime );
            lRet -= ( iDayOfWeek * 86400 );
            lRet += ( lIntervalAmount * 7 * 86400 );
            break;
        }

        case eitMonths:
            sTmpTime.tm_mday = 1;
            sTmpTime.tm_hour = 0;
            sTmpTime.tm_min = 0;
            sTmpTime.tm_sec = 0;
            sTmpTime.tm_mon += lIntervalAmount;
            while ( sTmpTime.tm_mon > 11 )
            {
                sTmpTime.tm_mon -= 12;
                sTmpTime.tm_year ++;
            }
            while ( sTmpTime.tm_mon < 0 )
            {
                sTmpTime.tm_mon += 12;
                sTmpTime.tm_year --;
            }
            lRet = mktime ( &sTmpTime );
            break;

        case eitYears:
            sTmpTime.tm_mon = 0;
            sTmpTime.tm_mday = 1;
            sTmpTime.tm_hour = 0;
            sTmpTime.tm_min = 0;
            sTmpTime.tm_sec = 0;
            sTmpTime.tm_year += lIntervalAmount;
            lRet = mktime ( &sTmpTime );
            break;

        default:
            return lRet;
    }
    return lRet;
}

//#############################################################################
//#############################################################################
//#############################################################################

clsPrecTimer::clsPrecTimer():
    m_sTime ( TimeZero() )
{
}

//#############################################################################

clsPrecTimer::~clsPrecTimer()
{
}

//#############################################################################

void    clsPrecTimer::SetToZero   ( )
{
    m_sTime = TimeZero();
}

//#############################################################################

void    clsPrecTimer::SetToNow          ( )
{
    m_sTime = TimeNow();
}

//#############################################################################

int     clsPrecTimer::InitInterval        ( unsigned int iSecs , unsigned int iMiliSecs )
{
    m_sTime = TimeNow();
    m_sTime.tv_sec += ( iSecs + ( iMiliSecs / 1000 ) );
    m_sTime.tv_usec += iMiliSecs * 1000;
    if ( m_sTime.tv_usec > 1000000l )
    {
        ++m_sTime.tv_sec;
        m_sTime.tv_usec = m_sTime.tv_usec % 1000000l;
    }
    return NoError;
}

//#############################################################################

int     clsPrecTimer::StopTimer           ( )
{
    m_sTime = TimeZero();
    return NoError;
}

//#############################################################################

bool    clsPrecTimer::IntervalFinished  ( ) const
{
    strPrecTime sTimeNow = TimeNow();
    return IntervalFinished ( sTimeNow.tv_sec , sTimeNow.tv_usec );
}

//#############################################################################

bool    clsPrecTimer::IntervalFinished  ( long lTimeNowSec , long lTimeNowUSec ) const
{
    if ( ! IntervalActive() )
        return true;
    if ( m_sTime.tv_sec < lTimeNowSec ||
         ( m_sTime.tv_sec == lTimeNowSec && m_sTime.tv_usec < lTimeNowUSec ) )
    {
        return true;
    }
    return false;
}

//#############################################################################

bool    clsPrecTimer::IntervalFinished  ( const clsPrecTimer& rEndTime ) const
{
    return IntervalFinished ( rEndTime.m_sTime.tv_sec , rEndTime.m_sTime.tv_usec );
}

//#############################################################################

bool    clsPrecTimer::IntervalFinished  ( const strPrecTime& rEndTime ) const
{
    return IntervalFinished ( rEndTime.tv_sec , rEndTime.tv_usec );
}

//#############################################################################

strPrecTime  clsPrecTimer::TimeNow ( )
{
    static struct timezone sTimeZone = { 0 , 0 }; //Dummy za gettimeofday
    static struct timeval sTimeVal; //Ovako moze biti preciznost u sekundama ili mikrosekundama
    gettimeofday( &sTimeVal , &sTimeZone );
    return sTimeVal;
}

//#############################################################################

strPrecTime  clsPrecTimer::TimeZero( )
{
    struct timeval sTimeVal = { 0 , 0 };
    return sTimeVal;
}

//#############################################################################

bool    clsPrecTimer::TimeoutEnd  ( const strPrecTime& rStart , const strPrecTime& rNow , long lIntervalMSecs )
{
    strPrecTime oTime ( rStart );
    oTime.tv_usec += ( lIntervalMSecs * 1000 );
    if ( oTime.tv_usec > 1000000l )
    {
        oTime.tv_sec += oTime.tv_usec / 1000000l;
        oTime.tv_usec %= 1000000l;
    }
    if ( rNow.tv_sec > oTime.tv_sec || ( rNow.tv_sec == oTime.tv_sec && rNow.tv_usec > oTime.tv_usec ) )
        return true;
    return false;
}

//#############################################################################