root/trunk/StringFunctions.cpp

#include "stdafx.h"
#include "stringfunctions.h"

bool StartsWithBackward(const string& match, const string& backwardText ) {
  string local = match;

  //std::reverse(local.begin() , local.end() );

  if ( backwardText.length() >= local.length () )   
    {
      //      AfxMessageBox(backwardText.substr(backwardText.length() - local.length() ).c_str() );
      if ( backwardText.substr(backwardText.length() - local.length() ) == local ) {
    return true;
      }
    }
    
  return false;

}

bool NextCharIsBackward(char ch , const string& backwardText, int skipNo  ) { 

  int pos = backwardText.length() - 1;
  pos -= skipNo;
  for ( pos; pos >= 0;pos-- )
    {
      if( isspace(backwardText[pos] ) ) continue;
      else 
    {
      if ( backwardText[pos] == ch ) return true;
      else 
        {
          // CString c;
//        c.Format("%c",backwardText[pos] );
//        AfxMessageBox (c);
          return false;
        }
    }

    }
  
  

  return false; 

}
bool NextCharIs(char ch , const string& backwardText,int skipNo  ) { return false; }


bool MatchesFunctionDefinition (const string& text) {
  return false;
}

void AdvanceToWhiteSpaceOrChar(const string& text, int & pos, char c ) {


    for ( int i = 0;i < text.size();i ++ ) {
        if ( isspace(text[i] ) ) {
            pos = i;
            return;
        }   
        else if ( text[i] == c ) {
            pos = i;
            return;
        }
        else {
          continue; 
        }

    }
}

void AdvanceToWhiteSpaceOrCharBackward(const string& text, int & pos, char c ) {


    for ( int i = text.length() - 1;i > 0 ;i-- ) {
        if ( isspace(text[i] ) ) {
            pos = i;
            return;
        }   
        else if ( text[i] == c ) {
            pos = i;
            return;
        }
        else {
            continue;
        }

    }
}
void AdvanceToWhiteSpaceBackward(const string& text, int & pos ) {


    for ( int i = text.length() - 1;i > 0 ;i ++ ) {

        if ( isspace(text[i] ) ) {
            pos = i;
            return;
        }   
        else {
            continue;
        }

    }


}


Strtok::Strtok (string *_str, string delim,
                        bool returnTokens)
{
    currentPosition = 0;
    str = _str;
    maxPosition = str->length ();
    delimiters = delim;
    retTokens = returnTokens;
}


Strtok::Strtok (string *_str, string delim)
{
    currentPosition = 0;
    str = _str;
    maxPosition = str->length ();
    delimiters = delim;
    retTokens = false;
}


Strtok::Strtok (string *_str)
{
    currentPosition = 0;
    str = _str;
    maxPosition = str->length ();
    delimiters = " \t\r\n";
    retTokens = false;
}

Strtok::Strtok ()
{
    currentPosition = 0;
    maxPosition = 0;
    delimiters = " \t\r\n";
    retTokens = false;
}

Strtok::~Strtok ()
{
}

void Strtok::SkipDelimiters ()
{
    while (!retTokens && (currentPosition < maxPosition) &&
           (delimiters.find((*str)[currentPosition]) != delimiters.npos)) {
        currentPosition++;
    }
}

bool Strtok::HasMoreTokens ()
{
    SkipDelimiters ();
    return (currentPosition < maxPosition);
}

string Strtok::NextToken (void)
{
    int start = GetStart ();
    string ret;
    ret.assign (&(*str)[start], &(*str)[currentPosition]);
    return ret;
}


bool Strtok::NextToken(string &_str)
{
    int start = GetStart ();
    _str.assign (&(*str)[start], &(*str)[currentPosition]);
    return true;
}

int Strtok::GetStart (void)
{
    SkipDelimiters();

    //assert (currentPosition < maxPosition);

    int start = currentPosition;
    while ((currentPosition < maxPosition) && 
           (delimiters.find((*str)[currentPosition]) == delimiters.npos)) {
        currentPosition++;
    }
    if (retTokens && (start == currentPosition) &&
           (delimiters.find((*str)[currentPosition]) != delimiters.npos)) {
        currentPosition++;
    }

    return start;
}


int Strtok::CountTokens()
{
    int count = 0;
    int currpos = currentPosition;

    while (currpos < maxPosition) {
        /*
         * This is just skipDelimiters(); but it does not affect
         * currentPosition.
         */
        while (!retTokens &&
           (currpos < maxPosition) &&
           (delimiters.find((*str)[currpos]) != delimiters.npos)) {
        currpos++;
        }

        if (currpos >= maxPosition) {
        break;
        }

        int start = currpos;
        while ((currpos < maxPosition) && 
           (delimiters.find((*str)[currpos]) == delimiters.npos)) {
        currpos++;
        }
        if (retTokens && (start == currpos) &&
           (delimiters.find((*str)[currpos]) != delimiters.npos)) {
        currpos++;
        }
        count++;

    }
    return count;
}


void Strtok::Reset (string *_str)
{
    currentPosition = 0;
    str = _str;
    maxPosition = str->length ();
}


void Strtok::Reset (string *_str, bool returnTokens)
{
    retTokens = returnTokens;
    currentPosition = 0;
    str = _str;
    maxPosition = str->length ();
}


void Strtok::Reset (string *_str, string delim, bool returnTokens)
{
    retTokens = returnTokens;
    delimiters = delim;
    currentPosition = 0;
    str = _str;
    maxPosition = str->length ();
}



void Split(const string& s, const string& delim, vector<string>& items )
{
    string str = s;
    Strtok token(&str,delim);

    while ( token.HasMoreTokens() )
    {
        items.push_back(token.NextToken() );
    }


}

void Split(const string& s, string& result1, string& result2 )
{
    string str = s;
    Strtok token(&str," ");


    result1 = token.NextToken();
    result2 = token.NextToken();

}

string Join(const vector<string> &items, const string & delim)
{
    string ret = "";
    for ( int i = 0;i < items.size();i++){
        
        ret += items[i];
        ret += delim;

    }
    return ret.substr(0,ret.length() - delim.length() );

}

void GetKeysForMap(map<string,vector<string> > & myMap, vector<string>  & vec)

{
    std::map<string,vector<string> >::iterator p = myMap.begin();
    for( p;p != myMap.end() ;p++)
    {
        vec.push_back( (*p).first );
    }

}


void GetKeysForMap(map<string, string > & myMap, vector<string>  & vec)

{
    std::map<string,string >::iterator p = myMap.begin();
    for( p;p != myMap.end() ;p++)
    {
        vec.push_back( (*p).first );
    }

}


void RemoveFileFromMap(map<string,vector<string> > & myMap,const string& mySet, const string& myFile ) {
    std::map<string,vector<string> >::iterator p = myMap.begin();
    vector<string> *files;
    for( p;p != myMap.end() ;p++)
    {
        files = &(*p).second ;
        for ( int i = 0;i < files->size();i++ ) {
            if ( (*files)[i] == myFile ) {
                files->erase(files->begin() + i );
                break;
            }

        }
    }
    


};


void GetAbbExpansion(const string& exp, string& expands, int & cursor, bool& tabs ){
    expands = exp;
                        
    unsigned long mtPos = expands.find_last_of("||~");
    if ( mtPos == string::npos ) return;
    tabs = expands.substr(mtPos+1) == "1";
    expands[mtPos-2] = '\0'; // cut off of 
    unsigned long curPos = expands.find("||~");
    if ( curPos == string::npos ) return;
    cursor = atoi(expands.substr(curPos+3).c_str() );
    expands[curPos] = '\0';
                        
}

string SetAbbExpansion(CString& exp,CString & cursor, CString& tabs )
{

    CString xp = exp + "||~" + cursor + "||~" ;
    xp += tabs == "true" ? "1" : "0";
//  ElephantMessageBox(xp.GetBuffer(0) );
    return xp.GetBuffer(0);
}


string shortPathName(const string& path ) {

    

    char buffer[MAX_PATH+1];    
    GetShortPathName(path.c_str(),buffer,MAX_PATH+1) ;  
    return buffer;

}