---

TranslatorsUtils.cpp

                              /* TranslatorsUtils.cpp */

/*
 *  Implementation of TranslatorsUtils.h
 */
#include "TranslatorsUtils.h"

using namespace LcgInfo;
using namespace std;

/********************  OTHER METHODS (General Usage)  **********************/

void LcgInfo::tokenizeStr(string const & pStr, vector<string>& pTokens, string const & pDelimiters)
{
    pTokens.clear(); // Just in case
     
    // Skip delimiters at beginning.
    string::size_type lastPos = pStr.find_first_not_of(pDelimiters, 0);
    // Find first "non-delimiter".
    string::size_type pos     = pStr.find_first_of(pDelimiters, lastPos);

    while (string::npos != pos || string::npos != lastPos)
    {
        // Found a token, add it to the vector.
        pTokens.push_back(pStr.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        lastPos = pStr.find_first_not_of(pDelimiters, pos);
        // Find next "non-delimiter"
        pos = pStr.find_first_of(pDelimiters, lastPos);
    }
}

void LcgInfo::tokenizeStrWithIndices (string const & pStr, vector<string>& pTokens,
                             vector<short int>& pIndices, string const & pDelimiters)
{
   pTokens.clear();
   pIndices.clear();
   
    // Skip delimiters at beginning.
    string::size_type lastPos = pStr.find_first_not_of(pDelimiters, 0);
    // Find first "non-delimiter".
    string::size_type pos     = pStr.find_first_of(pDelimiters, lastPos);

    while (string::npos != pos || string::npos != lastPos)
    {
        pTokens.push_back(pStr.substr(lastPos, pos - lastPos)); // Add found token to vector 
        pIndices.push_back(lastPos);  // Also add its index to the indices vector
        lastPos = pStr.find_first_not_of(pDelimiters, pos); // Skip delimiters. Note the "not_of"
        pos = pStr.find_first_of(pDelimiters, lastPos);  // Find next "non-delimiter"
    }
}

void LcgInfo::delLeadingChars(string& pStr, string const & pChars){
   string::size_type pos=pStr.find_first_not_of(pChars,0);
   pStr.erase(0,pos);
}

void LcgInfo::delEndingChars(string& pStr, string const & pChars){
   string::size_type end=pStr.length()-1;
   string::size_type pos=pStr.find_last_not_of(pChars,end);
   pStr.erase(pos+1,end-pos);
}

void LcgInfo::delSurroundingChars(string& pStr, string const & pChars){
   LcgInfo::delLeadingChars(pStr, pChars);
   LcgInfo::delEndingChars(pStr, pChars);
}

bool LcgInfo::nocaseCompare(string const & pStr1, string const & pStr2){
   string::const_iterator it1=pStr1.begin();
   string::const_iterator it2=pStr2.begin();

   //stop when either string's end has been reached
   while ( (it1!=pStr1.end()) && (it2!=pStr2.end()) ){ 
      if(toupper(*it1) != toupper(*it2))  //letters differ?
         return false;  //then strings are different
       ++it1;  //proceed to the next character in each string
       ++it2;
   }
   string::size_type size1=pStr1.size(), size2=pStr2.size();// cache lengths
   if (size1==size2)  return true;  //if sizes are equal
   return false; //false otherwise
}

bool LcgInfo::isNumber(string const & pStr){
   float aux;
   istringstream is(pStr, istringstream::in);
   is >> aux;
   if(is.fail())   return false;
   else    return true;
}

bool LcgInfo::isLiteral(string const & pStr){
   string aux;
   aux=pStr;
   delSurroundingChars(aux); //eliminate blanks
   //first and last chars are "'"
   return ((aux.at(0)=='\'') && (aux.at(aux.size()-1)=='\''));
}

string LcgInfo::int2str(int const & pValue){
   ostringstream os(ostringstream::out);
   os << (pValue);
   return os.str();
}

int LcgInfo::str2int(string const & pStr){
   int aux;
   istringstream is(pStr, istringstream::in);
   is >> aux;
   return aux;
}

void LcgInfo::escapeLiterals(std::string & pStr, std::string const & pChars,
                    char const & pEscape, char const & pDelimiter){
   string::size_type posIni, posFin, posCh, whichCh;
   string aux=pStr;
   string toInsert;
   posIni = aux.find(pDelimiter, 0);   
   while (posIni != string::npos){
      posFin = aux.find(pDelimiter, posIni+1);
      if(posFin == string::npos){
         string msg="Parsing error when escaping literals. Unmatched \"\'\".";
         msg+="\nString: " + pStr;
         throw QueryTranslationException(msg,__FILE__,__LINE__);
      }
      posCh=aux.find_first_of(pChars, posIni+1);
      while (posCh < posFin){
         whichCh=pChars.find(aux.at(posCh));
         aux.erase(posCh,1);
         toInsert=string(1,pEscape)+"n"+LcgInfo::int2str(whichCh)+string(1,pEscape);
         aux.insert(posCh, toInsert);
         posFin+=toInsert.length()-1;
         posCh=aux.find_first_of(pChars, posCh+toInsert.length());
      }
   posIni = aux.find(pDelimiter, posFin+1); 
   }
   pStr=aux;
}

void LcgInfo::unescapeLiterals(std::string & pStr, std::string const & pChars,
                      char const & pEscape, char const & pDelimiter){
   string::size_type posIni, posFin, posCh, posCh2, whichCh;
   string aux=pStr;
   posIni = aux.find(pDelimiter, 0);   
   while (posIni != string::npos){
      posFin = aux.find(pDelimiter, posIni+1);
      if(posFin == string::npos){
         string msg="Parsing error when unescaping literals. Unmatched \"\'\".";
         msg+="\nString: " + pStr;
         throw QueryTranslationException(msg,__FILE__,__LINE__);
      }
      posCh=aux.find(pEscape, posIni+1);
      while (posCh < posFin){
         if(aux.at(posCh+1)=='n'){
            posCh2=aux.find(pEscape, posCh+1);
            whichCh=LcgInfo::str2int(aux.substr(posCh+2, posCh2-posCh-2));   
            if(whichCh<pChars.size()){
               aux.erase(posCh,posCh2-posCh+1);
               aux.insert(posCh, 1, pChars.at(whichCh));
               posFin-=posCh2-posCh;
            }
         }
         posCh=aux.find(pEscape, posCh+1);
      }
   posIni = aux.find(pDelimiter, posFin+1); 
   }
   pStr=aux;
}

string LcgInfo::extractTable(string const & pStr){
   string::size_type pos;
   pos=pStr.find_last_of('.',pStr.size()-1);
   return pStr.substr(0,pos);
}

string LcgInfo::extractRow(string const & pStr){
   string::size_type pos;
   pos=pStr.find_last_of('.',pStr.size()-1)+1;
   if(pos==string::npos) pos=0;
   return pStr.substr(pos);
}

---