CORE_String.h

Go to the documentation of this file.

#ifndef CORE_String_H
#define CORE_String_H


#include "CORE_Object.h"
#include "CORE_Pointers.h"

#include "CORE_Integer.h"
#include "CORE_Real.h"
#include "CORE_Complex.h"

DEFINE_SPTR(CORE_String);


class CORE_String : public  CORE_Object {

    SP_OBJECT(CORE_String)

    // ATTRIBUTES
    private:
    tString mString;
    int mTokenIndex;
    vector<tString> mSeparators; 
    vector<tString> mTokenizer;
  
    //ASSOCIATIONS
  
private:
  

  
    //CONSTRUCTOR
public:
    CORE_String();
    CORE_String(const tString& str);
    //DESTRUCTOR
    ~CORE_String();

protected:


    // NEW METHODS
public:
    static inline SP::CORE_String New() {
        SP::CORE_String ret(new CORE_String(""),CORE_String::Delete());
        //ret->mThis=WP::CORE_String(ret);
        return ret;
    };
    static inline SP::CORE_String New(const tString& str) {
        SP::CORE_String p(new CORE_String(str),CORE_String::Delete());
        return p;
    };
    

    // SET METHODS
public:
    const char& operator[](int i) const { 
        return mString[i];
    };

    char& operator[](int i) {  
        return mString[i];
    };
    
    inline void setString(const tString& str) {mString=str;};
    inline void setString(const char* str) {
        mString.clear();
        mString.append(str);
    };


    // GET METHODS
public:
    tString getString() const {return mString;};
  
    // OTHERS METHODS
public:
    tString toString() const {return mString;};  


 
     
    char * toCharArray() const {
        return stringToCharArray(mString);
    };
    static char * stringToCharArray(const tString& str);
    
    inline void tokenize(const tString& separator) {
        int n=separator.length();
        mSeparators.resize(n);
        for (int i=0;i<n;i++) {
            mSeparators[i]=separator.substr(i,1);
        }
        tokenize();
    }
    void tokenize();

    inline int getTokensCount() const {
        return mTokenizer.size();
    }
    inline int getTokensNumber() const {
        return mTokenizer.size();
    }

    inline void begin() {
        mTokenIndex=0;
    }

    inline tBoolean hasNextToken() const {
        return (mTokenIndex<((int)mTokenizer.size()));
    }
    
    inline tString nextToken() {
        return mTokenizer[mTokenIndex++];
    };
 
    inline tString getToken(const int& index) {
        return mTokenizer[index];
    };

    inline void replaceAll(const tString& strToReplace,
                           const tString& str) {
        replaceAll(mString,strToReplace,str);
    };
    inline void replaceFirst(const tString& strToReplace,
                             const tString& str) {
        replaceFirst(mString,strToReplace,str);
    };
    inline void replaceLast(const tString& strToReplace,
                             const tString& str) {
        replaceLast(mString,strToReplace,str);
    };
    static void replaceAll(tString& inOutValue,
                           const tString& strToReplace,
                           const tString& str);
    static void replaceFirst(tString& inOutValue,
                             const tString& strToReplace,
                             const tString& str);
    static void replaceLast(tString& inOutValue,
                            const tString& strToReplace,
                            const tString& str); 


    static int getOccurencesNumber(const tString& str,
                                   const tString& occ);
 


    static tString toString(const tString& str,const int& len)  {
        tString ret(str);
        int n=str.size();
        for (int i=n;i<len;i++) ret+=" ";
        return ret;
    };

   
    inline static void toUpper(tString& s) {
        std::transform(s.begin(), s.end(),
                       s.begin(), ::toupper);
    };
  
    
    inline void toUpper() {
        toUpper(mString);
    };
    static inline tString  toUpper(const tString& str)       {
        tString upper(str);
        toUpper(upper);
        return upper;
    };
    
    static inline void toLower(tString& s) {
        std::transform(s.begin(), s.end(),
                       s.begin(), ::tolower);
    }; 
    inline void toLower() {
        toLower(mString);
    };
    static inline tString  toLower(const tString& str)       {
        tString lower(str);
        toLower(lower);
        return lower;
    };
    
    

    inline static tString toString(const tFlag& c) {
        return CORE_Integer::toString(c);
    }; 
    inline static tString toString(const float&  c) {
        return CORE_Real::toString(c,6);
    }; 
    inline static tString toString(const double&  c) {
        return CORE_Real::toString(c,6);
    }; 
    inline static tString toString(const long double&  c) {
        return CORE_Real::toString(c,6);
    }; 
    inline static tString toString(const int&  c) {
        return CORE_Integer::toString(c);
    }; 
    inline static tString toString(const long& c) {
        return CORE_Integer::toString(c);
    }; 
    inline static tString toString(const long long& c) {
        return CORE_Integer::toString(c);
    }; 
    inline static tString toString(const unsigned int&  c) {
        return CORE_Integer::toString(c);
    }; 
    inline static tString toString(const unsigned long&  c) {
        return CORE_Integer::toString(c);
    }; 
    inline static tString toString(const unsigned long  long& c) {
        return CORE_Integer::toString(c);
    };
    inline static tString toString(const tBoolean&  c) {
        return toString((unsigned char) c);
    };
    inline static tString boolean2String(const tBoolean&  c) {
        if (c) return "true";
        else return "false";
    };
    inline static tString booleanToString(const tBoolean&  c) {
        return boolean2String(c);
    };
    inline static tBoolean string2Boolean(const tString&  c) {
        if (c.compare("true")==0) return true;
        else if (c.compare("1")==0) return true;
        else return false;
    };
    inline static tBoolean stringToBoolean(const tString&  c) {
        return string2Boolean(c);
    };
    inline static tString toString(tCharacter  c) {
   
        char *cs=new char[2];
        cs[0]=c;
        cs[1]='\0';
        tString ret(cs);
        delete[] cs;
        return ret;
    }; 
    inline static tString toString(tComplex  c) {
        return CORE_Complex::toString(c);
    };
    inline static tString toString(tString  c) {
        return c;
    };
    inline static tString toString(const int &n, const long double* c) {
        tString ret="{";
        for (int i=0;i<n-1;i++) ret+=CORE_Real::toString(c[i],10)+",";
        if (n>0)ret+=CORE_Real::toString(c[n-1],10);
        ret+="}";
        return ret;
    }; 
    inline static void parse(const tString& str,unsigned char& c) {
        c=(unsigned char) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,short int& c) {
        c=(short) CORE_Integer::parseInt(str);
    };
    inline static void parse(const tString& str,unsigned short int& c) {
        c=(short) CORE_Integer::parseInt(str);
    };  
    inline static void parse(const tString& str,int& c) {
        c=(int) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,long& c) {
        c=(long) CORE_Integer::parseInt(str);
    };  
    inline static void parse(const tString& str,long long& c) {
        c=(long long) CORE_Integer::parseInt(str);
    };
    inline static void parse(const tString& str,unsigned int& c) {
        c=(unsigned int) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,unsigned long& c) {
        c=(unsigned long) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,unsigned long long& c) {
        c=(unsigned long long) CORE_Integer::parseInt(str);
    };   
    inline static void parse(const tString& str,bool& c) {
        if (str.compare("true")==0) c=true;
        else if (str.compare("false")==0) c=false;
        else c=(bool) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,char& c) {
        c=str[0];
    };
    inline static void parse(const tString& str,float&  c) {
        c=(float) CORE_Real::parseReal(str);
    };  
    inline static void parse(const tString& str,double&  c) {
        c=(double) CORE_Real::parseReal(str);
    }; 
    inline static void parse(const tString& str,long double&  c) {
        c=(long double) CORE_Real::parseReal(str);
    };
    inline static void parse(const tString& str,tString&  c) {
        c=tString(str);
    };
    inline static void parse(const tString& str,tComplex&  c) {
        c=(tComplex) CORE_Complex::parseComplex(str);
    };
 
    inline tString::size_type indexOf(const tString& v) const {
        return mString.find(v);
      
    }; 
    inline tString::size_type lastIndexOf(const tString& v) const {
        return mString.rfind(v);
      
    };
    inline tString::size_type getLastIndexOf(const tString& v) const {
        return mString.rfind(v);
      
    };
    static inline tString::size_type getLastIndexOf(const tString& str,const tString& v)  {
        return str.rfind(v);
      
    }; 
    inline tString::size_type indexOf(const tString& v,
                                      const tString::size_type& fromIndex) const {
        return mString.find(v,fromIndex);
      
    };
    
    static tString keepOnlyFirstLines(const tString& str,
                                      const int& nLines,tBoolean& isTruncated);
    inline void remove(const tString::size_type& from,
                       const tString::size_type& to)  {
        mString.erase(from,to-from+1);
    };
    inline void remove(const tString::size_type& index)  {
        mString=mString.erase(index,1);
    };
    static void removeAll(tString& inOutStr,const tString& strToRemove);

    static void truncate(tString& text,const int &nLines,const int& nCharsByLine);
    
    inline static tString substring(const tString& str,
                                    const tString::size_type& from,
                                    const tString::size_type& to)  {
        return str.substr(from,to-from);
    };
    inline tString substring(const tString::size_type& from,
                             const tString::size_type& to) const {
        return mString.substr(from,to-from);
    };
    inline tString substring(const tString::size_type& from) const {
        return mString.substr(from);
    };
   
  
    inline char charAt(const int& index) const {
        return mString[index];
    };
    inline int length() const {
        return mString.length();
    }; 
    inline void append(const tString& v) {
        mString+=v;
    }
    inline void append(const char& v) {
        mString+=toString(v);
    }
    static void trim(tString& str);

    inline void trim() {
        trim(mString);
    }

    static int readInteger(const tString& v);
    static tReal readReal(const tString& v);

    inline static tBoolean isLetter(const char& v) {
        return ( ((v>='a') && (v<='z')) ||
                 ((v>='A') && (v<='Z'))
            );
    }
    inline static tBoolean isDigit(const char& v) {
        return ((v>='0') && (v<='9'));
           
    }
    
    // VIRTUAl METHODS
public:

    // PRIVATE METHODS
private:

  
};


#endif // end of ifndef