cpptime.cpp

s/w handheld terminal ( based on Cygnal 8051f230)

#include <ctime>        // time(), localtime(), asctime(), difftime(), ...
#include "string.h"     // strcpy()
#include "CppTime.h"

//********************************** KTime << BEGIN >> **************************************
void KTime::updateLocal( bool bForce ) {
    if( bForce || !lflag ) {
        local = *localtime(&t);
        lflag = true;
    }
}

void KTime::updateAscii( bool bForce ) {
    if( bForce || !aflag ) {
       updateLocal( bForce );
       strcpy(asciiRep, asctime(&local));
       aflag = true;
    }
}

// Default konstruktor
KTime::KTime( void ) { 
    mark(); 
};

// Konstruktor
KTime::KTime( time_t time ){
    mark( time );
}

// Konstruktor
KTime::KTime( struct tm* timeptr ){
    time_t pomTime;
    pomTime = mktime( timeptr );
    if ( pomTime != (time_t)-1 ) mark( pomTime );
    else mark();
}

void KTime::mark() {
    lflag = aflag = false;
    bNulaDatum = false; 
    time(&t);
}

void KTime::mark( time_t time ) {
    lflag = aflag = false;
    bNulaDatum = false; 
    t = time;
}

const char* KTime::ascii() {
    updateAscii();
    return asciiRep;
}

// Vraca string koji predstavlja vreme u zadatom formatu
const char* KTime::FormatStr( const char *format ){
    updateLocal( true );
    strftime( formatStr, DUZINA_FORMAT, format, &local );

    return formatStr;
}

// Racuna vremensku razliku u odnosu na 'dt'
int KTime::delta(KTime* dt) const {
    return int(difftime(t, dt->t));
}

// Vraca strukturu tm ( razdvojeni podaci o vremenu i datumu : sekunde, minuti, ... )
tm KTime::GetLocal( void ){
    updateLocal( true );
    return local;
}

// Vraca strukturu time_t
time_t KTime::GetTimeT( void ){
    return t;
}

// Postavlja vreme ( cas, minut, sekunde ); u slucaju neuspeha vraca false.
// Ponekad 'cas' nije moguce setovati na zeljenu vrednost ( verovatno zbog 
// DST - daylight saving time ); u tom slucaju, moguce je 'forsirati' postavljanje
// casa na racun pomeranja godine ( ako godina u datom kontekstu nije bitna ).
bool KTime::PostaviVreme( int nCas, int nMinut, int nSekunda, bool bForsirajCas ){

    bool izlaz = false;

    updateLocal( true );
    local.tm_hour   = nCas;
    local.tm_min    = nMinut;
    local.tm_sec    = nSekunda;
    local.tm_isdst  = -1;
    time_t pomTime;
    pomTime = mktime( &local );

    // Funkcija 'mktime' hoce da prepravi sate po svom nahodjenju ( verovatno zbog DST ),
    // pa nikako nije moguce nasetovati vreme ( npr. za datum 30.03.2003, vreme 02:00
    // uvek se pretvori u 01:00 ili u 03:00 ).
    // Jedini nacin da se dobije trazeno vreme je da se pomeri godina, pa imamo :
    if ( bForsirajCas ){
        while( (local.tm_hour != nCas) && (pomTime != (time_t)-1) ) {
        local.tm_year++;
        local.tm_hour   = nCas;
        pomTime = mktime( &local );
        }
    }

    if ( pomTime != (time_t)-1 ) {  // Ako je 'kreiranje' uspelo
        t     = pomTime;
        izlaz = true;
    }
    else {
        updateLocal( true );
    }

    return izlaz;
}

// Postavlja datum ( dan, mesec, godina ); u slucaju neuspeha vraca false.
bool KTime::PostaviDatum( int nDan, int nMesec, int nGodina ){
    bool izlaz = false;

    // Postavi fleg za 'nula datum'.
    if ( nDan == 0 && nMesec == 0 )
        bNulaDatum = true;
    else
        bNulaDatum = false;

    if ( !( nDan == 0 && nMesec == 0 && nGodina == 0 ) ) { // Ako je datum 'NULA', ne diraj ga
        // Ako datum nije 'NULA' i ako je godina 'tekuca'
        if      ( nGodina == TEKUCA_GOD ) nGodina = TekucaGodina();
        // Ako datum nije 'NULA' i ako je godina zadata samo sa 2 cifre, dodaj tekuci vek
        else if ( nGodina >= 0 && nGodina <= 99 ) nGodina += PocetakTekucegVeka();
    }

    updateLocal( true );
    local.tm_mday   = nDan;
    if ( nMesec > 0 ) 
        local.tm_mon = nMesec - 1;
    else 
        local.tm_mon = 0;
    if ( nGodina > 0 )
        local.tm_year = nGodina - 1900;
    else
        local.tm_year = 0;

    time_t pomTime;
    // Zapamti sate ( 'mktime' automatski pomera na letnje i zimsko vreme, a meni to ne treba )
    int nSatiBackup = local.tm_hour;
    pomTime = mktime( &local );
    // Ako treba, vrati sate na staro
    if ( local.tm_hour != nSatiBackup ){
        local.tm_hour = nSatiBackup;
        pomTime = mktime( &local );
    }
    if ( pomTime != (time_t)-1 ) {
        t     = pomTime;
        izlaz = true;
    }
    else {
        updateLocal( true );
    }
   
    return izlaz;
}

// Vraca godinu pocetka tekuceg veka ( npr. 1900 ili 2000 )
int KTime::PocetakTekucegVeka( void ){
    return 2000; // Neka ga ovako, da se ne bi oslanjao na tacnost datuma na PC-u.
}

// Vraca tekucu godinu ( npr. 2002 )
int KTime::TekucaGodina( void ){
    KTime trenutnoVreme;
    tm opis = trenutnoVreme.GetLocal();

    return ( opis.tm_year + 1900 );
}

// Pauzira izvrsenje dati broj sekundi
void KTime::PauzaSek( double nSekundi ){
    KClock start;
    bool bIstekoTajmaut = false;
    while ( !bIstekoTajmaut ) {
        KClock end;
        if ( end.delta( &start ) > nSekundi ) bIstekoTajmaut = true;
    }
}

// Vraca true ako se radi o 'nula' datumu ( mesec i dan setovani na 0 pomocu PostaviDatum ).
// Koristi se kod rucnog formatiranja ispisa ( zato sto funkcija FormatStr ne moze da 
// ispise datum 00.00.0000 )
bool KTime::NulaDatum( void ){
    return bNulaDatum;
}

//*********************************** KTime << END >> ***************************************

//********************************** KClock << BEGIN >> **************************************
KClock::KClock( void ){ mark(); }

void KClock::mark() {
    CPUclock = clock();
}

// Racuna vremensku razliku ( u sekundama ) u odnosu na 'CPUclk'
double KClock::delta( KClock* CPUclk ) const {
    double nRazlika = ( double ) ( CPUclk->CPUclock - this->CPUclock );
    if ( nRazlika < 0 ) nRazlika = ( -nRazlika );

    return ( nRazlika / ( double ) BROJ_CPU_TAKTOVA_U_SEKUNDI );
}
//*********************************** KClock << END >> ***************************************