clsconfigfile.cpp

set of c++ classes for read/write access to ascii files.

    return false;
}

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

clsConfigVar*     clsConfigFile::GetVar      (const char* sSeqName, const char* cVarname)
{
    std::list<clsConfigSeq>::iterator oIter;
    for( oIter = m_lsConfigSeq.begin() ; oIter != m_lsConfigSeq.end() ; ++oIter )
    {
        if ( (*oIter).m_sSeqName ==  sSeqName)
        {
            return (*oIter).GetVar (cVarname);
        }	          	
    }
    return false;
}

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

int 	clsConfigFile::WriteSeq			(int iWriteSeqName, std::string& sSeqName)
{

    std::list<clsConfigSeq>::iterator oIter;

    for( oIter = m_lsConfigSeq.begin() ; oIter != m_lsConfigSeq.end() ; ++oIter )
    {
        if ( (*oIter).m_sSeqName ==  sSeqName)
        {
            return (*oIter).WriteSeq (iWriteSeqName, m_iConfFile);
        }	
    }
    return false;
}

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

int 	clsConfigFile::SeqExists			(const char* cSeqName)
{
    std::list<clsConfigSeq>::iterator oIter;
    for( oIter = m_lsConfigSeq.begin() ; oIter != m_lsConfigSeq.end() ; ++oIter )
    {
        if ( (*oIter).m_sSeqName ==  cSeqName)
        {
            return true;
        }	
    }
    return false;
}

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

int             clsConfigFile::VarExists       (const char* cSeqName,const char* cVarName)
{
    std::list<clsConfigSeq>::iterator oIter;
    for( oIter = m_lsConfigSeq.begin() ; oIter != m_lsConfigSeq.end() ; ++oIter )
    {
        clsConfigSeq& rSeq = *oIter;
        if ( rSeq.m_sSeqName ==  cSeqName)
        {
            if ( rSeq.GetVar ( cVarName ) )
                return true;
            else
                return false;
        }	
    }
    return false;
}

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

int 	clsConfigFile::DelSeq			(const char* cSeqName)
{
    std::list<clsConfigSeq>::iterator oIter;
    for( oIter = m_lsConfigSeq.begin() ; oIter != m_lsConfigSeq.end() ; ++oIter )
    {
        if ( (*oIter).m_sSeqName ==  cSeqName)
        {
            m_lsConfigSeq.erase(oIter);
            return true;
        }	
    }
    return false;
}	
	
//#############################################################################
   			
int 	clsConfigFile::DelVar			(const char* cSeqName,const char* cVarName)
{
    std::list<clsConfigSeq>::iterator oIter;
    for( oIter = m_lsConfigSeq.begin() ; oIter != m_lsConfigSeq.end() ; ++oIter )
    {
        clsConfigSeq& rSeq = *oIter;
        if ( rSeq.m_sSeqName ==  cSeqName)
        {
           return (*oIter).DelVar (cVarName) ;
        }	
    }
    return false;
}

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

int 	clsConfigFile::DelVarValue		(const char* cSeqName,const char* cVarName, long lIndex )
{
    std::list<clsConfigSeq>::iterator oIter;
    for( oIter = m_lsConfigSeq.begin() ; oIter != m_lsConfigSeq.end() ; ++oIter )
    {
        if ( (*oIter).m_sSeqName ==  cSeqName)
        {
            return (*oIter).DelVarValue (cVarName,lIndex) ;
        }	
    }
    return false;
}

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

int 	clsConfigFile::Clear			()
{
    m_lsConfigSeq.clear();
    return true;
}

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

const char*    clsConfigFile::GetVarName      (const char* cSeqName, long lIndex )
{
    std::list<clsConfigSeq>::iterator oIter;

    for( oIter = m_lsConfigSeq.begin() ; oIter != m_lsConfigSeq.end() ; ++oIter )
    {
        if ((*oIter).m_sSeqName ==  cSeqName )
        {
            return (*oIter).GetVarName(lIndex);
        }	
    }
    return 0;
}



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

clsConfigSeq::clsConfigSeq (const char* cNewName)
{
    m_sSeqName = cNewName ? cNewName : "";
}

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

clsConfigSeq::~clsConfigSeq ()
{

}

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

int clsConfigSeq::Count       ( )
{
    return m_lsConfigVar.size();
}

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

int 	clsConfigSeq::CountIndex		(const char* cVarname )
{
    std::list<clsConfigVar>::iterator oIter;
    for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
    {
        if ( (*oIter).m_sVarName ==  cVarname)
        {
            return (*oIter).Count();
        }	
    }
    return false;
}

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

int 	clsConfigSeq::CountIndex		(long lIndex )
{
    std::list<clsConfigVar>::iterator oIter;
    for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
    {
        if ( --lIndex < 0 )
        {
            return (*oIter).Count();
        }	
    }
    return 0;
}

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

const char* clsConfigSeq::GetVarName ( long lIndex )
{
    std::list<clsConfigVar>::iterator oIter;

    int i = 0;

    for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
    {
        if ( i == lIndex )
        {
            return (*oIter).m_sVarName.c_str ( );
        }
        ++i;
    }

    return false;
}

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

int clsConfigSeq::GetVarIndex ( const char* cVarname,std::string& sNewValue, long lIndex )
{
     std::list<clsConfigVar>::iterator oIter;

     for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
     {
         if ( (*oIter).m_sVarName ==  cVarname)
         {
             return (*oIter).GetIndex ( sNewValue, lIndex );
         }	
     }

    return false;
}

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

int clsConfigSeq::GetVarIndex ( long lVarIndex , std::string& sNewValue, long lIndex )
{
     std::list<clsConfigVar>::iterator oIter;
     long l = 0;

     for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
     {
         if ( l++ >= lVarIndex )
         {
             return (*oIter).GetIndex ( sNewValue, lIndex );
         }	
     }

    return false;
}

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

clsConfigVar*  clsConfigSeq::GetVar      (const char* cVarname)
{
    std::list<clsConfigVar>::iterator oIter;

    for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
    {
        if ( ! strcmp ( cVarname , (*oIter).m_sVarName.c_str() ) ) return & (*oIter);  	
    }
    return 0;
}

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

int		clsConfigSeq::AddVar			( const char* cNewVarName)
{
/*
    clsConfigVar *pTemp = 0;
    pTemp = new clsConfigVar(cNewVarName);
    if ( pTemp == 0 ) return false;
    m_lsConfigVar.push_back( *pTemp );
*/
    clsConfigVar oConfigVar ( cNewVarName );
    m_lsConfigVar.push_back ( oConfigVar );
    return true;
}

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

int     clsConfigSeq::SetVar          ( const char* cVarname, const long lNewValue, long lIndex )
{
    char cTmp[20];
    sprintf ( cTmp , "%ld" , lNewValue );
    std::string sNewValue = cTmp;
    return SetVar ( cVarname , sNewValue , lIndex );
}

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

int     clsConfigSeq::SetVar          ( const char* cVarname, const char* cNewValue, long lIndex )
{
    std::string sNewValue = cNewValue;
    return SetVar ( cVarname , sNewValue , lIndex );
}

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

int     clsConfigSeq::SetVar          ( const char* cVarname, const float fNewValue, long lIndex )
{
    char cTmp[20];
    sprintf ( cTmp , "%f" , fNewValue );
    std::string sNewValue = cTmp;
    return SetVar ( cVarname , sNewValue , lIndex );
}

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

int     clsConfigSeq::SetVar          ( const char* cVarname, const std::string& sNewValue, long lIndex )
{
     std::list<clsConfigVar>::iterator oIter;
     for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
     {
         if ( (*oIter).m_sVarName ==  cVarname)
         {
             return (*oIter).SetIndex ( sNewValue , lIndex );
         }
     }
     return false;
}

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

int 	clsConfigSeq::WriteSeq			(int iWriteSeqName, int iConfFile)
{
    std::string sVarString;
    std::string sOutString = "[";
    sOutString +=  m_sSeqName;
    sOutString += "]\n";

    if (iWriteSeqName)
    {
        std::list<clsConfigVar>::iterator oIter;
        for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
        {
            if ( ! (*oIter).m_iWritten )
            {
                write(iConfFile, sOutString.c_str(), sOutString.size());
                break;
            }	
        }
    }

    std::list<clsConfigVar>::iterator oIter;
    for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
    {
        if ( ! (*oIter).m_iWritten )
        {
            sVarString = (*oIter).GetVarString ( );
            sVarString += "\n";
            write( iConfFile, sVarString.c_str(), sVarString.size());
            (*oIter).m_iWritten = true;
        }	
    }
    return true;
}

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

int    clsConfigSeq::ClearWritten    ()
{
    m_iWritten = 0;

    std::list<clsConfigVar>::iterator oIter;
    for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
    {
         (*oIter).m_iWritten = 0;
    }
    return true;
}

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

int 	clsConfigSeq::DelVar			(const char* cVarName)
{
    std::list<clsConfigVar>::iterator oIter;
    for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
    {
        if ( (*oIter).m_sVarName ==  cVarName)
        {
            m_lsConfigVar.erase(oIter);
            return true;
        }	
    }
    return false;
}

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

int 	clsConfigSeq::DelVarValue		(const char* cVarName, long lIndex)
{
    std::list<clsConfigVar>::iterator oIter;
    for( oIter = m_lsConfigVar.begin() ; oIter != m_lsConfigVar.end() ; ++oIter )
    {
        if ( (*oIter).m_sVarName ==  cVarName)
        {
           return (*oIter).DelIndex (lIndex) ;
        }	
    }
    return false;
}

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

unsigned long   clsConfigFile::HexToNum        ( const char* cPtr )
{
    unsigned long lNewValue = 0;
    long lAdd;
    int iLast = 2;
    while ( 1 )
    {
        if ( ( cPtr[iLast] >= 'a' && cPtr[iLast] <= 'f' ) ||
             ( cPtr[iLast] >= 'A' && cPtr[iLast] <= 'F' ) ||
             ( cPtr[iLast] >= '0' && cPtr[iLast] <= '9' ) )
        {
            ++iLast;
            if ( iLast >= 9 ) break;
        }
        else
        {
            --iLast;
            break;
        }
    }
    for ( int j = 2 ; j <= iLast ; ++j )
    {
        lAdd = 0;
        if ( cPtr[j] >= '0' && cPtr[j] <= '9' )
        {
            lAdd = ( ( cPtr[j] - '0' ) << ( ( iLast - j ) * 4 ) );
        }
        else if ( cPtr[j] >= 'a' && cPtr[j] <= 'f' )
        {
            lAdd = ( ( 10 + ( cPtr[j] - 'a' ) ) << ( ( iLast - j ) * 4 ) );
        }
        else if ( cPtr[j] >= 'A' && cPtr[j] <= 'F' )
        {
            lAdd = ( ( 10 + ( cPtr[j] - 'A' ) ) << ( ( iLast - j ) * 4 ) );
        }
        lNewValue += lAdd;
    }
    return lNewValue;
}

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