korisno.cpp

load data from pc to hand held terminal and vice versa

/*
    Klasa sa korisnim procedurama koje se koriste u raznim drugim klasama.
    Klasa je 'singleton': pristup procedurama se vrsi preko pointera 'KKorisno::Instance()'.
*/
#include "Korisno.h"
#include "Konfig.h"

//*********************************** KString << BEGIN >> ***************************************
// Konstruktori
KString::KString( string cSadrzaj ){
    cString = cSadrzaj;
}

KString::KString( void ){
    cString = "";
}

// Operator pristupa elementu stringa
char& KString::operator[] ( unsigned int nPos ){
    return cString[ nPos ];
}

// Operator +=
KString& KString::operator+=( const KString& s ){
    cString += s.cString;
    return (*this);
}

// Vraca duzinu stringa
unsigned int KString::size( void ) const{
    return cString.size();
}

// Vraca podstring, od pozicije nPozicija, duzine nDuzina
KString KString::substr( unsigned int nPozicija, unsigned int nDuzina ) const{
    return cString.substr( nPozicija, nDuzina );
}

// Vraca indeks prvog elementa stringa koji nije razmak ili tabulator, racunajuci od date pozicije.
unsigned int KString::PreskociRazmake( unsigned int nPozicija ){
    return cString.find_first_not_of( RAZMACI, nPozicija );
}

// Vraca indeks prvog elementa stringa koji je razmak ili tabulator, racunajuci od date pozicije.
unsigned int KString::PreskociDoPrvogRazmaka( unsigned int nPozicija ){
    return cString.find_first_of( RAZMACI, nPozicija );
}

// Izdvaja 'rec'( deo stringa koji ne sadrzi ramake ) pocev od date pozicije.
// Vraca prvu poziciju iza nadjene reci.
unsigned int KString::IzdvojiRec( unsigned int nPozicija, string& cRec ){
    // Pozicioniraj se na pocetak reci
    unsigned int nPocetakReci = PreskociRazmake( nPozicija );
    // Pronadji prvi razmak iza reci
    unsigned int nIzaReci = PreskociDoPrvogRazmaka( nPocetakReci );
    // Izdvoji rec
    cRec = cString.substr( nPocetakReci, nIzaReci-nPocetakReci );

    return nIzaReci;
}

// Dopunjava string datim znakom sleva, do zadate duzine;
// Ukoliko je string vece duzine od nDuzina, vrsi se odsecanje na zadatu duzinu.
KString KString::lpad( unsigned char cZnak, unsigned int nDuzina ){
    unsigned int nPocetnaDuzina = KString::size();
    if ( nDuzina > nPocetnaDuzina ){
        string cPomStr;
        cPomStr.assign( nDuzina-nPocetnaDuzina, cZnak );
        cString = cPomStr + cString;
    }
    else if ( nDuzina < nPocetnaDuzina ) {
        cString = cString.substr( nPocetnaDuzina-nDuzina );
    }

    return (*this);
}

// Dopunjava string datim znakom zdesna, do zadate duzine;
// Ukoliko je string vece duzine od nDuzina, vrsi se odsecanje na zadatu duzinu.
KString KString::rpad( unsigned char cZnak, unsigned int nDuzina ){
    unsigned int nPocetnaDuzina = KString::size();
    if ( nDuzina > nPocetnaDuzina ){
        string cPomStr;
        cPomStr.assign( nDuzina-nPocetnaDuzina, cZnak );
        cString += cPomStr;
    }
    else if ( nDuzina < nPocetnaDuzina ) {
        cString = cString.substr( nPocetnaDuzina-nDuzina );
    }

    return (*this);
}

// Prevodi string u velika slova
KString KString::ToUpper( bool bKonvertUSpecZnak ){
    string cPomStr;
    unsigned int nDuzina = KString::size();
    unsigned char nPomChr;

    for ( unsigned int i=0; i<nDuzina; i++ ){
        nPomChr = toupper( KString::cString[i] );
        if ( bKonvertUSpecZnak ) 
            cPomStr += KKonfig::Instance()->DajSpecijalniKod( nPomChr );
        else
            cPomStr += nPomChr;
    }
    KString::cString = cPomStr;

    return (*this);
}

// Proverava da li je string decimalni broj
bool KString::IsDigit( void ){
    bool izlaz = true;

    unsigned int nDuzina = KString::size();
    int nPomChr;

    for ( unsigned int i=0; i<nDuzina; i++ ){
        nPomChr = KString::cString[i];
        if ( !isdigit( nPomChr ) ){
            izlaz = false;
            break;
        }
    }

    return izlaz;
}
//*********************************** KString << END >> ***************************************

//********************************* KKorisno << BEGIN >> **************************************
// Procedura za pristup jedinom objektu klase
KKorisno* KKorisno::Instance( void ){
    static KKorisno instance;
    return &instance;
}

// Za dati bajt, funkcija vraca string od 2 ASCII znaka ( "00" - "FF" ); Koristi se kod ispisa u BCD formatu.
char* KKorisno::BajtUBCD_ASCII( unsigned char bajt, char* str ){
    itoa( bajt, str, 16 );
    // Ako je broj jednocifren, dodaj jednu vodecu nulu
    if ( str[1] == 0 ) {
        str[2] = 0;
        str[1] = str[0];
        str[0] = '0';
    }
    return str;
}

// Za dati ASCII znak koji predstavlja HEX cifru ( '0'-'F' ), funkcija vraca celobrojnu vrednost ( 0-16 ).
unsigned char KKorisno::ASCIIHEXuBajt( char znak ) {
    if      ( znak>='0' && znak<='9' ) return znak-'0';
    else if ( znak>='A' && znak<='F' ) return znak-'A'+10;
    else if ( znak>='a' && znak<='f' ) return znak-'a'+10;
    else return 0;
}

// Za dati string od 1 ili 2 ASCII znaka ( "00" - "FF" ) vraca celobrojnu vrednost ( 0 -255 ).
unsigned char KKorisno::BCDuBajt( char* str ) {
    if ( str[1] == 0 ) return ASCIIHEXuBajt( str[0] );
    else if ( str[2] == 0 ) return ( 16 * ASCIIHEXuBajt( str[0] ) + ASCIIHEXuBajt( str[ 1 ] ) );
    else return 0;
}

// Za dati string od 1 ili 2 ASCII znaka ( "00" - "FF" ) vraca celobrojnu vrednost ( 0 -255 ).
unsigned char KKorisno::BCDuBajt( string str ) {
    char pomStr[3];
    for ( unsigned int i = 0; i < str.size() ;i++ ) pomStr[i] = str[i];
    pomStr[ str.size() ] = 0;
    return BCDuBajt( pomStr );
}

// Vraca 'formatiranu' verziju datog stringa ( prevodi bajtove u oblik pogodan za ispis ).
string KKorisno::FormatString( string cString, UIFormat format, bool bSaRazmacima ){
    string cFormatiranString;

    int i;
    switch( format ){
    case FS_BCD_ASCII:   // svaki bajt prevede u 2 znaka ( "00" - "FF" ) + razmak izmedju bajtova
        char pomStr[10];
        for ( i=0; i < cString.size(); i++ ) {
            KKorisno::Instance()->BajtUBCD_ASCII( cString[i], pomStr );
            if ( cFormatiranString.size() > 0 ){
                if ( bSaRazmacima )
                    cFormatiranString += " ";   // razmak izmedju bajtova
            }
            cFormatiranString += pomStr;
        }
        break;
    case FS_BAJT:        // ne radi nikakvu konverziju ( vraca string takav kakav je )
        cFormatiranString = cString;
        break;
    }

    return cFormatiranString;
}

// Vraca 'deformatiranu' verziju datog stringa ( oblik pogodan za ispis prevodi u bajtove ).
string KKorisno::DeformatString( KString cUlazniStr, UIFormat format ){
    string cDeformatiranString;

    cDeformatiranString.erase();
    unsigned int nDuzinaUlStr = cUlazniStr.size();
    string cBCDcifra = "";
    unsigned int i;
    // Odradi konverziju stringa u niz bajtova, na osnovu datog formata
    switch ( format ) {
    case FS_BCD_ASCII:
        // Konvertuj svaku grupu ASCII znakova koja predstavlja jednu BCD cifru u jedan bajt
        // ( svaki podstring "00" - "FF" konvertuje u 1 bajt; podstring izdvaja u 'znak' )
        for ( i=0; i<nDuzinaUlStr; ){
            cBCDcifra.erase();
            // Prihvata i 'jednocifrene' znakove ( ali iza njih mora razmak )
            while ( cUlazniStr[i] != ' ' && cBCDcifra.size() < 2 ) {
                cBCDcifra += cUlazniStr.cString[i];
                i++;
            }
            // Preskoci razmake izmedju dve grupe BCD cifara
            i = cUlazniStr.PreskociRazmake( i );
            cDeformatiranString += KKorisno::Instance()->BCDuBajt( cBCDcifra );
        }
        break;
    case FS_BAJT:
        // deformatirani string se dobija kao kopija ulaznog stringa
        cDeformatiranString = cUlazniStr.cString;
        break;
    }

    return cDeformatiranString;
}

// Konvertuje dati string u integer.
// Podrazumeva da je string sastavljen od niblova u datoj osnovi
// ( npr. za osnovu 16, niblovi su 0-F ).
// Ako je bIzuzetak = true, proverava da li niblovi odgovaraju datoj osnovi i
// baca izuzetak ako ne odgovaraju.
unsigned int KKorisno::KonvertUInt( string cStr, unsigned int nOsnova, bool bIzuzetak ){
    unsigned int nMnozilac = 1;
    unsigned int nInteger = 0;
    unsigned char nPomChr;

    for ( unsigned int i=cStr.size(); i > 0; i-- ) {
        // Nizi nibl
        nPomChr = (unsigned char)cStr[i-1] & 0x0F;
        if ( bIzuzetak && nPomChr>=nOsnova ) throw KIzuzetak( CIFRA_VAN_OSNOVE );
        nInteger += ( nPomChr * nMnozilac );
        nMnozilac *= nOsnova;
        // Visi nibl
        nPomChr = ((unsigned char)cStr[i-1]>>4) & 0x0F;
        if ( bIzuzetak && nPomChr>=nOsnova ) throw KIzuzetak( CIFRA_VAN_OSNOVE );
        nInteger += ( nPomChr * nMnozilac );        
        nMnozilac *= nOsnova;    
    }
    return nInteger;
}

// Konvertuje dati BCD string u integer.
// Podrazumeva da je string sastavljen od niblova 0-9 ( osnova 10 ).
// Ako je bIzuzetak = true, proverava da li su niblovi dekadne cifre i baca izuzetak ako nisu.
unsigned int KKorisno::KonvertBCDUInt( string cStr, bool bIzuzetak ){
    return KonvertUInt( cStr, 10, bIzuzetak );
}

// Konvertuje ceo broj( integer ) u string sastavljen od niblova u odgovarajucoj osnovi.
// Na primer, za nOsnova = 16, niblovi su 0-F. 
// Dopunjava vodecim nulama do date duzine.
KString KKorisno::KonvertIntUNiblString( unsigned int nInt, unsigned int nDuzina, 
                                         unsigned int nOsnova ){
    KString cOutStr;
    string cPomStr;
    unsigned int nBroj = nInt;
    unsigned int nCifra;
    unsigned char cNibl;

    while ( nBroj > 0 ) {
        // nizi nibl
        nCifra = nBroj % nOsnova;
        cNibl = nCifra & 0x0F;
        nBroj /= nOsnova;
        // visi nibl
        nCifra = nBroj % nOsnova;
        cNibl = ( ( nCifra << 4 ) & 0xF0   ) | cNibl;
        // smesti izracunati bajt ( 2 BCD cifre ) na pocetak izlaznog stringa
        cPomStr = string( 1, cNibl );
        cOutStr.cString = cPomStr + cOutStr.cString;
        nBroj /= nOsnova;
    }
    if ( cOutStr.size() == 0 ) cOutStr.cString.append( 1, '\x00' );

    // vrsi dopunjavanje( ili odsecanje ) do zadate duzine
    return cOutStr.lpad( 0, nDuzina ); 
}

// Konvertuje ceo broj( integer ) u BCD string ( string sastavljen od niblova 0-9 ).
// Dopunjava vodecim nulama do date duzine.
KString KKorisno::KonvertIntUBCD( unsigned int nInt, unsigned int nDuzina ){
    return KonvertIntUNiblString( nInt, nDuzina, 10 );
}

// Konvertuje integer u string date duzine ( vrsi odsecanje ako je integer duzi ).
// Ako je bDopuni=true, dopunjava vodecim nulama.
string KKorisno::KonvertIntUString( unsigned int nInt, unsigned int nDuzinaStringa,
                                    bool bDopuni ){
    string cOutStr;
    char cPomStr[1000];

    itoa( nInt, cPomStr, 10 );
    cOutStr.assign( cPomStr );
    unsigned int nDuzinaBroja = cOutStr.size();
    if      ( nDuzinaBroja > nDuzinaStringa )    
        // odsecanje
        cOutStr = cOutStr.substr( nDuzinaBroja - nDuzinaStringa );
    else {
        if ( bDopuni && nDuzinaBroja < nDuzinaStringa ) {  
            // dopunjavanje vodecim nulama
            string cPad( nDuzinaStringa-nDuzinaBroja, '0' );
            cOutStr = cPad + cOutStr;
        }
    }

    return cOutStr;
}

// Konvertuje string sa BCD ciframa u realan broj.
// Ako je bIzuzetak = true, proverava da li su niblovi dekadne cifre ( 0-9 ) 
// i baca izuzetak ako nisu.
double KKorisno::BCDStringUDouble( string cStr, unsigned char nBrojDecimala, bool bIzuzetak ){
    unsigned int nCeli, nDecimale;
    unsigned int nBrojCelih = ( cStr.size() * 2 ) - nBrojDecimala;

    unsigned int nDelilac = 1;
    for ( int i = 0; i < nBrojDecimala; i++ ) nDelilac *= 10;

    unsigned int nDuzinaPom;
    if ( nBrojCelih%2 == 1 ) {  // broj cifara u celobrojnom delu neparan
        nDuzinaPom = ( nBrojCelih + 1 ) / 2;

        // izdvoji celobrojni deo
        nCeli     = KonvertBCDUInt( cStr.substr( 0, nDuzinaPom ), bIzuzetak ) / 10;

        // izdvoji decimale
        nDecimale = KonvertBCDUInt( cStr.substr( nDuzinaPom-1 ), bIzuzetak );

        // izbaci cifru najvece tezine iz decimala
        nDecimale = nDecimale - ( ( nDecimale / nDelilac ) * nDelilac );

    }
    else {                      // broj cifara u celobrojnom delu paran
        nDuzinaPom = nBrojCelih / 2;

        // izdvoji celobrojni deo
        nCeli     = KonvertBCDUInt( cStr.substr( 0, nDuzinaPom ), bIzuzetak );

        // izdvoji decimale
        nDecimale = KonvertBCDUInt( cStr.substr( nDuzinaPom ), bIzuzetak );

    }

    // spoji celobrojni i razlomljeni deo
    return ( (double)(nCeli) + ( (double)( nDecimale ) / (double)( nDelilac ) ) );
}

// Konvertuje bool u string ( 'true' i 'false' )
string KKorisno::BoolToString( bool bBool ){
    if ( bBool ) return "true";
    else return "false";
}

// Grupu BCD cifara konvertuje u niz brojeva tipa 'double'.
// Zadaje se broj brojeva, duzina ( u bajtovima ) jednog broja i 
// broj BCD cifara iza decimalne tacke.
// U slucaju da konverzija nekog broja ne uspe, vraca false.
// Preko promenljive nBrojIzdvojenihPodataka vraca broj double
// brojeva izdvojenih iz ulaznog stringa ( moze da bude
// manje od nTrazeniBrojPodataka ).
bool KKorisno::StringUNizDouble( const string&    cKorisniPodaci, 
                                 unsigned int     nTrazeniBrojPodataka, 
                                 int              nDuzinaPodatka, 
                                 int              nBrojBCDDecimala,
                                 double*          nDoubleNiz,
                                 unsigned int&    nBrojIzdvojenihPodataka ){

    int nPozicija = 0;
    unsigned int nDuzinaPod = cKorisniPodaci.length();
    int i;

    for ( i=0; i<nTrazeniBrojPodataka; i++ ) {

        // proveri da li ima jos podataka u ulaznom stringu
        if ( nDuzinaPod < nPozicija + nDuzinaPodatka ) break;

        // izdvoji podatak iz ulaznog stringa ako je moguce
        try {
            nDoubleNiz[ i ] = BCDStringUDouble( cKorisniPodaci.substr( nPozicija, nDuzinaPodatka ), 
                                                nBrojBCDDecimala,
                                                true );
        }
        catch ( KIzuzetak iz ) {
            return false;
        }

        nPozicija += nDuzinaPodatka;
    }

    nBrojIzdvojenihPodataka = i;
    return true;
}

// Konvertuje string u bool : ako je string 'true' konvertuje ga u true, ostalo u false
bool KKorisno::StringUBool( string cStr ){
    KString cStrUpp( cStr );
    cStrUpp.ToUpper();
    KString cStrTRUE( "true" );
    cStrTRUE.ToUpper();

    if ( cStrUpp.cString == cStrTRUE.cString ) return true;
    else return false;
}
//********************************** KKorisno << END >> ***************************************