00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00039 #ifndef BLOCXX_STRING_HPP_INCLUDE_GUARD_
00040 #define BLOCXX_STRING_HPP_INCLUDE_GUARD_
00041 #include "blocxx/BLOCXX_config.h"
00042 #include "blocxx/Types.hpp"
00043 #include "blocxx/COWIntrusiveReference.hpp"
00044 #include "blocxx/CommonFwd.hpp"
00045 #include "blocxx/Exception.hpp"
00046 #include <iosfwd>
00047 #include <string>
00048
00049 namespace BLOCXX_NAMESPACE
00050 {
00051
00052 BLOCXX_DECLARE_APIEXCEPTION(StringConversion, BLOCXX_COMMON_API);
00053
00066 class BLOCXX_COMMON_API String
00067 {
00068 public:
00069 class ByteBuf;
00073 String();
00080 explicit String(Int32 val);
00087 explicit String(UInt32 val);
00088
00089 #if defined(BLOCXX_INT32_IS_INT) && defined(BLOCXX_INT64_IS_LONG_LONG)
00090
00096 explicit String(long val);
00103 explicit String(unsigned long val);
00104 #endif
00105
00111 explicit String(Int64 val);
00118 explicit String(UInt64 val);
00125 explicit String(Real32 val);
00132 explicit String(Real64 val);
00138 String(const char* str);
00145 explicit String(const Char16Array& ra) BLOCXX_DEPRECATED;
00152 explicit String(Bool parm) BLOCXX_DEPRECATED;
00159 explicit String(const Char16& parm) BLOCXX_DEPRECATED;
00165 explicit String(const std::string& str);
00166
00167 enum ETakeOwnershipFlag
00168 {
00169 E_TAKE_OWNERSHIP
00170 };
00182 explicit String(ETakeOwnershipFlag, char* allocatedMemory, size_t len);
00191 explicit String(const char* str, size_t len);
00199 String(const String& arg);
00204 explicit String(char c);
00208 ~String();
00212 void swap(String& x);
00219 char* allocateCString() const;
00223 size_t length() const;
00227 size_t size() const { return length(); }
00233 size_t UTF8Length() const;
00237 bool empty() const { return length() == 0; }
00246 int format(const char* fmt, ...);
00247 enum EReturnDelimitersFlag
00248 {
00249 E_DISCARD_TOKENS,
00250 E_RETURN_TOKENS,
00251 E_DISCARD_DELIMITERS,
00252 E_RETURN_DELIMITERS
00253 };
00254 enum EEmptyTokenReturnFlag
00255 {
00256 E_SKIP_EMPTY_TOKENS,
00257 E_RETURN_EMPTY_TOKENS
00258 };
00272 StringArray tokenize(const char* delims = " \n\r\t\v",
00273 EReturnDelimitersFlag returnDelimitersAsTokens = E_DISCARD_DELIMITERS,
00274 EEmptyTokenReturnFlag returnEmptyTokens = E_SKIP_EMPTY_TOKENS ) const;
00279 const char* c_str() const;
00284 BLOCXX_DEPRECATED const char* getBytes() const { return c_str(); }
00291 char charAt(size_t ndx) const;
00299 int compareTo(const String& arg) const;
00307 int compareTo(const char* arg) const;
00315 int compareToIgnoreCase(const String& arg) const;
00323 int compareToIgnoreCase(const char* arg) const;
00329 String& concat(const char* arg);
00330
00336 String& concat(const String& arg)
00337 {
00338 return concat(arg.c_str());
00339 }
00340
00346 String& concat(char arg);
00347 enum EIgnoreCaseFlag
00348 {
00349 E_CASE_SENSITIVE,
00350 E_CASE_INSENSITIVE
00351 };
00360 bool endsWith(const char* arg, EIgnoreCaseFlag ignoreCase = E_CASE_SENSITIVE) const;
00361
00371 bool endsWith(const String& arg, EIgnoreCaseFlag ignoreCase = E_CASE_SENSITIVE) const
00372 {
00373 return endsWith(arg.c_str(), ignoreCase);
00374 }
00375
00382 bool endsWith(char arg) const;
00383
00391 bool equals(const String& arg) const;
00399 bool equals(const char* arg) const;
00408 bool equalsIgnoreCase(const String& arg) const;
00417 bool equalsIgnoreCase(const char* arg) const;
00421 UInt32 hashCode() const;
00430 size_t indexOf(char ch, size_t fromIndex=0) const;
00438 size_t indexOf(const char* arg, size_t fromIndex=0) const;
00446 size_t indexOf(const String& arg, size_t fromIndex=0) const
00447 {
00448 return indexOf(arg.c_str(), fromIndex);
00449 }
00450
00459 size_t lastIndexOf(char ch, size_t fromIndex=npos) const;
00468 size_t lastIndexOf(const char* arg, size_t fromIndex=npos) const;
00477 size_t lastIndexOf(const String& arg, size_t fromIndex=npos) const
00478 {
00479 return lastIndexOf(arg.c_str(), fromIndex);
00480 }
00481
00490 bool startsWith(const char* arg, EIgnoreCaseFlag ignoreCase = E_CASE_SENSITIVE) const;
00499 bool startsWith(const String& arg, EIgnoreCaseFlag ignoreCase = E_CASE_SENSITIVE) const
00500 {
00501 return startsWith(arg.c_str(), ignoreCase);
00502 }
00509 bool startsWith(char arg) const;
00510
00519 String substring(size_t beginIndex,
00520 size_t length=npos) const;
00525 bool isSpaces() const;
00531 String& toLowerCase();
00537 String& toUpperCase();
00544 String& ltrim();
00551 String& rtrim();
00558 String& trim();
00564 String& erase();
00565
00571 String& erase( size_t idx, size_t len = npos );
00578 String& operator= (const String & arg);
00586 const char& operator[] (size_t ndx) const;
00587 char& operator[] (size_t ndx);
00594 String& operator+= (const String& arg) { return concat(arg); }
00601 String& operator+= (const char* arg) { return concat(arg); }
00608 String& operator+= (char arg) { return concat(arg); }
00615 void readObject(std::streambuf & istrm);
00621 void writeObject(std::streambuf & ostrm) const;
00625 String toString() const;
00631 Char16 toChar16() const BLOCXX_DEPRECATED;
00636 Real32 toReal32() const;
00641 Real64 toReal64() const;
00647 bool toBool() const;
00652 UInt8 toUInt8(int base=10) const;
00657 Int8 toInt8(int base=10) const;
00662 UInt16 toUInt16(int base=10) const;
00667 Int16 toInt16(int base=10) const;
00672 UInt32 toUInt32(int base=10) const;
00677 Int32 toInt32(int base=10) const;
00682 UInt64 toUInt64(int base=10) const;
00687 Int64 toInt64(int base=10) const;
00692 unsigned int toUnsignedInt(int base=10) const;
00697 int toInt(int base=10) const;
00708 static unsigned long long int strtoull(const char* nptr, char** endptr,
00709 int base);
00720 static long long int strtoll(const char* nptr, char** endptr, int base);
00728 static const char* strchr(const char* theStr, int c);
00737 static String getLine(std::istream& istr);
00738
00739 #if defined(BLOCXX_AIX)
00740 static const size_t npos;
00741 #else
00742 static const size_t npos = size_t(~0);
00743 #endif // BLOCXX_AIX
00744
00745 #ifdef BLOCXX_WIN32
00746 #pragma warning (push)
00747 #pragma warning (disable: 4251)
00748 #endif
00749
00750 typedef COWIntrusiveReference<ByteBuf> buf_t;
00751 private:
00752 buf_t m_buf;
00753
00754 #ifdef BLOCXX_WIN32
00755 #pragma warning (pop)
00756 #endif
00757
00758 };
00759 BLOCXX_EXPORT_TEMPLATE(BLOCXX_COMMON_API, Array, String);
00760 BLOCXX_EXPORT_TEMPLATE(BLOCXX_COMMON_API, Enumeration, String);
00761
00762 BLOCXX_COMMON_API std::ostream& operator<< (std::ostream& ostr, const String& arg);
00763 BLOCXX_COMMON_API String operator + (const String& s1, const String& s2);
00764 BLOCXX_COMMON_API String operator + (const char* p, const String& s);
00765 BLOCXX_COMMON_API String operator + (const String& s, const char* p);
00766 BLOCXX_COMMON_API String operator + (char c, const String& s);
00767 BLOCXX_COMMON_API String operator + (const String& s, char c);
00768 inline bool
00769 operator == (const String& s1, const String& s2)
00770 {
00771 return (s1.compareTo(s2) == 0);
00772 }
00773 inline bool
00774 operator == (const String& s, const char* p)
00775 {
00776 return (s.compareTo(p) == 0);
00777 }
00778 inline bool
00779 operator == (const char* p, const String& s)
00780 {
00781 return (s.compareTo(p) == 0);
00782 }
00783 inline bool
00784 operator != (const String& s1, const String& s2)
00785 {
00786 return (s1.compareTo(s2) != 0);
00787 }
00788 inline bool
00789 operator != (const String& s, const char* p)
00790 {
00791 return (s.compareTo(p) != 0);
00792 }
00793 inline bool
00794 operator != (const char* p, const String& s)
00795 {
00796 return (s.compareTo(p) != 0);
00797 }
00798 inline bool
00799 operator < (const String& s1, const String& s2)
00800 {
00801 return (s1.compareTo(s2) < 0);
00802 }
00803 inline bool
00804 operator < (const String& s, const char* p)
00805 {
00806 return (s.compareTo(p) < 0);
00807 }
00808 inline bool
00809 operator < (const char* p, const String& s)
00810 {
00811 return (String(p).compareTo(s) < 0);
00812 }
00813 inline bool
00814 operator <= (const String& s1, const String& s2)
00815 {
00816 return (s1.compareTo(s2) <= 0);
00817 }
00818 inline bool
00819 operator <= (const String& s, const char* p)
00820 {
00821 return (s.compareTo(p) <= 0);
00822 }
00823 inline bool
00824 operator <= (const char* p, const String& s)
00825 {
00826 return (String(p).compareTo(s) <= 0);
00827 }
00828 inline bool
00829 operator > (const String& s1, const String& s2)
00830 {
00831 return (s1.compareTo(s2) > 0);
00832 }
00833 inline bool
00834 operator > (const String& s, const char* p)
00835 {
00836 return (s.compareTo(p) > 0);
00837 }
00838 inline bool
00839 operator > (const char* p, const String& s)
00840 {
00841 return (String(p).compareTo(s) > 0);
00842 }
00843 inline bool
00844 operator >= (const String& s1, const String& s2)
00845 {
00846 return (s1.compareTo(s2) >= 0);
00847 }
00848 inline bool
00849 operator >= (const String& s, const char* p)
00850 {
00851 return (s.compareTo(p) >= 0);
00852 }
00853 inline bool
00854 operator >= (const char* p, const String& s)
00855 {
00856 return (String(p).compareTo(s) >= 0);
00857 }
00858
00859 }
00860
00861 #endif