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;
    vector<tString>::iterator 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;
    };
    

    
public:

    // accessor operators
    // ==================
    inline const char& operator[](const tUIndex& i) const {
        ASSERT_IN(i<mString.length());
        return mString[i];
    };

    inline char& operator[](const tUIndex& i) {
        ASSERT_IN(i<mString.length());
        return mString[i];
    };

    //equal operator
    //===============

    inline CORE_String& operator=(const tString& s) {
        mString=s;
        return (*this);
    }
    inline CORE_String& operator=(const CORE_String& s) {
        mString=s.getString();
        return (*this);
    }
    inline CORE_String& operator=(SP::CORE_String s) {
        if (s.get()!=null)
            mString=s->getString();
        return (*this);
    }
    
    //arithmetic operator
    //===================
    inline CORE_String& operator+=(const CORE_String& s) {
        append(s.getString());
        return (*this);
    };
    inline CORE_String& operator+=(const tString& s) {
        append(s);
        return (*this);
    };
    inline CORE_String& operator+=(SP::CORE_String s) {
        if (s.get()!=null) append(s->getString());
        return (*this);
    };
 
    inline CORE_String& operator-=(const CORE_String& s) {
        removeAll(mString,s.getString());
        return (*this);
    };
    inline CORE_String& operator-=(const tString& s) {
        removeAll(mString,s);
        return (*this);
    };
    inline CORE_String& operator-=(SP::CORE_String s) {
        if (s.get()!=null) removeAll(mString,s->getString());
        return (*this);
    };

    
    // SET METHODS
    // ===========
    inline void setString(const tString& str) {
        mString=str;
    };
    inline void setString(const char* str) {
        mString.clear();
        mString.append(str);
    };


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


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

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

    inline void begin() {
        mTokenIndex=mTokenizer.begin();
    }

    inline tBoolean hasNextToken() const {
        return (mTokenIndex!=mTokenizer.end());
    }
    
    inline tString nextToken() {
        tString &ret=(*mTokenIndex);
        mTokenIndex++;
        return ret;
    };
 
    inline tString getToken(const tUIndex& 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 tUInteger getOccurencesNumber(const tString& str,
                                         const tString& occ);
 


    static tString toString(const tString& str,const tUIndex& len)  {
        tString ret(str);
        tUIndex i,n=str.size();
        for (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 void toLower(tString& s) {
        std::transform(s.begin(), s.end(),
                       s.begin(), ::tolower);
    }; 
    inline void toLower() {
        toLower(mString);
    };
   
    
    
    inline static tString toString(const char* c) {
        tString s(c);
        return s;
    };
    inline static tString toString(const tBoolean& c) {
        return boolean2String(c);
    };
    inline static tString toString(const tChar&  c) {
        return CORE_Integer::toString((int) c);
      // char *cs=new char[2];
      // cs[0]=c;
      // cs[1]='\0';
      // tString ret(cs);
      // delete[] cs;
      // return ret;
    };
    
    inline static tString toString(const tUChar& c) {
        return CORE_Integer::toString((int)c);
    };


    inline static tString toString(const tSInt& c) {
        return CORE_Integer::toString(c);
    };
    inline static tString toString(const tUSInt& c) {
        return CORE_Integer::toString(c);
    };
    inline static tString toString(const tInt&  c) {
        return CORE_Integer::toString(c);
    };
    inline static tString toString(const tUInt&  c) {
        return CORE_Integer::toString(c);
    };
    
    inline static tString toString(const tLInt& c) {
        return CORE_Integer::toString(c);
    };
    inline static tString toString(const tULInt&  c) {
        return CORE_Integer::toString(c);
    };
    inline static tString toString(const tLLInt& c) {
        return CORE_Integer::toString(c);
    };
    inline static tString toString(const tULLInt&  c) {
        return CORE_Integer::toString(c);
    }; 
    inline static tString toString(const tFloat&  c) {
        return CORE_Real::toString(c);
    }; 
    inline static tString toString(const tDouble&  c) {
        return CORE_Real::toString(c);
    }; 
    inline static tString toString(const tLDouble&  c) {
        return CORE_Real::toString(c);
    }; 
 
    inline static tString boolean2String(const tBoolean&  c) {
        return (c ? "true" : "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(const tComplex&  c) {
        return CORE_Complex::toString(c);
    };
    inline static tString toString(const tString&  c) {
        return c;
    };
    inline static tString toString(const tLDouble* c,const tUInteger& n) {
        tString ret="{";
        if (n>0) {
            for (tUInteger i=0;i<n-1;i++) ret+=CORE_Real::toString(c[i])+",";
            ret+=CORE_Real::toString(c[n-1]);
        }
        ret+="}";
        return ret;
    }; 
    inline static void parse(const tString& str,tUChar& c) {
        c=(tUChar) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,tSInt& c) {
        c=(tSInt) CORE_Integer::parseInt(str);
    };
    inline static void parse(const tString& str,tUSInt& c) {
        c=(tUSInt) CORE_Integer::parseInt(str);
    };  
    inline static void parse(const tString& str,tInt& c) {
        c=(tInt) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,tLInt& c) {
        c=(tLInt) CORE_Integer::parseInt(str);
    };  
    inline static void parse(const tString& str,tLLInt& c) {
        c=(tLLInt) CORE_Integer::parseInt(str);
    };
    inline static void parse(const tString& str,tUInt& c) {
        c=(tUInt) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,tULInt& c) {
        c=(tULInt) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,tULLInt& c) {
        c=(tULLInt) CORE_Integer::parseInt(str);
    };   
    inline static void parse(const tString& str,tBoolean& c) {
        if (str.compare("true")==0) c=true;
        else if (str.compare("false")==0) c=false;
        else c=(tBoolean) CORE_Integer::parseInt(str);
    }; 
    inline static void parse(const tString& str,tChar& c) {
        c=str[0];
    };
    inline static void parse(const tString& str,tFloat&  c) {
        c=(tFloat) CORE_Real::parseReal(str);
    };  
    inline static void parse(const tString& str,tDouble&  c) {
        c=(tDouble) CORE_Real::parseReal(str);
    }; 
    inline static void parse(const tString& str,tLDouble&  c) {
        c=(tLDouble) 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 tUIndex indexOf(const tString& v) const {
        return mString.find(v);
      
    }; 
    inline tUIndex lastIndexOf(const tString& v) const {
        return mString.rfind(v);
      
    };
    inline tUIndex getLastIndexOf(const tString& v) const {
        return mString.rfind(v);
      
    };
    static inline tUIndex getLastIndexOf(const tString& str,
                                         const tString& v)  {
        return str.rfind(v);
      
    }; 
    inline tUIndex indexOf(const tString& v,
                           const tUIndex& fromIndex) const {
        return mString.find(v,fromIndex);
      
    };
    
    static tString keepOnlyFirstLines(const tString& str,
                                      const tUIndex& nLines,
                                      tBoolean& isTruncated);
    
    inline void remove(const tUIndex& from,
                       const tUIndex& to)  {
        mString.erase(from,to-from+1);
    };
    inline void remove(const tUIndex& index)  {
        mString=mString.erase(index,1);
    };
    static void removeAll(tString& inOutStr,const tString& strToRemove);

    static void truncate(tString& text,const tUInteger &nLines,const tUInteger& nCharsByLine);
    
    inline static tString substring(const tString& str,
                                    const tUIndex& from,
                                    const tUIndex& to)  {
        return str.substr(from,to-from);
    };
    inline tString substring(const tUIndex& from,
                             const tUIndex& to) const {
        return mString.substr(from,to-from);
    };
    inline tString substring(const tUIndex& from) const {
        return mString.substr(from);
    };
   
  
    inline char charAt(const tUIndex& index) const {
        return (*this)[index];
    };
    inline tUIndex length() const {
        return mString.length();
    }; 
    inline void append(const tString& v) {
        mString.append(v);
    }
    inline void append(const char& v) {
        mString.append(&v,1);
    }
    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')) || (v=='-') || (v=='+'));
           
    }
    
    // VIRTUAl METHODS
public:

    // PRIVATE METHODS
private:

    /* \brief search the first token
     * @param[in] words : words to find the first token
     * @param[out] sepLength: number of chars of the separator found
     * @return the index of the first seperator found in words
     */
    tUIndex findFirstSeparator(const tString& words,tUIndex& sepLength) const;
};


#endif // end of ifndef