GNU CommonC++: string.h Source File

00001 // Copyright (C) 1999-2001 Open Source Telecom Corporation. 00002 // 00003 // This program is free software; you can redistribute it and/or modify 00004 // it under the terms of the GNU General Public License as published by 00005 // the Free Software Foundation; either version 2 of the License, or 00006 // (at your option) any later version. 00007 // 00008 // This program is distributed in the hope that it will be useful, 00009 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00010 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00011 // GNU General Public License for more details. 00012 // 00013 // You should have received a copy of the GNU General Public License 00014 // along with this program; if not, write to the Free Software 00015 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 00016 // 00017 // As a special exception to the GNU General Public License, permission is 00018 // granted for additional uses of the text contained in its release 00019 // of Common C++. 00020 // 00021 // The exception is that, if you link the Common C++ library with other 00022 // files to produce an executable, this does not by itself cause the 00023 // resulting executable to be covered by the GNU General Public License. 00024 // Your use of that executable is in no way restricted on account of 00025 // linking the Common C++ library code into it. 00026 // 00027 // This exception does not however invalidate any other reasons why 00028 // the executable file might be covered by the GNU General Public License. 00029 // 00030 // This exception applies only to the code released under the 00031 // name Common C++. If you copy code from other releases into a copy of 00032 // Common C++, as the General Public License permits, the exception does 00033 // not apply to the code that you add in this way. To avoid misleading 00034 // anyone as to the status of such modified files, you must delete 00035 // this exception notice from them. 00036 // 00037 // If you write modifications of your own for Common C++, it is your choice 00038 // whether to permit this exception to apply to your modifications. 00039 // If you do not wish that, delete this exception notice. 00040 00046 #ifndef CCXX_STRING_H_ 00047 #define CCXX_STRING_H_ 00048 00049 #ifndef CCXX_MISSING_H_ 00050 #include <cc++/missing.h> 00051 #endif 00052 00053 #ifndef CCXX_STRCHAR_H_ 00054 #include <cc++/strchar.h> 00055 #endif 00056 00057 #ifdef CCXX_NAMESPACES 00058 namespace ost { 00059 #endif 00060 00061 class MemPager; 00062 00079 class __EXPORT String 00080 { 00081 protected: 00082 static const unsigned minsize; 00083 static const unsigned slotsize; 00084 static const unsigned pagesize; 00085 static const unsigned slotlimit; 00086 static const unsigned slotcount; 00087 00088 friend class StringObject; 00089 00090 private: 00091 friend class MemPager; 00092 00093 static MemPager *pager; 00094 static char **idx; 00095 00096 #pragma pack(1) 00097 union 00098 { 00099 struct 00100 { 00101 char *text; 00102 size_t size; 00103 size_t length; 00104 } bigstring; 00105 struct 00106 { 00107 char text[(sizeof(char *) + (sizeof(size_t) * 2) + 1)]; 00108 char length : 6; 00109 bool big : 1; 00110 } ministring; 00111 } content; 00112 #pragma pack() 00113 00114 protected: 00121 inline bool isBig(void) const 00122 {return content.ministring.big;}; 00123 00132 const char *set(const char *str, size_t len = 0); 00133 00140 void set(const String &str); 00141 00142 #ifdef HAVE_SNPRINTF 00143 00149 const char *set(size_t size, const char *format, ...); 00150 #endif 00151 00158 void copy(const String &str); 00159 00163 void init(void); 00164 00172 static char *getSpace(size_t size); 00173 00181 size_t setSize(size_t size); 00182 00188 void setLength(size_t len); 00189 00200 virtual int compare(const char *text, size_t len = 0, size_t index = 0) const; 00201 00211 size_t search(const char *text, size_t clen = 0, size_t offset = 0) const; 00212 00213 public: 00214 static const size_t npos; 00215 00216 typedef size_t size_type; 00217 00221 String(); 00222 00228 String(const String &original); 00229 00235 String(const char *str); 00236 00242 String(std::string str); 00243 00251 String(const String &str, size_t offset, size_t len = npos); 00252 00253 #ifdef HAVE_SNPRINTF 00254 00261 String(size_t count, const char *fmt, ...); 00262 #else 00263 00270 String(size_t count, const char *str); 00271 #endif 00272 00279 String(size_t count, const char fill = ' '); 00280 00284 virtual ~String(); 00285 00293 const char *getIndex(size_t index) const; 00294 00300 char *getText(void) const; 00301 00307 long getValue(long defvalue = 0l) const; 00308 00314 bool getBool(bool defbool = false) const; 00315 00321 const size_t getLength(void) const; 00322 00328 const size_t getSize(void) const; 00329 00335 bool isEmpty(void) const; 00336 00342 void resize(size_t size); 00343 00347 void clear(void); 00348 00354 char at(ssize_t offset) const; 00355 00364 unsigned count(const String &s, size_t offset = 0) const; 00365 00375 unsigned count(const char *s, size_t offset = 0, size_t len = 0) const; 00376 00384 String token(const char *delim = " \t\n\r", size_t offset = 0); 00385 00394 size_t find(const String &s, size_t offset = 0, unsigned instance = 1) const; 00395 00403 size_t rfind(const String &s, size_t offset = 0) const; 00404 00414 size_t find(const char *s, size_t offset = 0, size_t len = 0, unsigned count = 1) const; 00415 00424 size_t rfind(const char *s, size_t offset = 0, size_t len = 0) const; 00425 00431 inline void trim(const char *cs) 00432 {setLength(strtrim(cs, getText(), getLength()));}; 00433 00439 inline void chop(const char *cs) 00440 {setLength(strchop(cs, getText(), getLength()));}; 00441 00447 void strip(const char *cs); 00448 00454 inline void chop(size_t chars) 00455 {erase(0, chars);}; 00456 00462 void trim(size_t count); 00463 00470 void erase(size_t start, size_t len = npos); 00471 00479 void insert(size_t start, const char *text, size_t len = 0); 00480 00487 void insert(size_t start, const String &str); 00488 00498 void replace(size_t start, size_t len, const char *text, size_t count = 0); 00499 00508 void replace(size_t start, size_t len, const String &s); 00509 00519 inline size_t find(unsigned instance, const char *cp, size_t offset = 0, size_t len = 0) const 00520 {return find(cp, offset, len, instance);}; 00521 00530 inline size_t find(unsigned instance, const String &s, size_t offset = 0) const 00531 {return find(s, offset, instance);}; 00532 00541 inline String substr(size_t start, size_t len) const 00542 {return String(*this, start, len);}; 00543 00551 inline const char *(index)(size_t ind) const 00552 {return getIndex(ind);}; 00553 00558 inline void compact(void) 00559 {resize(getLength() + 1);}; 00560 00566 inline char *c_str(void) const 00567 {return getText();}; 00568 00574 inline operator char *() const 00575 {return getText();}; 00576 00582 inline bool operator!(void) const 00583 {return isEmpty();}; 00584 00590 inline char *text(void) const 00591 {return getText();}; 00592 00598 inline char *data(void) const 00599 {return getText();}; 00600 00606 inline size_t length(void) const 00607 {return strlen(getText());}; 00608 00614 inline size_t size(void) const 00615 {return getLength();}; 00616 00622 inline size_t capacity(void) const 00623 {return getSize();}; 00624 00628 bool empty(void) const 00629 {return isEmpty();}; 00630 00637 void append(const char *str, size_t count = 0); 00638 00639 #ifdef HAVE_SNPRINTF 00640 00646 void append(size_t size, const char *format, ...); 00647 #endif 00648 00656 void append(const char *str, size_t offset, size_t count); 00657 00663 void add(char c); 00664 00670 void append(const String &str); 00671 00677 inline const char operator[](unsigned ind) const 00678 {return at(ind);}; 00679 00683 inline const char *operator =(const char *str) 00684 {return set(str);}; 00685 00689 friend __EXPORT String operator+(const String &s1, const String &s2); 00690 00691 friend __EXPORT String operator+(const String &s1, const char *s2); 00692 00693 friend __EXPORT String operator+(const char *s1, const String &s2); 00694 00695 friend __EXPORT String operator+(const String &s1, const char c2); 00696 00697 friend __EXPORT String operator+(const char c1, const String &s2); 00698 00702 inline String &operator+=(const String &str) 00703 {append(str); return *this;}; 00704 00708 inline String &operator+=(char c) 00709 {add(c); return *this;}; 00710 00714 inline String &operator+=(const char *str) 00715 {append(str); return *this;}; 00716 00720 inline String &operator+=(const std::string &str) 00721 {append(str.c_str()); return *this;}; 00722 00733 friend __EXPORT std::istream &getline(std::istream &is, String &str, char delim = '\n', size_t size = 0); 00734 00739 friend __EXPORT std::ostream &operator<<(std::ostream &os, const String &str); 00740 00744 inline friend std::istream &operator>>(std::istream &is, String &str) 00745 {return getline(is, str);}; 00746 00747 #ifdef HAVE_SNPRINTF 00748 00756 friend __EXPORT int strprintf(String &str, size_t size, const char *fmt, ...); 00757 #endif 00758 00759 bool operator<(const String &str) const; 00760 bool operator<(const char *str) const; 00761 bool operator>(const String &str) const; 00762 bool operator>(const char *str) const; 00763 bool operator<=(const String &str) const; 00764 bool operator<=(const char *str) const; 00765 bool operator>=(const String &str) const; 00766 bool operator>=(const char *str) const; 00767 bool operator==(const String &str) const; 00768 bool operator==(const char *str) const; 00769 bool operator!=(const String &str) const; 00770 bool operator!=(const char *str) const; 00771 00772 #ifdef HAVE_SNPRINTF 00773 00777 inline String &operator+=(int i) 00778 {append(16, "%d", i); return *this;}; 00779 00780 inline String &operator+=(unsigned int i) 00781 {append(16, "%u", i); return *this;}; 00782 00783 inline String &operator+=(long l) 00784 {append(16, "%l", l); return *this;}; 00785 00786 inline String &operator+=(unsigned long l) 00787 {append(16, "%ul", l); return *this;}; 00788 00789 inline String &operator+=(float f) 00790 {append(32, "%f", f); return *this;}; 00791 00792 inline String &operator+=(double d) 00793 {append(32, "%f", d); return *this;}; 00794 00795 inline String &operator+=(short s) 00796 {append(8, "%hd", s); return *this;}; 00797 00798 inline String &operator+=(unsigned short s) 00799 {append(8, "%hu", s); return *this;}; 00800 00801 00805 inline String &operator=(int i) 00806 {set(16, "%d", i); return *this;}; 00807 00808 inline String &operator=(unsigned int i) 00809 {set(16, "%u", i); return *this;}; 00810 00811 inline String &operator=(long l) 00812 {set(16, "%l", l); return *this;}; 00813 00814 inline String &operator=(unsigned long l) 00815 {set(16, "%ul", l); return *this;}; 00816 00817 inline String &operator=(float f) 00818 {set(32, "%f", f); return *this;}; 00819 00820 inline String &operator=(double d) 00821 {set(32, "%f", d); return *this;}; 00822 00823 inline String &operator=(short s) 00824 {set(8, "%hd", s); return *this;}; 00825 00826 inline String &operator=(unsigned short s) 00827 {set(8, "%hu", s); return *this;}; 00828 #endif 00829 00830 inline String &operator=(const String &original) 00831 {copy(original); return *this;}; 00832 00836 bool operator*=(const String &str) const; 00837 00841 bool operator*=(const char *str) const; 00842 }; 00843 00844 class __EXPORT SString : public String, protected std::streambuf, public std::ostream 00845 { 00846 protected: 00852 int overflow(int c); 00853 00854 public: 00858 SString(); 00859 00863 SString(const SString &from); 00864 00868 ~SString(); 00869 }; 00870 00880 class __EXPORT StringObject 00881 { 00882 public: 00886 void *operator new(size_t size) NEW_THROWS; 00887 00891 void operator delete(void *obj); 00892 }; 00893 00894 #ifdef CCXX_NAMESPACES 00895 } 00896 #endif 00897 00898 #endif