EgtGeneral 1.3a1 : primo salvataggio.
This commit is contained in:
Dario Sassi
+273
@@ -0,0 +1,273 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalS
|
||||
//----------------------------------------------------------------------------
|
||||
// File : StringUtils.cpp Data : 20.01.13 Versione : 1.1a1
|
||||
// Contenuto : Implementazione delle funzioni di utilità per le stringhe.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 20.01.13 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
//--------------------------- Include ----------------------------------------
|
||||
#include "stdafx.h"
|
||||
#include "/EgtDEv/Include/EgnStringUtils.h"
|
||||
|
||||
using namespace std ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
const string
|
||||
ToString( int nVal, int nPrec)
|
||||
{
|
||||
int nErr ;
|
||||
int nLen ;
|
||||
char szBuff[24] ;
|
||||
|
||||
|
||||
// eseguo conversione
|
||||
nErr = _itoa_s( nVal, szBuff, 10) ;
|
||||
|
||||
// se errore, ritorno stringa opportuna
|
||||
if ( nErr != 0) {
|
||||
_ASSERT( 0) ;
|
||||
return "#Error" ;
|
||||
}
|
||||
|
||||
// verifico lunghezza minima
|
||||
if ( ( nLen = (int) strlen( szBuff)) >= nPrec)
|
||||
return szBuff ;
|
||||
|
||||
// porto la stringa alla minima lunghezza
|
||||
string sBuff( szBuff) ;
|
||||
sBuff.insert( 0, ( nPrec - nLen), '0') ;
|
||||
return sBuff ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
const string
|
||||
ToString( double dVal, int nPrec)
|
||||
{
|
||||
const double BIG_NUMBER = 1e10 ;
|
||||
const int BIG_DIGITNBR = 10 ;
|
||||
const int MAX_PREC = 12 ;
|
||||
char szBuff[24] ;
|
||||
char szDest[32] ;
|
||||
char* pBuff ;
|
||||
char* pDest ;
|
||||
int nErr ;
|
||||
int nDecimal ;
|
||||
int nSign ;
|
||||
int nExp ;
|
||||
int nTmp ;
|
||||
|
||||
|
||||
// verifico la precisione
|
||||
nPrec = min( nPrec, MAX_PREC) ;
|
||||
|
||||
// converto la mantissa
|
||||
if ( fabs( dVal) < BIG_NUMBER)
|
||||
nErr = _fcvt_s( szBuff, dVal, nPrec, &nDecimal, &nSign) ;
|
||||
else
|
||||
nErr = _ecvt_s( szBuff, dVal, BIG_DIGITNBR + nPrec, &nDecimal, &nSign) ;
|
||||
|
||||
// se errore, ritorno stringa opportuna
|
||||
if ( nErr != 0) {
|
||||
_ASSERT( 0) ;
|
||||
return "#Error" ;
|
||||
}
|
||||
|
||||
// se buffer vuoto, risultato è numero 0
|
||||
if ( szBuff[0] == '\0')
|
||||
return "0" ;
|
||||
|
||||
// verifica per forma esponenziale
|
||||
if ( nDecimal > BIG_DIGITNBR) {
|
||||
nExp = nDecimal - 1 ;
|
||||
nDecimal = 1 ;
|
||||
}
|
||||
else
|
||||
nExp = 0 ;
|
||||
|
||||
// puntatori a inizio stringhe
|
||||
pBuff = szBuff ;
|
||||
pDest = szDest ;
|
||||
// eventuale inserimento segno '-'
|
||||
if ( nSign != 0) {
|
||||
*pDest = '-' ;
|
||||
pDest ++ ;
|
||||
} ;
|
||||
// gestione decimali dopo 0
|
||||
if ( nDecimal <= 0) {
|
||||
*pDest = '0' ;
|
||||
pDest ++ ;
|
||||
*pDest = '.' ;
|
||||
pDest ++ ;
|
||||
for ( ; nDecimal < 0 ; nDecimal ++) {
|
||||
*pDest = '0' ;
|
||||
pDest ++ ;
|
||||
}
|
||||
nDecimal -- ;
|
||||
}
|
||||
// gestione cifre e .
|
||||
while ( *pBuff != '\0') {
|
||||
if ( *pBuff == '#') // NAN, INFINITY, INDEFINITE
|
||||
_ASSERT( 0) ;
|
||||
if ( nDecimal == 0) {
|
||||
*pDest = '.' ;
|
||||
pDest ++ ;
|
||||
}
|
||||
nDecimal -- ;
|
||||
*pDest = *pBuff ;
|
||||
pDest ++ ;
|
||||
pBuff ++ ;
|
||||
}
|
||||
*pDest = '\0' ;
|
||||
// se inserito un punto decimale tolgo i trailing zero
|
||||
if ( nDecimal < 0) {
|
||||
pDest -- ;
|
||||
while ( *pDest == '0') {
|
||||
*pDest = '\0' ;
|
||||
pDest -- ;
|
||||
}
|
||||
if ( *pDest == '.')
|
||||
*pDest = '\0' ;
|
||||
else
|
||||
pDest ++ ;
|
||||
}
|
||||
// aggiungo eventuale esponente (sempre compreso tra 9 e 308)
|
||||
if ( nExp > 0) {
|
||||
*pDest = 'e' ;
|
||||
pDest ++ ;
|
||||
nTmp = nExp ;
|
||||
if ( nTmp >= 100) {
|
||||
*pDest = '0' + ( nTmp / 100) ;
|
||||
pDest ++ ;
|
||||
nTmp = nTmp % 100 ;
|
||||
}
|
||||
if ( nTmp >= 10 || nExp >= 100) {
|
||||
*pDest = '0' + ( nTmp / 10) ;
|
||||
pDest ++ ;
|
||||
nTmp = nTmp % 10 ;
|
||||
}
|
||||
*pDest = '0' + nTmp ;
|
||||
pDest ++ ;
|
||||
*pDest = '\0' ;
|
||||
}
|
||||
|
||||
if ( szDest[0] == '-' && szDest[1] == '0' && szDest[2] == '\0')
|
||||
return "0" ;
|
||||
else
|
||||
return szDest ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void
|
||||
Split( const string& sString, const string& sSeparator, bool bFirstVsLast,
|
||||
string& sFirst, string& sLast)
|
||||
{
|
||||
string::size_type iPos ;
|
||||
|
||||
|
||||
// cerco il separatore
|
||||
iPos = ( bFirstVsLast ? sString.find( sSeparator) : sString.rfind( sSeparator)) ;
|
||||
// se trovato
|
||||
if ( iPos != string::npos) {
|
||||
if ( iPos > 0)
|
||||
sFirst = sString.substr( 0, iPos) ;
|
||||
else
|
||||
sFirst.clear() ;
|
||||
if ( ( iPos + 1) < sString.length())
|
||||
sLast = sString.substr( iPos + 1) ;
|
||||
else
|
||||
sLast.clear() ;
|
||||
}
|
||||
// altrimenti
|
||||
else {
|
||||
sFirst = sString ;
|
||||
sLast.clear() ;
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
Tokenize( const string& sString, const string& sSeparators, STRVECTOR& vsTokens)
|
||||
{
|
||||
string::size_type iPosStart ;
|
||||
string::size_type iPosEnd ;
|
||||
|
||||
|
||||
// pulisco il risultato
|
||||
vsTokens.clear() ;
|
||||
// parto dall'inizio
|
||||
iPosStart = ( sString.empty() ? string::npos : 0) ;
|
||||
// mentre esiste un nuovo inizio di token
|
||||
while ( iPosStart != string::npos) {
|
||||
// cerco il primo separatore
|
||||
iPosEnd = sString.find_first_of( sSeparators, iPosStart) ;
|
||||
// aggiungo il token al vettore
|
||||
vsTokens.push_back( sString.substr( iPosStart, iPosEnd - iPosStart)) ;
|
||||
// cerco l'inizio di un nuovo token
|
||||
iPosStart = sString.find_first_not_of( sSeparators, iPosEnd) ;
|
||||
}
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
Tokenize( const string& sString, const string& sSeparators,
|
||||
const string& sAtomStarts, const string& sAtomEnds, STRVECTOR& vsTokens)
|
||||
{
|
||||
string::size_type iPosStart ;
|
||||
string::size_type iPosEnd ;
|
||||
string::size_type iAtomStart ;
|
||||
string::size_type iAtomEnd ;
|
||||
|
||||
|
||||
// i separatori devono essere diversi da inizio e fine di atomi
|
||||
if ( sAtomStarts.find_first_of( sSeparators) != string::npos ||
|
||||
sAtomEnds.find_first_of( sSeparators) != string::npos)
|
||||
return false ;
|
||||
|
||||
// parto dall'inizio
|
||||
iPosStart = ( sString.empty() ? string::npos : 0) ;
|
||||
// mentre esiste un nuovo inizio di token
|
||||
while ( iPosStart != string::npos) {
|
||||
// eventuale inizio e fine di parte atomica
|
||||
iAtomStart = sString.find_first_of( sAtomStarts, iPosStart) ;
|
||||
iAtomEnd = sString.find_first_of( sAtomEnds, iAtomStart) ;
|
||||
// cerco il primo separatore
|
||||
iPosEnd = sString.find_first_of( sSeparators, iPosStart) ;
|
||||
// se separatore è nella parte atomica, lo ricerco dopo la sua fine
|
||||
if ( iAtomStart != string::npos && iPosEnd != string::npos &&
|
||||
iPosEnd > iAtomStart && iPosEnd < iAtomEnd)
|
||||
iPosEnd = sString.find_first_of( sSeparators, iAtomEnd) ;
|
||||
// aggiungo il token al vettore
|
||||
vsTokens.push_back( sString.substr( iPosStart, iPosEnd - iPosStart)) ;
|
||||
// cerco l'inizio di un nuovo token
|
||||
iPosStart = sString.find_first_not_of( sSeparators, iPosEnd) ;
|
||||
}
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
int
|
||||
ReplaceString( std::string& sString, const std::string& sOld, const std::string& sNew)
|
||||
{
|
||||
int nSubs ;
|
||||
size_t pos ;
|
||||
|
||||
|
||||
nSubs = 0 ;
|
||||
pos = 0 ;
|
||||
while ( ( pos = sString.find( sOld, pos)) != std::string::npos) {
|
||||
sString.replace( pos, sOld.length(), sNew) ;
|
||||
pos += sNew.length() ;
|
||||
nSubs ++ ;
|
||||
}
|
||||
|
||||
return nSubs ;
|
||||
}
|
||||
Reference in New Issue
Block a user