str.hpp

Go to the documentation of this file.

/*
 *     SocialLedge.com - Copyright (C) 2013
 *
 *     This file is part of free software framework for embedded processors.
 *     You can use it and/or distribute it as long as this copyright header
 *     remains unmodified.  The code is free for personal use and requires
 *     permission to use in a commercial product.
 *
 *      THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED
 *      OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
 *      MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
 *      I SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR
 *      CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 *
 *     You can reach the author of this software at :
 *          p r e e t . w i k i @ g m a i l . c o m
 */

#ifndef STR_HPP__
#define STR_HPP__



#define STR_ON_STACK(name, size)    \
    char __##name##buffer[size];    \
    str name((__##name##buffer), sizeof(__##name##buffer))



class str
{
    public:
        static int toInt(const char* pString);     
        static int toInt(str& s)   { return str::toInt(s()); }
        static float toFloat(const char* pString); 
        static float toFloat(str& s) { return str::toFloat(s()); }
        str();                      
        str(int capacity);          
        str(const char* pString);   
        str(char *buff, int size);  
        str(const str& s);          
        ~str();                     

        int getLen() const;      
        int getCapacity() const; 
        bool reserve(int n);     
        void clear();            
        void clearAll();         

        void toLower(); 
        void toUpper(); 

        int printf(const char* pFormat, ...);

        int scanf(const char* pFormat, ...);

        int tokenize(const char* delimators, int char_ptr_count, ...);

        bool insertAtBeg(const char* pString);
        bool insertAtBeg(const str& s) { return insertAtBeg(s()); }
        bool insertAtEnd(const char* pString);
        bool insertAtEnd(const str& s) { return insertAtEnd(s()); }
        bool insertAt(const int index, const char* pString);
        bool insertAt(const int index, const str& s) { return insertAt(index, s()); }
        void append(const char* pString);           
        void append(const str& s) { append(s()); }  
        void append(int x);                         
        void append(float x);                       
        void appendAsHex(unsigned int num);         

        bool compareTo(const char* pString) const;
        bool compareTo(const str& s) const { return compareTo(s.c_str()); }
        bool compareToIgnoreCase(const char* pString) const;
        bool compareToIgnoreCase(const str& s) const { return compareToIgnoreCase(s()); }
        int firstIndexOfIgnoreCase(const char* pString) const;
        int firstIndexOfIgnoreCase(const str& s) const { return firstIndexOfIgnoreCase(s()); }

        int firstIndexOf(const char* pString) const;
        int firstIndexOf(const str& s) const { return firstIndexOf(s()); }
        int lastIndexOf(const char* pString) const;
        int lastIndexOf(const str& s) const { return lastIndexOf(s()); }
        bool contains(const char* pString) const;
        bool contains(const str& s) const { return contains(s()); }
        bool containsIgnoreCase(const char* pString) const;
        bool containsIgnoreCase(const str& s) const { return containsIgnoreCase(s()); }

        int countOf(const char* pString) const;
        int countOf(const str& s) const { return countOf(s()); }

        bool beginsWith(const char* pString) const;
        bool beginsWith(const str& s) const { return endsWith(s()); }
        bool beginsWithIgnoreCase(const char* pString) const;
        bool beginsWithIgnoreCase(const str& s) const { return beginsWithIgnoreCase(s()); }

        bool beginsWithWholeWord(const char* pString, char seperator=' ') const;
        bool beginsWithWholeWordIgnoreCase(const char* pString, char seperator=' ') const;

        bool endsWith(const char* pString) const;
        bool endsWith(const str& s) const { return endsWith(s()); }
        bool endsWithIgnoreCase(const char* pString) const;
        bool endsWithIgnoreCase(const str& s) const { return endsWithIgnoreCase(s()); }
        bool erase(const char* pString);
        bool erase(const str& s) { return erase(s()); }
        bool eraseFirst(int nChars);
        bool eraseLast(int nChars);
        bool eraseCharAt(int index);
        bool eraseAllAfter(int index);
        bool eraseAfter(int index, int nChars);
        bool eraseFirstWords(int words, char separator = ' ');
        int eraseAllSpecialChars(); 

        void trimStart(const char* pChars);
        void trimStart(const str& s) { trimStart(s()); }
        void trimEnd(const char* pChars);
        void trimEnd(const str& s) { trimEnd(s()); }
        bool replaceFirst(const char* pFind, const char* pWith);
        bool replaceLast(const char* pFind, const char* pWith);
        int replaceAll(const char* pFind, const char* pWith);
        const str& subString(int fromIndex);
        const str& subString(int fromIndex, int charCount);
        const str& subString(char fromFirstChar);
        const str& subString(const char* fromStr);
        const str& subString(char fromFirstChar, int charCount);
        const str& subString(const char* fromStr, int charCount);
        const str& subString(char fromFirstChar, char toLastChar);
        const str* getToken(const char* pSplitter = " ", bool restart=false);



        bool isAllAlpha() const;     
        bool isAlphaNumeric() const; 
        bool isFloat() const;        
        bool isUint() const;         
        bool isInt() const;          

        unsigned int checksum_Get(); 
        void checksum_Append();      
        void checksum_Remove();      
        bool checksum_Verify();      

        void operator=(const char* pString);  
        void operator=(int num);              
        void operator=(float num);            
        str& operator=(const str& rhs);       

        void operator++();           
        void operator++(int unused); 
        void operator--();           
        void operator--(int unused); 

        void operator+=(const char singleChar); 
        void operator+=(const char* pString);   
        void operator+=(const str& s);          
        void operator+=(int n);                 
        void operator-=(const char* pString);   
        void operator-=(const str& s);          
        void operator-=(int n);                 
        void operator+=(float n);               
        void operator-=(float n);               

        bool operator==(const char* pString) const;
        bool operator==(const str& rhs) const;
        bool operator==(int) const;
        bool operator!=(const char* pString) const;
        bool operator!=(const str& rhs) const;
        bool operator!=(int) const;
        // Note: Floats cannot be compared using == operator, they require delta comparison
        bool operator<(const char* pString) const;
        bool operator<(const str& s) const { return (*this) < s(); }
        bool operator<(int) const;

        bool operator>(const char* pString) const;
        bool operator>(int) const;
        bool operator>(const str& s) const { return (*this) > s(); }

        bool operator<=(const char* pString) const;
        bool operator<=(int) const;
        bool operator<=(const str& s) const { return (*this) <= s(); }

        bool operator>=(const char* pString) const;
        bool operator>=(int) const;
        bool operator>=(const str& s) const { return (*this) >= s(); }
        bool operator<(float) const;
        bool operator>=(float) const;
        bool operator>(float) const;
        bool operator<=(float) const;
        const char* operator()() const;                   
        const char* c_str() const { return (*this)(); };  
        operator float() const;     
        operator int() const;       
        char& operator[](int pos);  


    private:
        bool mStackMem;     
        int mCapacity;      
        char* mpStr;        
        str* mpTempStr;     
        char* mpTokenPtr;   
        static const int mInvalidIndex = -1;
        static const int mAllocSize = 16;

        void init(int initialLength=mAllocSize)
        {
            mStackMem = false;
            mCapacity = 0;
            mpStr = 0;
            mpTempStr = 0;
            mpTokenPtr = 0;

            reAllocateMem(initialLength);
        }

        bool ensureMemoryToInsertNChars(const int nChars);

        bool reAllocateMem(const int size);

        void copyFrom(const char* pString);

        int singleHexCharToInt(unsigned char theChar);

        int hexStrDigitsToInt(char* pString);

        friend bool test_str(void);
};

#endif /* STR_HPP__ */