commoncpp/apidocs/String_8h_09_09_source.html

 /* ---------------------------------------------------------------------------
    commonc++ - A C++ Common Class Library
    Copyright (C) 2005-2014  Mark A Lindner

    This file is part of commonc++.

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    ---------------------------------------------------------------------------
 */

 #ifndef __ccxx_String_hxx
 #define __ccxx_String_hxx

 #include <commonc++/Common.h++>
 #include <commonc++/AtomicCounter.h++>
 #include <commonc++/Char.h++>
 #include <commonc++/CharRef.h++>
 #include <commonc++/CString.h++>
 #include <commonc++/EncodingException.h++>
 #include <commonc++/Hash.h++>
 #include <commonc++/NullPointerException.h++>
 #include <commonc++/OutOfBoundsException.h++>

 #include <string>
 #include <vector>
 #include <cerrno>
 #include <iosfwd>

 namespace ccxx {

 class StringVec;

 class COMMONCPP_API String
 {
  public:

   typedef char16_t value_type;
   typedef const char16_t* const_iterator;

   String();

   String(const String& other);

   String(char16_t* str, uint_t offset = 0, uint_t count = 0, bool copy = true);

   String(const char16_t* str, uint_t offset = 0, uint_t count = 0);

   String(const wchar_t* str);

   String(const char* str, uint_t offset = 0, uint_t count = 0);

   ~String();

   bool endsWith(const String& str, bool ignoreCase = false) const;

   bool endsWith(const Char& c, bool ignoreCase = false) const;

   bool endsWithAnyOf(const String& chars, bool ignoreCase = false) const;

   bool startsWith(const String& str, bool ignoreCase = false) const;

   bool startsWith(const Char& c, bool ignoreCase = false) const;

   bool startsWithAnyOf(const String& chars, bool ignoreCase = false) const;

   uint_t getLength() const;

   inline uint_t length() const
   { return(getLength()); }

   void setLength(uint_t length);

   void reserve(uint_t capacity);

   uint_t getCapacity() const;

   void compact();

   inline String& clear()
   {
     setLength(0);
     return(*this);
   }

   bool isEmpty() const;

   bool isNull() const;

   bool isInteger() const;

   bool isAlphaNumeric() const;

   int compareTo(const String& other, bool ignoreCase = false) const;

   String& trim(const String &chars = whitespaceChars, bool begin = true,
                bool end = true);

   inline String& trimBegin(const String& chars = whitespaceChars)
   { return(trim(chars, true, false)); }

   inline String& trimEnd(const String& chars = whitespaceChars)
   { return(trim(chars, false, true)); }

   String& chop(const Char& c);

   String& reverseChop(const Char& c);

   String& replace(const Char& a, const Char& b);

   String& replace(const String& a, const String& b);

   String& insert(const Char& c, uint_t index = 0);

   String& insert(const String& str, uint_t index = 0, uint_t length = 0);

   String& insert(const char16_t* str, uint_t index = 0, uint_t count = 0);

   inline String& insert(const wchar_t* str, uint_t index = 0, uint_t count = 0)
   { return(insert(String(str), index, count)); }

   inline String& insert(const char* str, uint_t index = 0, uint_t count = 0)
   { return(insert(String(str), index, count)); }

   String& append(bool v);

   inline String& append(char c)
   { return(append(Char(c))); }

   inline String& append(char16_t c)
   { return(append(Char(c))); }

   String& append(int val);

   String& append(int val, uint_t base);

   String& append(uint_t val);

   String& append(uint_t val, uint_t base);

   String& append(const int64_t& val);

   String& append(const double& val, uint_t precision = 6);

   String& append(const uint64_t& val);

   inline String& append(const Char& c)
   { return(insert(c, END)); }

   inline String& append(const String& str, uint_t count = 0)
   { return(insert(str, END, count)); }

   inline String& append(const char16_t* str, uint_t count = 0)
   { return(insert(str, END, count)); }

   inline String& append(const char* str, uint_t count = 0)
   { return(insert(String(str), END, count)); }

   inline String& append(const wchar_t* str, uint_t count = 0)
   { return(insert(str, END, count)); }

   inline String& prepend(char c)
   { return(insert(Char(c), 0)); }

   inline String& prepend(char16_t c)
   { return(insert(Char(c), 0)); }

   inline String& prepend(const Char& c)
   { return(insert(c, 0)); }

   inline String& prepend(const String& str, uint_t count = 0)
   { return(insert(str, 0, count)); }

   inline String& prepend(const char16_t* str, uint_t count = 0)
   { return(insert(str, 0, count)); }

   inline String& prepend(const char* str, uint_t count = 0)
   { return(insert(String(str), 0, count)); }

   inline String& prepend(const wchar_t* str, uint_t count = 0)
   { return(insert(str, 0, count)); }

   String& remove(uint_t fromIndex, uint_t toIndex = END);

   Char charAt(uint_t index) const;

   String& setCharAt(uint_t index, const Char& c);

   uint_t hash(uint_t modulo = 256) const;

   String substring(uint_t fromIndex, uint_t toIndex = END) const;

   int indexOf(const Char& c, uint_t fromIndex = 0) const;

   inline int indexOf(const char* str, uint_t fromIndex = 0) const
   { return(indexOf(String(str), fromIndex)); }

   int indexOfAnyOf(const String& chars, uint_t fromIndex = 0) const;

   int indexOf(const String& str, uint_t fromIndex = 0) const;

   int lastIndexOf(const Char& c, uint_t fromIndex = END) const;

   int lastIndexOfAnyOf(const String& chars, uint_t fromIndex = END) const;

   int lastIndexOf(const String& str, uint_t fromIndex = END) const;

   inline bool contains(const Char& c) const
   { return(indexOf(c) >= 0); }

   inline bool contains(const String& str) const
   { return(indexOf(str) >= 0); }

   inline bool containsAnyOf(const char* chars) const
   { return(indexOfAnyOf(chars) >= 0); }

   String nextToken(uint_t& fromIndex, const String& delim = whitespaceChars)
     const;

   uint_t split(StringVec& tokens, const String& delim = whitespaceChars,
                uint_t limit = 0) const;

   String& toLowerCase();

   String& toUpperCase();

   String& fill(const Char& c, uint_t count);

   String& pad(const Char& c, uint_t count);

   bool toBool(uint_t index = 0) const;

   int toInt(uint_t index = 0, uint_t base = 10) const;

   uint_t toUInt(uint_t index = 0, uint_t base = 10) const;

   int64_t toInt64(uint_t index = 0, uint_t base = 10) const;

   uint64_t toUInt64(uint_t index = 0, uint_t base = 10) const;

   float toFloat(uint_t index = 0) const;

   double toDouble(uint_t index = 0) const;

   operator const void*() const;

   const char16_t* data() const;

   CString toUTF8() const;

   String& operator=(const char* other);

   String& operator=(const wchar_t* other);

   String& operator=(const String& other);

   inline String& operator=(const std::string& other)
   { return(operator=(other.c_str())); }

   CharRef operator[](int index);

   const Char operator[](int index) const;

   const_iterator begin() const;

   const_iterator end() const;

   inline String operator()(uint_t fromIndex, uint_t toIndex = END) const
   { return(substring(fromIndex, toIndex)); }

   inline bool operator!() const
   { return(isNull()); }

   inline String& operator+=(char c)
   { return(append(c)); }

   inline String& operator+=(char16_t c)
   { return(append(c)); }

   inline String& operator+=(const Char& c)
   { return(append(c)); }

   inline String& operator+=(const char* str)
   { return(append(str)); }

   inline String& operator+=(const String& str)
   { return(append(str)); }

   inline String& operator+=(bool val)
   { return(append(val)); }

   inline String& operator+=(int val)
   { return(append(val)); }

   inline String& operator+=(uint_t val)
   { return(append(val)); }

   inline String& operator+=(double val)
   { return(append(val)); }

   inline String& operator+=(int64_t val)
   { return(append(val)); }

   inline String& operator+=(uint64_t val)
   { return(append(val)); }

   inline String& operator<<(const char* str)
   { return(append(str)); }

   inline String& operator<<(const wchar_t* str)
   { return(append(str)); }

   inline String& operator<<(const String& str)
   { return(append(str)); }

   inline String& operator<<(bool val)
   { return(append(val)); }

   inline String& operator<<(char c)
   { return(append(c)); }

   inline String& operator<<(char16_t c)
   { return(append(c)); }

   inline String& operator<<(const Char& c)
   { return(append(c)); }

   inline String& operator<<(int val)
   { return(append(val)); }

   inline String& operator<<(uint_t val)
   { return(append(val)); }

   inline String& operator<<(const int64_t& val)
   { return(append(val)); }

   inline String& operator<<(const uint64_t& val)
   { return(append(val)); }

   inline String& operator<<(const double& val)
   { return(append(val)); }

   inline String& operator^=(char c)
   { return(prepend(c)); }

   inline String& operator^=(char16_t c)
   { return(prepend(c)); }

   inline String& operator^=(const Char& c)
   { return(prepend(c)); }

   inline String& operator^=(const char* str)
   { return(prepend(str)); }

   inline String& operator^=(const wchar_t* str)
   { return(prepend(str)); }

   inline String& operator^=(const String& str)
   { return(prepend(str)); }

   String operator+(const String& str);
   String operator+(const char* str);
   String operator+(const Char& c);

   void write(std::ostream& stream) const;

   static const uint_t END;

   static const String null;

   static const String nullRep;

   static const String empty;

   static const String whitespaceChars;

  private:

   class StringBuf;

   StringBuf* _buf;

   void _insert(const char16_t* str, uint_t length, uint_t index, uint_t count);
   void _release();
   void _makeCopy(uint_t size, bool unshareable = false);
   char16_t* _makeGap(uint_t index, uint_t gaplen);
   void _fromUTF8(const char* str, uint_t len, uint_t offset);
   void _fromUTF32(const char32_t* str, uint_t len, uint_t offset);
   void _fromWChar(const wchar_t* str);
 };

 class StringVec : public std::vector<String>
 {
  public:

   StringVec()
   { }

   inline StringVec& operator<<(String s)
   { push_back(s); return(*this); }

   static const StringVec emptyVec;
 };

 inline bool operator==(const String& s1, const String& s2)
 { return(s1.compareTo(s2) == 0); }

 inline bool operator==(const String& s1, const char* s2)
 { return(s1.compareTo(s2) == 0); }

 inline bool operator==(const char* s1, const String& s2)
 { return(s2.compareTo(s1) == 0); }

 inline bool operator!=(const String& s1, const String& s2)
 { return(s1.compareTo(s2) != 0); }

 inline bool operator!=(const String& s1, const char* s2)
 { return(s1.compareTo(s2) != 0); }

 inline bool operator!=(const char* s1, const String& s2)
 { return(s2.compareTo(s1) != 0); }

 inline bool operator<(const String& s1, const String& s2)
 { return(s1.compareTo(s2) < 0); }

 inline bool operator<(const String& s1, const char* s2)
 { return(s1.compareTo(s2) < 0); }

 inline bool operator<(const char* s1, const String& s2)
 { return(s2.compareTo(s1) > 0); }

 inline bool operator>(const String& s1, const String& s2)
 { return(s1.compareTo(s2) > 0); }

 inline bool operator>(const String& s1, const char* s2)
 { return(s1.compareTo(s2) > 0); }

 inline bool operator>(const char* s1, const String& s2)
 { return(s2.compareTo(s1) < 0); }

 inline bool operator<=(const String& s1, const String& s2)
 { return(s1.compareTo(s2) <= 0); }

 inline bool operator<=(const String& s1, const char* s2)
 { return(s1.compareTo(s2) <= 0); }

 inline bool operator<=(const char* s1, const String& s2)
 { return(s2.compareTo(s1) > 0); }

 inline bool operator>=(const String& s1, const String& s2)
 { return(s1.compareTo(s2) >= 0); }

 inline bool operator>=(const String& s1, const char* s2)
 { return(s1.compareTo(s2) >= 0); }

 inline bool operator>=(const char* s1, const String& s2)
 { return(s2.compareTo(s1) < 0); }

 inline String operator+(const char* s1, const String& s2)
 { return(String(s1) + s2); }

 inline String operator+(const Char& c, const String& s)
 { String t; t += c; t += s; return(t); }

 inline std::ostream& operator<<(std::ostream& stream, const String& s)
 { s.write(stream); return(stream); }

 } // namespace ccxx

 #endif // __ccxx_String_hxx
ccxx::String::operator+=
String & operator+=(uint_t val)
Append a string representation of an unsigned integer value onto the end of the string.
Definition: String.h++:1015

CharRef.h++

Common.h++

ccxx::String::operator+=
String & operator+=(const String &str)
Append a string onto the end of this string.
Definition: String.h++:988

ccxx::StringVec::operator<<
StringVec & operator<<(String s)
Append operator.
Definition: String.h++:1167

ccxx::String::operator<<
String & operator<<(const double &val)
Append operator.
Definition: String.h++:1090

ccxx::String::containsAnyOf
bool containsAnyOf(const char *chars) const
Determine if the string contains any character in a given set of characters.
Definition: String.h++:745

Hash.h++

ccxx::StringVec
A String vector.
Definition: String.h++:1159

ccxx::String::prepend
String & prepend(char16_t c)
Prepend a character to the beginning of the string.
Definition: String.h++:544

ccxx::String::empty
static const String empty
The empty string.
Definition: String.h++:1134

ccxx::String::operator<<
String & operator<<(uint_t val)
Append operator.
Definition: String.h++:1078

ccxx::String::operator^=
String & operator^=(char16_t c)
Prepend operator.
Definition: String.h++:1098

ccxx::String::operator+=
String & operator+=(const Char &c)
Append a character onto the end of the string.
Definition: String.h++:972

ccxx::String::operator^=
String & operator^=(const char *str)
Prepend operator.
Definition: String.h++:1106

ccxx::String::append
String & append(const String &str, uint_t count=0)
Append a string to the end of the string.
Definition: String.h++:498

ccxx::operator+
const TimeSpan operator+(const TimeSpan &s1, const TimeSpan &s2)
Definition: TimeSpan.c++:362

ccxx::operator<=
bool operator<=(const Blob &b1, const Blob &b2)
Definition: Blob.h++:356

ccxx::String::operator<<
String & operator<<(const Char &c)
Append operator.
Definition: String.h++:1070

ccxx::String::operator+=
String & operator+=(double val)
Append a string representation of double-precision floating point value onto the end of the string...
Definition: String.h++:1024

Char.h++

ccxx::operator==
bool operator==(const Blob &b1, const Blob &b2)
Definition: Blob.h++:344

ccxx::String::operator+=
String & operator+=(uint64_t val)
Append a string representation of an unsigned long long (64-bit) integer onto the end of the string...
Definition: String.h++:1042

ccxx::char32_t
uint32_t char32_t
A UTF-32 character.
Definition: Common.h++:207

ccxx::uint_t
unsigned int uint_t
An alias for unsigned int.
Definition: Integers.h++:74

ccxx::String::operator!
bool operator!() const
Unary NOT operator.
Definition: String.h++:948

ccxx::String::operator+=
String & operator+=(const char *str)
Append a C string onto the end of this string.
Definition: String.h++:980

ccxx::String::append
String & append(char16_t c)
Append a UTF-16 character to the end of the string.
Definition: String.h++:418

ccxx::String::operator+=
String & operator+=(char16_t c)
Append a UTF-16 character onto the end of the string.
Definition: String.h++:964

ccxx::String::insert
String & insert(const wchar_t *str, uint_t index=0, uint_t count=0)
Insert a C wide string to this string.
Definition: String.h++:382

AtomicCounter.h++

ccxx::String::write
void write(std::ostream &stream) const
Write the string (in UTF-8 form) to a stream.
Definition: String.c++:1482

ccxx::String::compareTo
int compareTo(const String &other, bool ignoreCase=false) const
Compare the string to another.
Definition: String.c++:420

ccxx::String::END
static const uint_t END
A pseudo-index indicating the end of the string.
Definition: String.h++:1125

ccxx::String::contains
bool contains(const String &str) const
Determine if the string contains a given substring.
Definition: String.h++:734

ccxx::String::prepend
String & prepend(const char *str, uint_t count=0)
Prepend a string to the beginning of the string.
Definition: String.h++:582

ccxx::String::whitespaceChars
static const String whitespaceChars
The set of whitespace delimiter characters.
Definition: String.h++:1137

ccxx::String::prepend
String & prepend(char c)
Prepend a character to the beginning of the string.
Definition: String.h++:536

ccxx::String::operator+=
String & operator+=(int val)
Append a string representation of an integer value onto the end of the string.
Definition: String.h++:1006

ccxx::String::operator=
String & operator=(const std::string &other)
Assignment operator.
Definition: String.h++:893

ccxx::String::operator<<
String & operator<<(const uint64_t &val)
Append operator.
Definition: String.h++:1086

ccxx::String::append
String & append(const Char &c)
Append a character to the end of the string.
Definition: String.h++:488

ccxx::String::prepend
String & prepend(const wchar_t *str, uint_t count=0)
Prepend a wide string to the beginning of the string.
Definition: String.h++:592

ccxx::operator<<
std::ostream & operator<<(std::ostream &stream, const BitSet &bs)
Definition: BitSet.h++:383

ccxx::String::operator()
String operator()(uint_t fromIndex, uint_t toIndex=END) const
Substring operator.
Definition: String.h++:939

EncodingException.h++

ccxx::String::operator<<
String & operator<<(const int64_t &val)
Append operator.
Definition: String.h++:1082

ccxx::String::indexOf
int indexOf(const char *str, uint_t fromIndex=0) const
Find the first occurrence of a given string in this string.
Definition: String.h++:659

ccxx::String::value_type
char16_t value_type
Definition: String.h++:54

ccxx::String::operator^=
String & operator^=(const wchar_t *str)
Prepend operator.
Definition: String.h++:1110

ccxx::String::operator<<
String & operator<<(char c)
Append operator.
Definition: String.h++:1062

CString.h++

ccxx::String::clear
String & clear()
Clear the string.
Definition: String.h++:232

COMMONCPP_API
#define COMMONCPP_API
Definition: Common.h++:126

ccxx::String::operator<<
String & operator<<(int val)
Append operator.
Definition: String.h++:1074

ccxx::String::trimEnd
String & trimEnd(const String &chars=whitespaceChars)
Trim characters from the end of the string.
Definition: String.h++:306

ccxx::String::append
String & append(const wchar_t *str, uint_t count=0)
Append a wide string to the end of the string.
Definition: String.h++:528

ccxx::String::operator+=
String & operator+=(int64_t val)
Append a string representation of a long long (64-bit) integer onto the end of the string...
Definition: String.h++:1033

ccxx::String::prepend
String & prepend(const char16_t *str, uint_t count=0)
Prepend a string to the beginning of the string.
Definition: String.h++:572

ccxx::String::operator+=
String & operator+=(char c)
Append a character onto the end of the string.
Definition: String.h++:956

ccxx::operator!=
bool operator!=(const Blob &b1, const Blob &b2)
Definition: Blob.h++:347

NullPointerException.h++

ccxx::Char
A class representing a UTF-16 character.
Definition: Char.h++:33

ccxx::String
A flexible, reference counted, copy-on-write, thread-safe, nullable string.
Definition: String.h++:50

ccxx::CString
An implicitly shared, reference-counted container for an immutable, NUL-terminated C string...
Definition: CString.h++:39

ccxx::String::operator<<
String & operator<<(const String &str)
Append operator.
Definition: String.h++:1054

ccxx::StringVec::StringVec
StringVec()
Definition: String.h++:1163

ccxx::String::prepend
String & prepend(const String &str, uint_t count=0)
Prepend a string to the beginning of the string.
Definition: String.h++:562

ccxx::String::length
uint_t length() const
Get the length of the string.
Definition: String.h++:194

ccxx::operator<
bool operator<(const Blob &b1, const Blob &b2)
Definition: Blob.h++:350

ccxx::String::prepend
String & prepend(const Char &c)
Prepend a character to the beginning of the string.
Definition: String.h++:552

ccxx::char16_t
uint16_t char16_t
A UTF-16 character.
Definition: Common.h++:201

ccxx::String::append
String & append(char c)
Append a character to the end of the string.
Definition: String.h++:410

ccxx::StringVec::emptyVec
static const StringVec emptyVec
An empty StringVec.
Definition: String.h++:1171

ccxx::String::insert
String & insert(const char *str, uint_t index=0, uint_t count=0)
Insert a C string to this string.
Definition: String.h++:394

ccxx::String::append
String & append(const char16_t *str, uint_t count=0)
Append a UTF-16 character array to the end of the string.
Definition: String.h++:508

ccxx::String::operator+=
String & operator+=(bool val)
Append a string representation of a boolean value onto the end of the string.
Definition: String.h++:997

ccxx::operator>=
bool operator>=(const Blob &b1, const Blob &b2)
Definition: Blob.h++:359

ccxx::String::null
static const String null
The null string.
Definition: String.h++:1128

ccxx::String::operator^=
String & operator^=(const String &str)
Prepend operator.
Definition: String.h++:1114

ccxx::String::operator^=
String & operator^=(char c)
Prepend operator.
Definition: String.h++:1094

ccxx::String::trimBegin
String & trimBegin(const String &chars=whitespaceChars)
Trim characters from the beginning of the string.
Definition: String.h++:297

ccxx::String::append
String & append(const char *str, uint_t count=0)
Append a string to the end of the string.
Definition: String.h++:518

ccxx
Definition: AllocationMap.c++:25

ccxx::String::nullRep
static const String nullRep
The string representation of the null value.
Definition: String.h++:1131

ccxx::String::const_iterator
const char16_t * const_iterator
Definition: String.h++:55

ccxx::operator>
bool operator>(const Blob &b1, const Blob &b2)
Definition: Blob.h++:353

ccxx::String::operator<<
String & operator<<(char16_t c)
Append operator.
Definition: String.h++:1066

ccxx::String::operator<<
String & operator<<(const wchar_t *str)
Append operator.
Definition: String.h++:1050

OutOfBoundsException.h++

ccxx::String::contains
bool contains(const Char &c) const
Determine if the string contains a given character.
Definition: String.h++:724

ccxx::String::operator<<
String & operator<<(bool val)
Append operator.
Definition: String.h++:1058

ccxx::String::operator^=
String & operator^=(const Char &c)
Prepend operator.
Definition: String.h++:1102

ccxx::String::operator<<
String & operator<<(const char *str)
Append operator.
Definition: String.h++:1046