root/trunk/StringFunctions.h

#ifndef STRINGFUNCTIONS_H
#define STRINGFUNCTIONS_H

#include "stdincludes.h"
#include "cs_filefunctions.h"
#include <cctype>
#include <algorithm>
#include <afxpriv.h>

class WhiteSpace
{
public:
    static inline string ReplaceWhiteSpaceWithBlanks ( const string& str ) {

        CString v(str.c_str() );

        v.Replace("\r","");
        v.Replace("\t","");
        v.Replace("\n","");

        return v.GetBuffer(0);

    }
    

    static inline string ReplaceWithCodes ( const string& str ) {


        CString v(str.c_str() );

        v.Replace("\r","\\r");
        v.Replace("\t","\\t");
        v.Replace("\n","\\n");

        return v.GetBuffer(0);

    }

    static inline string ReplaceCodesWithWhite(const string& str ) {

        CString expands(str.c_str() );
        expands.Replace("\\r","\r");
        expands.Replace("\\t","\t");
        expands.Replace("\\n","\n");

        return expands.GetBuffer(0);
    }
    

};

inline bool FileIsReadOnly(const string& file )
{

    DWORD code = GetFileAttributes(file.c_str() );

    if ( code & FILE_ATTRIBUTE_READONLY ) return true;

    return false;



}
inline bool isFullPath(const string& word )
{

    if ( word.length() > 3 ) if ( word.substr(1,2) == ":\\" ) return true;
    return false;

}
inline string ITOA(int x) {
    char y[20];
    sprintf(y,"%d",x);
    return y;
}

inline string ReplaceCRandLF(string& buffer ) {
    CString buf(buffer.c_str() );
    buf.Replace("\r\n","REPLACE");
    buf.Replace("\r","REPLACE");
    buf.Replace("\n","REPLACE");
    buf.Replace("REPLACE","\r\n");
    return buf.GetBuffer(0);
}


inline void StripTrailingChars(string& str , char t ) {
    

    unsigned long pos = str.length() - 1;
    if ( pos != string::npos ) {
        while (pos > 0 && str[pos--] == t ) ; // find the last pos without 't'
    }
    
    str = str.substr(0,pos+2);


}

inline string LowerCase(const string& u ) {
    string ret = "";
    for ( int i = 0;i < u.size();i++) { // dont lower the null zero , somehow that affect
        ret += tolower(u[i] );
    }

    return ret;
}

inline char* getcwd()
{
    char data[MAX_PATH+1];
    GetCurrentDirectory(MAX_PATH,data );
    return strdup(data);
}

string GetEmbeddedString(const string& marker, const string& buffer ) {
        unsigned long pos = buffer.find_first_of(marker);
        unsigned long pos2 = buffer.find_last_of(marker);
        if ( pos != string::npos && pos2 != string::npos ) 
                return buffer.substr(pos+1,pos2);
        return "";
}


inline int FindMatchingStrings(const string& str, const vector<string>& collection, int &startIndex ) {

    int start = 0, count  = 0;
    for ( int i = 0;i < collection.size();i++) {

            if ( LowerCase(collection[i].substr(0,str.length() ) ) == LowerCase(str) ) {
                count++;
                if ( start == 0) start = i;
            }

    }

    startIndex = start;
    return count;


}


inline bool ParseFartLine(const string& buf, string& lineNumber, string& line ) {
    unsigned long pos = 0 , pos1 = 0;

    pos = buf.find("[");
    pos1 = buf.find("]");

    if ( pos == string::npos || pos1 == string::npos ) return false;

    lineNumber = buf.substr(pos+1, pos1 - (pos + 1 ) );
    line = buf.substr(pos1+1);

    return true;

}

inline string StripFileName(const string& s) {
    return s.substr(s.find_last_of("\\") + 1 );
}


inline string StripDirPath(const string& s) {
    return s.substr(0,s.find_last_of("\\"));
}

inline string StripDirName(const string& s)
{   
    return s.substr(s.find_last_of("\\") + 1);
    
}

inline bool GetFileAndLineNumber(string& s,int& lineNumber, string& file ) {

    unsigned long pos2, startPos = s.find_first_of(":") , pos = s.find_first_of("(");
    if ( pos == string::npos || startPos == string::npos) return false;
    
    
    file = s.substr(0,pos);
    //AfxMessageBox(file.c_str());
    pos2 = s.find_first_of(")");
    lineNumber = atoi(s.substr(pos+1, pos2 - pos).c_str());
    if ( lineNumber == 0 ) return false;
    s = s.substr(startPos+1);


    return true;
    
}

inline void GetFontStyles(const string& s, int styles[3]) {

    unsigned long pos = s.find_first_of("|");
    styles[0] = atoi(s.substr(0,pos).c_str() );
    unsigned long pos2 = s.find("|",pos+1);
    styles[1] = atoi(s.substr(pos+1,pos2).c_str() );    
    unsigned long pos3 = s.find("|",pos2+1);
    styles[2] = atoi(s.substr(pos2+1,pos3).c_str() );   

}


inline void GetTabStyles(const string& s, int styles[2]) {

    unsigned long pos = s.find_first_of("|");
    styles[0] = atoi(s.substr(0,pos).c_str() );
    unsigned long pos2 = s.find("|",pos+1);
    styles[1] = atoi(s.substr(pos+1,pos2).c_str() );    
}

inline string ReadFile(const string& file) {    
    
    if (FileExists(file) ) 
    {
        
        string buffer = "" , line = "";
        
        ifstream in(file.c_str() );
        if ( in.good() ) {
            while ( !in.eof () ) {
                std::getline(in,line);
                buffer += line + "\n";
            }
        }
        in.close();
        
        return buffer;
    }
    else return "";
    /*
    
      if ( FileExists(file_) ) {
    
    FILE* file = fopen(file_.c_str() ,"r");
    fseek(file,0, SEEK_END);
    int end = ftell(file) + 1;
    char* data = new char[end];
    fseek(file,0,SEEK_CUR); 
    fread((void*)data,1,end,file);
    if ( data ) 
    {
        string ret(data);
        fclose(file);
        delete data;
        return ret;
    }
    
    fclose(file);
    }
    return "";
    */
}

inline bool LastCharIsCurlyBrace(const string& buffer) {
//  char temp[10];
    for (int i = buffer.size() - 1;i >= 0;i--) {
        if (buffer[i] == '\t' || buffer[i] == ' ' || buffer[i] == '\n' || buffer[i] == '\r' || buffer[i] == 10 || buffer[i] == 13 ) continue;
        else if (buffer[i] == '{') return true;
        return false;
    }
    return false;
}
    

inline string GetTabs(const string& buffer) {
    string tabs = "";
    for (int i = 0;i < buffer.size();i++) {
        if (buffer[i] == '\t') tabs += "\t";
        if (buffer[i] != '\t') return tabs; // use this so that only the first tabs are counted
    }
    return tabs;
}

inline bool ContainsWords(const string& word) {
    for (int i = 0;i < word.size();i++) {
        if (isalpha(word[i]) || isdigit(word[i])) return true;
    }
    return false;
}

inline bool IsAllWhiteSpace(const string& s) {

    for ( int i = 0;i < s.length();i++) {
        if (isspace(s[i] ) ) continue;
        return false;
    }
    return true;

}

inline bool BeginsWithComment(const string& s) {
    if (s.length() < 2) return false;
    if (s[0] == '/' && s[1] == '/') return true;
    if (s[0] == '/' && s[1] == '*') return true;
    return false;

}
    
    
inline string GetDMDUnzipPath(const string& path ) {
    unsigned int pos = path.find("dmd");
    return path.substr(0,pos);
}


inline string GetDIGUnzipPath(const string& path ) {
    unsigned int pos = path.find("dig");
    return path.substr(0,pos);
}

inline bool ExistsIn(vector<string> & h , const string& n ) {
    for ( int i = 0;i < h.size();i++) {
        if ( h[i] == n ) return true;
    }
    return false;
}


template < class T > 
inline  void RemoveDuplicates(vector<T>& output,vector<T>& uniques) {
    
    std::sort(output.begin(),output.end() );
    std::unique_copy (output.begin(), output.end(),std::inserter(uniques, uniques.begin()));
    
}

inline bool IsBrace(char ch) {
    return ch == '[' || ch == ']' || ch == '(' || ch == ')' || ch == '{' || ch == '}';
}


inline string FileExtension(const string& s ) {
    unsigned long pos = s.find_last_of(".");
    return s.substr(pos+1);
}


inline void StripExtension(string& s ) {
    unsigned long pos = s.find_last_of(".");
    s = s.substr(0,pos);
}

inline string StripModifyStar(CString title)
{
    title.Replace("*","");
    return title.GetBuffer(0);
    
}
inline string stripl(const string&  s)
{
    int i;

    for (i = 0; i < s.length(); i++)
    {
    if (!isspace(s[i]))
        break;
    }
    return s.substr(i,s.length() ) ;
}

inline string stripr(const string& s)
{
    int i;

    for (i = s.length(); i > 0; i--)
    {
    if (!isspace(s[i - 1]))
        break;
    }
    return s.substr(0,i);
}

inline string strip(const string& s)
{
    return stripr(stripl(s));
}


inline string ReplaceConstants(string& s, const string& name, const string& pname) {

    unsigned long pos = 0 , inc = 0;

    CTime _t = CTime::GetCurrentTime();
    CString t;
    t.Format("%d / %d / %d",_t.GetMonth(),_t.GetDay(), _t.GetYear());

    CString time;
    time.Format("%d:%d:%d",_t.GetHour(), _t.GetMinute(),_t.GetSecond());

    
    pos = 0;
    inc = 0;
    
    while ( (pos = s.find("PROJECTNAME",inc) ) != string::npos  ) {
        s.replace(pos,11,pname.c_str() );
    }

    pos = 0;
    inc = 0;

    while ( (pos = s.find("DATE",inc) ) != string::npos  ) {
        s.replace(pos,4,(LPCSTR)t);
    }

    pos = 0;
    inc = 0;

    while ( (pos = s.find("TIME",inc) ) != string::npos  ) {
        s.replace(pos,4,(LPCSTR)time);
    }


    pos = 0;
    inc = 0;

    while ( (pos = s.find("NAME",inc) ) != string::npos  ) {
        s.replace(pos,4,name.c_str() );
    }



    return s;
}       

inline string ReplaceAll(const string& _line , const string& findString, const string& replaceString, bool ignoreCase = false ) 
{

    CString line(_line.c_str() );
    int pos = 0;

    if ( ignoreCase ) {
        CString lower = line;
        CString fs(findString.c_str() );
        fs.MakeLower();
        lower.MakeLower();

//      ElephantMessageBox(lower );
//      ElephantMessageBox(fs );
        
        while ( (pos = lower.Find(fs) )  != -1 ) {
            
            line.Delete(pos , findString.length());
            line.Insert(pos,replaceString.c_str() );

            // replace for lower also so it will just traverse the string
            lower.Delete(pos , findString.length());
            lower.Insert(pos,replaceString.c_str() );
            
        }

    }
    else {
        
        line.Replace(findString.c_str() , replaceString.c_str() );
    }

    return line.GetBuffer(0);
    
}

string shortPathName(const string& path );

inline string TranslateToolsMenuConstants(const string& str, const string& currentFile,const string& projectExe, 
                      const string& projectDir,const vector<string>& pfiles ) {
    string projectFiles = "";
    for ( int i = 0;i < pfiles.size();i++) {        
        i + 1 == pfiles.size () ?
            projectFiles += "\"" + pfiles[i] + "\""
            :
            projectFiles += "\"" + pfiles[i] + "\" ";

    }

    CString buf(str.c_str() );
    buf.Replace("CURRENTFILE",string("\"" + currentFile + "\"" ).c_str() );
    buf.Replace("PROJECTEXE",string("\"" + projectExe + "\"" ).c_str() );
    buf.Replace("PROJECTDIR",string("\"" + projectDir + "\"").c_str() );
    buf.Replace("PROJECTFILES",projectFiles.c_str() );

    return buf.GetBuffer(0);
}

inline BOOL  getLongPathName(const string & cs, CString &sLongPath) 
{
        CString sShortPath(cs.c_str() );
        USES_CONVERSION;

        LPSHELLFOLDER   psfDesktop = NULL; 
        ULONG                   chEaten = 0; 
        LPITEMIDLIST    pidlShellItem = NULL; 
        WCHAR                   szLongPath[_MAX_PATH] = { 0 }; 
        BOOL                    bResult = TRUE;

        // Get the Desktop's shell folder interface 
        HRESULT hr = SHGetDesktopFolder(&psfDesktop); 

        LPCTSTR lpsz = (LPCTSTR)sShortPath;
        LPWSTR  lpwShortPath = A2W(lpsz);

        // Request an ID list (relative to the desktop) for the short pathname 
        hr = psfDesktop->ParseDisplayName(NULL, NULL, lpwShortPath, &chEaten, &pidlShellItem, NULL); 
        psfDesktop->Release(); // Release the desktop's IShellFolder 

        if(FAILED(hr)) 
        { 
                // If we couldn't get an ID list for short pathname, it must not exist. 
                sLongPath.Empty();
                bResult = FALSE;
        } 
        else 
        { 
                // We did get an ID list, convert it to a long pathname 
                SHGetPathFromIDListW(pidlShellItem, szLongPath); 
 
                // Free the ID list allocated by ParseDisplayName 
                LPMALLOC pMalloc = NULL; 
                SHGetMalloc(&pMalloc); 
                pMalloc->Free(pidlShellItem); 
                pMalloc->Release(); 
                sLongPath = W2A(szLongPath);
        } 

        return bResult; 

}  




inline bool IsIn(const string& t, const vector<string>& v ) {
    for ( int i = 0;i < v.size();i++) {
        if ( v[i] == t ) return true;
    }
    return false;
}

inline void AdvanceWhiteSpaceOrComment(const string& line, int& pos ) {

    bool isInLineComment = false, isInFullComment = false;

    for ( int i = 0;i < line.size();i ++ ) {

        if ( isspace(line[i] ) ) {
            continue;
        }   
        else {
            
            if ( line[i] == '/' ) { // check to see if start of comment

                if ( line.length() > i + 1 ) {
                    if ( line[i + 1] == '*') {
                        i++;
                        isInFullComment = true;
                        continue;
                    }
                    else if ( line[i + 1] == '/' ) {
                        i++;
                        isInLineComment = true;
                        /* */                       continue;
                    }
                }

                if ( line.length() > i - 1 ) {
                    if ( line[i - 1 ] == '*' ) {
                        isInFullComment = false;
                        isInLineComment = false;
                    }
                }
            }
            else if  ( line[i] == '\n' ) {
                isInLineComment = false;
                continue;
            }
            else if ( isInLineComment || isInFullComment ) {
                continue;
            }
            else {
                pos = i;
                return;
            }
        }

    }

}   

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

inline bool CheckForCombo(const string& start, char end, const string& line ) {

    // check that the first part matches
    if ( line.length() > start.length () ) { 
        if ( line.substr(0,start.length () ) != start ) {
            return false;
        }
    }
    else return false;

    int i = start.length();
    int pos = 0;

    if ( i < line.length() ) {

        AdvanceWhiteSpaceOrComment(line.substr(i) , pos );
        CString buf(line[pos + i] );
        if ( pos + i  <= line.length () ) {
            if ( line[pos + i] == end ) return true;
            else {
                return false;
            }
        }
    }
    
    return false;
        
}

inline bool StartsWith( const string& match, const string& text ) {

    if ( text.length() > match.length () ) 
        if ( text.substr(0,match.length()) == match ) 
            return true;
    
    return false;
}
inline void Reverse(string& line )
{

  std::reverse(line.begin(),line.end() );

}

bool StartsWithBackward(const string& match, const string& backwardText );
void AdvanceToWhiteSpaceOrChar(const string& text, int & pos, char c );
void AdvanceToWhiteSpace(const string& text, int & pos ) ;

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

inline bool IsWord( const string& text ) {
    if ( !text.size() ) return false;
    for ( int i = 0 ;i < text.size();i++) {
        if ( isalpha(text[i]) || isdigit(text[i]) || text[i] == '_' || text[i] == '-' ) continue;
        else return false;

    }
    return true;
}

inline bool IsType( const string& text ) {
    if ( !text.size() ) return false;
    for ( int i = 0 ;i < text.size();i++) {
        if ( isalpha(text[i]) || isdigit(text[i]) || text[i] == '_' || text[i] == '-' 
             || text[i] == '['
             || text[i] == ']'
             || text[i] == '*'
             || text[i] == '.'
            ) continue;
        else return false;

    }
    return true;
}



bool MatchesFunctionDefinition (const string& text) ; 


void Split(const string& str, const string& delim, vector<string>& items );
void Split(const string& buffer, string& result1, string& result2 );
string Join(const vector<string>& items, const string & delim);
void GetKeysForMap(map<string,vector<string> > & , vector<string>  &);
void GetKeysForMap(map<string,string> & , vector<string>  &);
void RemoveFileFromMap(map<string,vector<string> > & myMap,const string& mySet, const string& myFile ) ;

template<typename T> void RemoveFromVector(vector<T>& words, const vector<T>& word )
{

    for ( int i = 0 ;i < word.size();i++)
    {

        for ( int j = 0;j < words.size();j++) {
            if ( words[j] == word[i] ) {
                words.erase(j + words.begin());
                break;
            }
        }

    }
}
template<typename T> void RemoveFromVector(vector<T>& words, const T& word )
{
    for ( int i = 0;i < words.size();i++)
    {
        if ( words[i] == word ) {
            words.erase(i + words.begin () );
            break;
        }

    }

}
void GetAbbExpansion(const string& exp, string& expands, int & cursor, bool& tabs );
string SetAbbExpansion(CString& exp,CString & cursor, CString& tabs );



class Strtok {

 public:
    Strtok (string *_str, string delim,
            bool returnTokens);
    Strtok (string *_str, string delim);
    Strtok (string *_str);
    Strtok ();
    ~Strtok ();

    void SkipDelimiters ();
    bool HasMoreTokens ();
    string NextToken(void);
    bool NextToken(string &_str);
    int GetStart (void);
    int CountTokens();
    void Reset (string *_str);
    void Reset (string *_str, bool returnTokens);
    void Reset (string *_str, string delim, bool returnTokens = false);
 
 private:
    int currentPosition;
    int maxPosition;
    string* str;
    string delimiters;
    bool retTokens;
};

#endif