PTLib  Version 2.10.4
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
pstring.h
Go to the documentation of this file.
1 /*
2  * pstring.h
3  *
4  * Character string class.
5  *
6  * Portable Windows Library
7  *
8  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
9  *
10  * The contents of this file are subject to the Mozilla Public License
11  * Version 1.0 (the "License"); you may not use this file except in
12  * compliance with the License. You may obtain a copy of the License at
13  * http://www.mozilla.org/MPL/
14  *
15  * Software distributed under the License is distributed on an "AS IS"
16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
17  * the License for the specific language governing rights and limitations
18  * under the License.
19  *
20  * The Original Code is Portable Windows Library.
21  *
22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
23  *
24  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
25  * All Rights Reserved.
26  *
27  * Contributor(s): ______________________________________.
28  *
29  * $Revision: 26847 $
30  * $Author: rjongbloed $
31  * $Date: 2012-01-08 03:33:29 -0600 (Sun, 08 Jan 2012) $
32  */
33 
34 #ifndef PTLIB_STRING_H
35 #define PTLIB_STRING_H
36 
37 #ifdef P_USE_PRAGMA
38 #pragma interface
39 #endif
40 
41 #include <string>
42 #include <vector>
43 #include <ptlib/array.h>
44 
46 // PString class
47 
48 class PStringArray;
49 class PRegularExpression;
50 class PString;
51 
56  const char * fmt,
57  ...
58 );
59 
64  const char * fmt,
65  va_list arg
66 );
67 
68 #if (defined(_WIN32) || defined(_WIN32_WCE)) && (!defined(_NATIVE_WCHAR_T_DEFINED)) && (!defined(__MINGW32__))
69 PBASEARRAY(PWCharArray, unsigned short);
70 #else
71 PBASEARRAY(PWCharArray, wchar_t);
72 #endif
73 
108 class PString : public PCharArray
109 {
110  PCLASSINFO(PString, PCharArray);
111 
112 // using namespace std;
113 
114  public:
115  typedef const char * Initialiser;
116 
122  PINLINE PString();
123 
128  const PString & str
129  );
130 
134  const std::string & str
135  );
136 
145  PString(
146  const char * cstr
147  );
148 
153  PString(
154  const wchar_t * ustr
155  );
156 
170  PString(
171  const char * cstr,
172  PINDEX len
173  );
174 
185  PString(
186  const wchar_t * ustr,
187  PINDEX len
188  );
189 
200  PString(
201  const PWCharArray & ustr
202  );
203 
212  PString(
213  char ch
214  );
215 
220  PString(
221  short n
222  );
223 
228  PString(
229  unsigned short n
230  );
231 
236  PString(
237  int n
238  );
239 
244  PString(
245  unsigned int n
246  );
247 
252  PString(
253  long n
254  );
255 
260  PString(
261  unsigned long n
262  );
263 
268  PString(
269  PInt64 n
270  );
271 
276  PString(
277  PUInt64 n
278  );
279 
280 
282  Pascal, // Data is a length byte followed by characters.
283  Basic, // Data is two length bytes followed by characters.
284  Literal, // Data is C language style string with \\ escape codes.
285  Signed, // Convert a signed integer to a string.
286  Unsigned, // Convert an unsigned integer to a string.
287  Decimal, // Convert a real number to a string in decimal format.
288  Exponent, // Convert a real number to a string in exponent format.
289  Printf, // Formatted output, sprintf() style function.
291  };
292  /* Type of conversion to make in the conversion constructors.
293  */
294 
295  /* Contruct a new string converting from the spcified data source into
296  a string array.
297  */
298  PString(
299  ConversionType type,
300  const char * str,
301  ...
302  );
303  PString(
304  ConversionType type,
305  long value,
306  unsigned base = 10
307  );
308  PString(
309  ConversionType type,
310  double value,
311  unsigned places
312  );
313 
321  PString & operator=(
322  const PString & str
323  );
324 
333  const std::string & str
334  ) { return operator=(str.c_str()); }
335 
345  PString & operator=(
346  const char * cstr
347  );
348 
357  PString & operator=(
358  char ch
359  );
360 
365  PString & operator=(
366  short n
367  );
368 
373  PString & operator=(
374  unsigned short n
375  );
376 
381  PString & operator=(
382  int n
383  );
384 
389  PString & operator=(
390  unsigned int n
391  );
392 
397  PString & operator=(
398  long n
399  );
400 
405  PString & operator=(
406  unsigned long n
407  );
408 
413  PString & operator=(
414  PInt64 n
415  );
416 
421  PString & operator=(
422  PUInt64 n
423  );
424 
427  virtual PString & MakeEmpty();
428 
431  static PString Empty();
433 
440  virtual PObject * Clone() const;
441 
451  virtual Comparison Compare(
452  const PObject & obj
453  ) const;
454 
457  virtual void PrintOn(
458  ostream & strm
459  ) const;
460 
466  virtual void ReadFrom(
467  istream & strm
468  );
469 
483  virtual PINDEX HashFunction() const;
485 
500  virtual PBoolean SetSize(
501  PINDEX newSize
502  );
503 
512  virtual PBoolean IsEmpty() const;
513 
522  virtual PBoolean MakeUnique();
524 
525 
539 
548  PINLINE PINDEX GetLength() const;
549 
556  bool operator!() const;
558 
568  const PString & str
569  ) const;
570 
583  const char * cstr
584  ) const;
585 
598  char ch
599  ) const;
600 
612  friend PString operator+(
613  const char * cstr,
614  const PString & str
615  );
616 
628  friend PString operator+(
629  char ch,
630  const PString & str
631  );
632 
639  const PString & str
640  );
641 
652  const char * cstr
653  );
654 
665  char ch
666  );
667 
668 
676  const PString & str
677  ) const;
678 
696  const char * cstr
697  ) const;
698 
716  char ch
717  ) const;
718 
735  friend PString operator&(
736  const char * cstr,
737  const PString & str
738  );
739 
756  friend PString operator&(
757  char ch,
758  const PString & str
759  );
760 
767  const PString & str
768  );
769 
785  const char * cstr
786  );
787 
788 
804  char ch
805  );
807 
808 
816  bool operator*=(
817  const PString & str
818  ) const;
819 
827  bool operator==(
828  const PObject & str
829  ) const;
830 
838  bool operator!=(
839  const PObject & str
840  ) const;
841 
849  bool operator<(
850  const PObject & str
851  ) const;
852 
860  bool operator>(
861  const PObject & str
862  ) const;
863 
871  bool operator<=(
872  const PObject & str
873  ) const;
874 
882  bool operator>=(
883  const PObject & str
884  ) const;
885 
886 
897  bool operator*=(
898  const char * cstr
899  ) const;
900 
911  bool operator==(
912  const char * cstr
913  ) const;
914 
925  bool operator!=(
926  const char * cstr
927  ) const;
928 
939  bool operator<(
940  const char * cstr
941  ) const;
942 
953  bool operator>(
954  const char * cstr
955  ) const;
956 
967  bool operator<=(
968  const char * cstr
969  ) const;
970 
981  bool operator>=(
982  const char * cstr
983  ) const;
984 
997  const PString & str,
998  PINDEX count = P_MAX_INDEX,
999  PINDEX offset = 0
1000  ) const;
1001 
1014  const char * cstr,
1015  PINDEX count = P_MAX_INDEX,
1016  PINDEX offset = 0
1017  ) const;
1019 
1020 
1024  PINDEX Find(
1025  char ch,
1026  PINDEX offset = 0
1027  ) const;
1028 
1030  PINDEX Find(
1031  const PString & str,
1032  PINDEX offset = 0
1033  ) const;
1034 
1035  /* Locate the position within the string of the character or substring. The
1036  search will begin at the character offset provided.
1037 
1038  If <code>offset</code> is beyond the length of the string, then the
1039  function will always return P_MAX_INDEX.
1040 
1041  The matching will be for identical character or string. If a search
1042  ignoring case is required then the string should be converted to a
1043  PCaselessString before the search is made.
1044 
1045  @return
1046  position of character or substring in the string, or P_MAX_INDEX if the
1047  character or substring is not in the string.
1048  */
1049  PINDEX Find(
1050  const char * cstr,
1051  PINDEX offset = 0
1052  ) const;
1053 
1055  PINDEX FindLast(
1056  char ch,
1057  PINDEX offset = P_MAX_INDEX
1058  ) const;
1059 
1061  PINDEX FindLast(
1062  const PString & str,
1063  PINDEX offset = P_MAX_INDEX
1064  ) const;
1065 
1083  PINDEX FindLast(
1084  const char * cstr,
1085  PINDEX offset = P_MAX_INDEX
1086  ) const;
1087 
1089  PINDEX FindOneOf(
1090  const PString & set,
1091  PINDEX offset = 0
1092  ) const;
1093 
1108  PINDEX FindOneOf(
1109  const char * cset,
1110  PINDEX offset = 0
1111  ) const;
1112 
1114  PINDEX FindSpan(
1115  const PString & set,
1116  PINDEX offset = 0
1117  ) const;
1118 
1134  PINDEX FindSpan(
1135  const char * cset,
1136  PINDEX offset = 0
1137  ) const;
1138 
1149  PINDEX FindRegEx(
1150  const PRegularExpression & regex,
1151  PINDEX offset = 0
1152  ) const;
1153 
1165  const PRegularExpression & regex,
1166  PINDEX & pos,
1167  PINDEX & len,
1168  PINDEX offset = 0,
1169  PINDEX maxPos = P_MAX_INDEX
1170  ) const;
1171 
1172 
1176  const PRegularExpression & regex
1177  ) const;
1178 
1189  void Replace(
1190  const PString & target,
1191  const PString & subs,
1192  PBoolean all = false,
1193  PINDEX offset = 0
1194  );
1195 
1203  void Splice(
1204  const PString & str,
1205  PINDEX pos,
1206  PINDEX len = 0
1207  );
1208 
1216  void Splice(
1217  const char * cstr,
1218  PINDEX pos,
1219  PINDEX len = 0
1220  );
1221 
1228  void Delete(
1229  PINDEX start,
1230  PINDEX len
1231  );
1233 
1234 
1255  PINDEX start,
1256  PINDEX end
1257  ) const;
1258 
1273  PString Left(
1274  PINDEX len
1275  ) const;
1276 
1291  PString Right(
1292  PINDEX len
1293  ) const;
1294 
1311  PString Mid(
1312  PINDEX start,
1313  PINDEX len = P_MAX_INDEX
1314  ) const;
1315 
1316 
1324  PString LeftTrim() const;
1325 
1333  PString RightTrim() const;
1334 
1343  PString Trim() const;
1344 
1345 
1354  PString ToLower() const;
1355 
1364  PString ToUpper() const;
1365 
1366 
1369  const PString & separators,
1371  PBoolean onePerSeparator = true
1373  ) const;
1399  const char * cseparators,
1401  PBoolean onePerSeparator = true
1403  ) const;
1404 
1418  PStringArray Lines() const;
1420 
1437  PString & sprintf(
1438  const char * cfmt,
1439  ...
1440  );
1441 
1456  friend PString psprintf(
1457  const char * cfmt,
1458  ...
1459  );
1460 
1462  PString & vsprintf(
1463  const PString & fmt,
1464  va_list args
1465  );
1480  PString & vsprintf(
1481  const char * cfmt,
1482  va_list args
1483  );
1484 
1486  friend PString pvsprintf(
1487  const char * cfmt,
1488  va_list args
1489  );
1504  friend PString pvsprintf(
1505  const PString & fmt,
1506  va_list args
1507  );
1508 
1509 
1522  long AsInteger(
1523  unsigned base = 10
1524  ) const;
1537  DWORD AsUnsigned(
1538  unsigned base = 10
1539  ) const;
1553  PInt64 AsInt64(
1554  unsigned base = 10
1555  ) const;
1569  PUInt64 AsUnsigned64(
1570  unsigned base = 10
1571  ) const;
1572 
1583  double AsReal() const;
1584 
1588  PWCharArray AsUCS2() const;
1589 
1600  PBYTEArray ToPascal() const;
1601 
1610  PString ToLiteral() const;
1611 
1619  operator const unsigned char *() const;
1620 
1623  operator std::string () const
1624  { return std::string(theArray); }
1626 
1627 
1628  protected:
1629  void InternalFromUCS2(
1630  const wchar_t * ptr,
1631  PINDEX len
1632  );
1633  virtual Comparison InternalCompare(
1634  PINDEX offset, // Offset into string to compare.
1635  char c // Character to compare against.
1636  ) const;
1637  virtual Comparison InternalCompare(
1638  PINDEX offset, // Offset into string to compare.
1639  PINDEX length, // Number of characters to compare.
1640  const char * cstr // C string to compare against.
1641  ) const;
1642 
1643  /* Internal function to compare the current string value against the
1644  specified C string.
1645 
1646  @return
1647  relative rank of the two strings.
1648  */
1649  PString(int dummy, const PString * str);
1650 
1652 };
1653 
1654 
1655 inline ostream & operator<<(ostream & stream, const PString & string)
1656 {
1657  string.PrintOn(stream);
1658  return stream;
1659 }
1660 
1661 
1662 inline wostream & operator<<(wostream & stream, const PString & string)
1663 {
1664  return stream << (const char *)string;
1665 }
1666 
1667 
1668 #ifdef _WIN32
1669  class PWideString : public PWCharArray {
1670  PCLASSINFO(PWideString, PWCharArray);
1671 
1672  public:
1673  typedef const wchar_t * Initialiser;
1674 
1675  PWideString() { }
1676  PWideString(const PWCharArray & arr) : PWCharArray(arr) { }
1677  PWideString(const PString & str) : PWCharArray(str.AsUCS2()) { }
1678  PWideString(const char * str) : PWCharArray(PString(str).AsUCS2()) { }
1679  PWideString & operator=(const PWideString & str) { PWCharArray::operator=(str); return *this; }
1680  PWideString & operator=(const PString & str) { PWCharArray::operator=(str.AsUCS2()); return *this; }
1681  PWideString & operator=(const std::string & str) { PWCharArray::operator=(PString(str.c_str()).AsUCS2()); return *this; }
1682  PWideString & operator=(const char * str) { PWCharArray::operator=(PString(str).AsUCS2()); return *this; }
1683  friend inline ostream & operator<<(ostream & stream, const PWideString & string) { return stream << PString(string); }
1684 
1685  protected:
1686  PWideString(PContainerReference & reference) : PWCharArray(reference) { }
1687  };
1688 
1689  #ifdef UNICODE
1690  typedef PWideString PVarString;
1691  #else
1692  typedef PString PVarString;
1693  #endif
1694 #endif
1695 
1696 
1698 
1708 class PCaselessString : public PString
1709 {
1710  PCLASSINFO(PCaselessString, PString);
1711 
1712  public:
1715  PCaselessString();
1716 
1721  const char * cstr
1722  );
1723 
1729  const PString & str
1730  );
1731 
1732 
1736  const std::string & str
1737  ) : PString(str)
1738  { }
1739 
1748  const PString & str
1749  );
1750 
1759  const std::string & str
1760  ) { return operator=(str.c_str()); }
1761 
1772  const char * cstr
1773  );
1774 
1784  char ch
1785  );
1786 
1787 
1788  // Overrides from class PObject
1793  virtual PObject * Clone() const;
1794 
1795  protected:
1796  // Overrides from class PString
1797  virtual Comparison InternalCompare(
1798  PINDEX offset, // Offset into string to compare.
1799  char c // Character to compare against.
1800  ) const;
1801  virtual Comparison InternalCompare(
1802  PINDEX offset, // Offset into string to compare.
1803  PINDEX length, // Number of characters to compare.
1804  const char * cstr // C string to compare against.
1805  ) const;
1806  /* Internal function to compare the current string value against the
1807  specified C string.
1808 
1809  @return
1810  relative rank of the two strings or characters.
1811  */
1812 
1813  PCaselessString(int dummy, const PCaselessString * str);
1815 };
1816 
1817 
1819 
1833 template <class ParentString>
1834 class PConstantString : public ParentString
1835 {
1836  private:
1837  PContainerReference m_staticReference;
1838  public:
1839  PConstantString(typename ParentString::Initialiser init)
1840  : ParentString(m_staticReference)
1841  , m_staticReference((PINDEX)strlen(init)+1, true)
1842  {
1843  this->theArray = (char *)init;
1844  }
1845  ~PConstantString() { this->Destruct(); }
1846 
1847  virtual PBoolean SetSize(PINDEX) { return false; }
1849  virtual void DestroyReference() { }
1850 
1851  private:
1853  : ParentString(m_staticReference)
1854  , m_staticReference(0, true)
1855  { }
1856  void operator=(const PConstantString &) { }
1857 };
1858 
1859 
1862 
1865 
1866 
1867 
1869 
1870 class PStringStream;
1871 
1878 class PStringStream : public PString, public iostream
1879 {
1880  PCLASSINFO(PStringStream, PString);
1881 
1882  public:
1888  PStringStream();
1889 
1894  PStringStream(
1895  PINDEX fixedBufferSize
1896  );
1897 
1904  PStringStream(
1905  const PString & str
1906  );
1907 
1912  PStringStream(
1913  const char * cstr
1914  );
1915 
1918  virtual PString & MakeEmpty();
1919 
1932  const PStringStream & strm
1933  );
1934 
1947  const PString & str
1948  );
1949 
1966  const char * cstr
1967  );
1968 
1978  char ch
1979  );
1980 
1981 
1983  virtual ~PStringStream();
1984 
1985 
1986  protected:
1987  virtual void AssignContents(const PContainer & cont);
1988 
1989  private:
1990  PStringStream(int, const PStringStream &) : iostream(cout.rdbuf()) { }
1991 
1992  class Buffer : public streambuf {
1993  public:
1994  Buffer(PStringStream & str, PINDEX size);
1995  Buffer(const Buffer & sbuf);
1996  Buffer & operator=(const Buffer & sbuf);
1997  virtual int_type overflow(int_type = EOF);
1998  virtual int_type underflow();
1999  virtual int sync();
2000  virtual pos_type seekoff(off_type, ios_base::seekdir, ios_base::openmode = ios_base::in | ios_base::out);
2001  virtual pos_type seekpos(pos_type, ios_base::openmode = ios_base::in | ios_base::out);
2002  PStringStream & string;
2003  PBoolean fixedBufferSize;
2004  };
2005 };
2006 
2007 
2008 class PStringList;
2009 class PSortedStringList;
2010 
2023 #ifdef DOC_PLUS_PLUS
2024 class PStringArray : public PArray {
2025 #endif
2026  PDECLARE_ARRAY(PStringArray, PString);
2027  public:
2034  PStringArray(
2035  PINDEX count,
2036  char const * const * strarr,
2037  PBoolean caseless = false
2038  );
2041  PStringArray(
2042  const PString & str
2043  );
2046  PStringArray(
2047  const PStringList & list
2048  );
2051  PStringArray(
2052  const PSortedStringList & list
2053  );
2054 
2059  const std::vector<PString> & vec
2060  )
2061  {
2062  for (std::vector<PString>::const_iterator r = vec.begin(); r != vec.end(); ++r)
2063  AppendString(*r);
2064  }
2065 
2070  const std::vector<std::string> & vec
2071  )
2072  {
2073  for (std::vector<std::string>::const_iterator r = vec.begin(); r != vec.end(); ++r)
2074  AppendString(PString(*r));
2075  }
2076 
2080  template <typename stlContainer>
2082  const stlContainer & vec
2083  )
2084  {
2085  PStringArray list;
2086  for (typename stlContainer::const_iterator r = vec.begin(); r != vec.end(); ++r)
2087  list.AppendString(PString(*r));
2088  return list;
2089  }
2090 
2092 
2101  virtual void ReadFrom(
2102  istream &strm // Stream to read the objects contents from.
2103  );
2105 
2114  PINDEX GetStringsIndex(
2115  const PString & str
2116  ) const;
2117 
2119  PINDEX index
2120  ) const;
2121 
2129  PString & operator[](
2130  PINDEX index
2131  );
2132 
2135  PINDEX AppendString(
2136  const PString & str
2137  );
2138 
2144  PStringArray & operator +=(const PStringArray & array);
2145  PStringArray & operator +=(const PString & str);
2146 
2147 
2154  PStringArray operator + (const PStringArray & array);
2155  PStringArray operator + (const PString & str);
2156 
2164  char ** ToCharArray(
2165  PCharArray * storage = NULL
2166  ) const;
2168 };
2169 
2170 
2183 #ifdef DOC_PLUS_PLUS
2184 class PStringList : public PList {
2185 #endif
2186 PDECLARE_LIST(PStringList, PString);
2187  public:
2192  PStringList(
2193  PINDEX count,
2194  char const * const * strarr,
2195  PBoolean caseless = false
2196  );
2199  PStringList(
2200  const PString & str
2201  );
2204  PStringList(
2205  const PStringArray & array
2206  );
2209  PStringList(
2210  const PSortedStringList & list
2211  );
2213 
2222  virtual void ReadFrom(
2223  istream &strm // Stream to read the objects contents from.
2224  );
2226 
2231  PINDEX AppendString(
2232  const PString & str
2233  );
2234 
2237  PINDEX InsertString(
2238  const PString & before,
2239  const PString & str
2240  );
2241 
2245  PINDEX GetStringsIndex(
2246  const PString & str
2247  ) const;
2248 
2254  PStringList & operator +=(const PStringList & list);
2255  PStringList & operator +=(const PString & str);
2256 
2257 
2264  PStringList operator + (const PStringList & array);
2265  PStringList operator + (const PString & str);
2266 
2270  template <typename stlContainer>
2272  const stlContainer & vec
2273  )
2274  {
2275  PStringList list;
2276  for (typename stlContainer::const_iterator r = vec.begin(); r != vec.end(); ++r)
2277  list.AppendString(PString(*r));
2278  return list;
2279  }
2281 };
2282 
2283 
2295 #ifdef DOC_PLUS_PLUS
2297 #endif
2298 PDECLARE_SORTED_LIST(PSortedStringList, PString);
2299  public:
2305  PINDEX count,
2306  char const * const * strarr,
2307  PBoolean caseless = false
2308  );
2312  const PString & str
2313  );
2317  const PStringArray & array
2318  );
2322  const PStringList & list
2323  );
2325 
2334  virtual void ReadFrom(
2335  istream &strm // Stream to read the objects contents from.
2336  );
2338 
2344  PINDEX AppendString(
2345  const PString & str
2346  );
2347 
2351  PINDEX GetStringsIndex(
2352  const PString & str
2353  ) const;
2354 
2359  PINDEX GetNextStringsIndex(
2360  const PString & str
2361  ) const;
2363 
2364  protected:
2365  PINDEX InternalStringSelect(
2366  const char * str,
2367  PINDEX len,
2368  Element * thisElement,
2369  Element * & lastElement
2370  ) const;
2371 };
2372 
2373 
2390 #ifdef DOC_PLUS_PLUS
2391 class PStringSet : public PSet {
2392 #endif
2393 PDECLARE_SET(PStringSet, PString, true);
2394  public:
2399  PStringSet(
2400  PINDEX count,
2401  char const * const * strarr,
2402  PBoolean caseless = false
2403  );
2406  PStringSet(
2407  const PString & str
2408  );
2410 
2419  virtual void ReadFrom(
2420  istream &strm
2421  );
2423 
2427  void Include(
2428  const PString & key
2429  );
2432  const PString & key
2433  );
2435  void Exclude(
2436  const PString & key
2437  );
2440  const PString & key
2441  );
2443 };
2444 
2445 
2453 template <class K> class PStringDictionary : public PAbstractDictionary
2454 {
2456 
2457  public:
2467  : PAbstractDictionary() { }
2469 
2476  virtual PObject * Clone() const
2477  { return PNEW PStringDictionary(0, this); }
2479 
2494  const PString & operator[](const K & key) const
2495  { return (const PString &)GetRefAt(key); }
2496 
2510  PString operator()(const K & key, const char * dflt = NULL) const
2511  {
2512  PString * str = this->GetAt(key);
2513  return str != NULL ? *str : PString(dflt);
2514  }
2515 
2525  const K & key // Key to look for in the dictionary.
2526  ) const { return AbstractContains(key); }
2527 
2539  virtual PString * RemoveAt(
2540  const K & key // Key for position in dictionary to get object.
2541  ) {
2542  PString * s = GetAt(key); AbstractSetAt(key, NULL);
2543  return reference->deleteObjects ? (s ? (PString *)-1 : NULL) : s;
2544  }
2545 
2552  virtual PString * GetAt(
2553  const K & key // Key for position in dictionary to get object.
2554  ) const { return (PString *)AbstractGetAt(key); }
2555 
2565  PINDEX index, // Ordinal index in the dictionary.
2566  const PString & str // New string value to put into the dictionary.
2567  ) { return PAbstractDictionary::SetDataAt(index, PNEW PString(str)); }
2568 
2580  virtual PBoolean SetAt(
2581  const K & key, // Key for position in dictionary to add object.
2582  const PString & str // New string value to put into the dictionary.
2583  ) { return AbstractSetAt(key, PNEW PString(str)); }
2584 
2596  const K & GetKeyAt(PINDEX index) const
2597  { return (const K &)AbstractGetKeyAt(index); }
2598 
2610  PString & GetDataAt(PINDEX index) const
2611  { return (PString &)AbstractGetDataAt(index); }
2613 
2614  protected:
2615  PStringDictionary(int dummy, const PStringDictionary * c)
2616  : PAbstractDictionary(dummy, c) { }
2617 };
2618 
2619 
2634 #define PDECLARE_STRING_DICTIONARY(cls, K) \
2635  PDECLARE_CLASS(cls, PStringDictionary<K>) \
2636  protected: \
2637  cls(int dummy, const cls * c) \
2638  : PStringDictionary<K>(dummy, c) { } \
2639  public: \
2640  cls() \
2641  : PStringDictionary<K>() { } \
2642  virtual PObject * Clone() const \
2643  { return PNEW cls(0, this); } \
2644 
2645 
2658 #define PSTRING_DICTIONARY(cls, K) typedef PStringDictionary<K> cls
2659 
2660 
2675 #ifdef DOC_PLUS_PLUS
2677 #endif
2678 PDECLARE_STRING_DICTIONARY(POrdinalToString, POrdinalKey);
2679  public:
2682 
2683  struct Initialiser {
2685  PINDEX key;
2687  const char * value;
2688  };
2692  PINDEX count,
2693  const Initialiser * init
2694  );
2696 
2705  virtual void ReadFrom(
2706  istream &strm // Stream to read the objects contents from.
2707  );
2709 };
2710 
2722 #ifdef DOC_PLUS_PLUS
2724 #endif
2725 PDECLARE_ORDINAL_DICTIONARY(PStringToOrdinal, PString);
2726  public:
2729 
2730  struct Initialiser {
2732  const char * key;
2734  PINDEX value;
2735  };
2739  PINDEX count,
2740  const Initialiser * init,
2741  PBoolean caseless = false
2742  );
2744 
2753  virtual void ReadFrom(
2754  istream &strm // Stream to read the objects contents from.
2755  );
2757 };
2758 
2759 
2773 #ifdef DOC_PLUS_PLUS
2775 #endif
2776 PDECLARE_STRING_DICTIONARY(PStringToString, PString);
2777  public:
2780 
2781  struct Initialiser {
2783  const char * key;
2785  const char * value;
2786  };
2790  PINDEX count,
2791  const Initialiser * init,
2792  PBoolean caselessKeys = false,
2793  PBoolean caselessValues = false
2794  );
2796 
2805  virtual void ReadFrom(
2806  istream &strm // Stream to read the objects contents from.
2807  );
2809 
2822  char ** ToCharArray(
2823  bool withEqualSign,
2824  PCharArray * storage = NULL
2825  ) const;
2826 };
2827 
2828 
2836 {
2837  public:
2839  PStringOptions(const PStringToString & other) : PStringToString(other) { }
2840  PStringOptions & operator=(const PStringToString & other) { PStringToString::operator=(other); return *this; }
2841 
2843  bool Contains(const char * key ) const { PConstCaselessString k(key); return PStringToString::Contains(k); }
2844  bool Contains(const PString & key ) const { return PStringToString::Contains(PCaselessString(key)); }
2845  bool Contains(const PCaselessString & key ) const { return PStringToString::Contains(key); }
2846  bool Contains(const PCaselessString & (*key)()) const { return PStringToString::Contains(key()); }
2847 
2848  // Overide default PStringToString::SetAt() to make sure the key is caseless
2849  PString * GetAt(const char * key ) const { PConstCaselessString k(key); return PStringToString::GetAt(k); }
2850  PString * GetAt(const PString & key ) const { return PStringToString::GetAt(PCaselessString(key)); }
2851  PString * GetAt(const PCaselessString & key ) const { return PStringToString::GetAt(key); }
2852  PString * GetAt(const PCaselessString & (*key)()) const { return PStringToString::GetAt(key()); }
2853 
2854  // Overide default PStringToString::SetAt() to make sure the key is caseless
2855  PBoolean SetAt(const char * key, const PString & data) { PConstCaselessString k(key); return SetAt(k, data); }
2856  PBoolean SetAt(const PString & key, const PString & data) { return SetAt(PCaselessString(key), data); }
2857  PBoolean SetAt(const PCaselessString & key, const PString & data) { MakeUnique(); return PStringToString::SetAt(key, data); }
2858  PBoolean SetAt(const PCaselessString & (*key)(), const PString & data) { return SetAt(key(), data); }
2859 
2860  // Overide default PStringToString::RemoveAt() to make sure the key is caseless
2861  PString * RemoveAt(const char * key) { PConstCaselessString k(key); return RemoveAt(k); }
2862  PString * RemoveAt(const PString & key) { return RemoveAt(PCaselessString(key)); }
2864  PString * RemoveAt(const PCaselessString & (*key)()) { return RemoveAt(key()); }
2865 
2867  PString GetString(const char * key, const char * dflt = NULL) const { PConstCaselessString k(key); return GetString(k, dflt); }
2868  PString GetString(const PString & key, const char * dflt = NULL) const { return GetString(PCaselessString(key), dflt); }
2869  PString GetString(const PCaselessString & key, const char * dflt = NULL) const;
2870  PString GetString(const PCaselessString & (*key)(), const char * dflt = NULL) const { return GetString(key(), dflt); }
2871 
2873  bool SetString(const char * key, const PString & value) { return SetAt(key, value); }
2874  bool SetString(const PString & key, const PString & value) { return SetAt(key, value); }
2875  bool SetString(const PCaselessString & key, const PString & value) { return SetAt(key, value); }
2876  bool SetString(const PCaselessString & (*key)(), const PString & value) { return SetAt(key, value); }
2877 
2879  bool GetBoolean(const char * key, bool dflt = false) const { PConstCaselessString k(key); return GetBoolean(k, dflt); }
2880  bool GetBoolean(const PString & key, bool dflt = false) const { return GetBoolean(PCaselessString(key), dflt); }
2881  bool GetBoolean(const PCaselessString & key, bool dflt = false) const;
2882  bool GetBoolean(const PCaselessString & (*key)(), bool dflt = false) const { return GetBoolean(key(), dflt); }
2883 
2885  void SetBoolean(const char * key, bool value) { PConstCaselessString k(key); SetBoolean(k, value); }
2886  void SetBoolean(const PString & key, bool value) { SetBoolean(PCaselessString(key), value); }
2887  void SetBoolean(const PCaselessString & key, bool value) { SetAt(key, value ? "true" : "false"); }
2888  void SetBoolean(const PCaselessString & (*key)(), bool value) { SetBoolean(key(), value); }
2889 
2891  long GetInteger(const char * key, long dflt = 0) const { PConstCaselessString k(key); return GetInteger(k, dflt); }
2892  long GetInteger(const PString & key, long dflt = 0) const { return GetInteger(PCaselessString(key), dflt); }
2893  long GetInteger(const PCaselessString & key, long dflt = 0) const;
2894  long GetInteger(const PCaselessString & (*key)(), long dflt = 0) const { return GetInteger(key(), dflt); }
2895 
2897  void SetInteger(const char * key, long value) { PConstCaselessString k(key); SetInteger(k, value); }
2898  void SetInteger(const PString & key, long value) { SetInteger(PCaselessString(key), value); }
2899  void SetInteger(const PCaselessString & key, long value);
2900  void SetInteger(const PCaselessString & (*key)(), long value) { SetInteger(key(), value); }
2901 
2903  double GetReal(const char * key, double dflt = 0) const { PConstCaselessString k(key); return GetReal(k, dflt); }
2904  double GetReal(const PString & key, double dflt = 0) const { return GetReal(PCaselessString(key), dflt); }
2905  double GetReal(const PCaselessString & key, double dflt = 0) const;
2906  double GetReal(const PCaselessString & (*key)(), double dflt = 0) const { return GetReal(key(), dflt); }
2907 
2909  void SetReal(const char * key, double value, int decimals) { PConstCaselessString k(key); SetReal(k, value, decimals); }
2910  void SetReal(const PString & key, double value, int decimals) { SetReal(PCaselessString(key), value, decimals); }
2911  void SetReal(const PCaselessString & key, double value, int decimals);
2912  void SetReal(const PCaselessString & (*key)(), double value, int decimals) { SetReal(key(), value, decimals); }
2913 
2915  __inline bool Has(const char * key) const { return Contains(key); }
2916  __inline bool Has(const PString & key) const { return Contains(key); }
2917  __inline bool Has(const PCaselessString & key) const { return Contains(key); }
2918  __inline bool Has(const PCaselessString & (*key)()) const { return Contains(key); }
2919 
2921  __inline PString Get(const char * key, const char * dflt = NULL) const { return GetString(key, dflt); }
2922  __inline PString Get(const PString & key, const char * dflt = NULL) const { return GetString(key, dflt); }
2923  __inline PString Get(const PCaselessString & key, const char * dflt = NULL) const { return GetString(key, dflt); }
2924  __inline PString Get(const PCaselessString & (*key)(), const char * dflt = NULL) const { return GetString(key, dflt); }
2925  __inline PString Get(const char * key, const PString & dflt) const { return GetString(key, dflt); }
2926  __inline PString Get(const PString & key, const PString & dflt) const { return GetString(key, dflt); }
2927  __inline PString Get(const PCaselessString & key, const PString & dflt) const { return GetString(key, dflt); }
2928  __inline PString Get(const PCaselessString & (*key)(), const PString & dflt) const { return GetString(key, dflt); }
2929 
2931  __inline bool Set(const char * key, const PString & value) { return SetAt(key, value); }
2932  __inline bool Set(const PString & key, const PString & value) { return SetAt(key, value); }
2933  __inline bool Set(const PCaselessString & key, const PString & value) { return SetAt(key, value); }
2934  __inline bool Set(const PCaselessString & (*key)(), const PString & value) { return SetAt(key, value); }
2935 
2937  __inline void Remove(const char * key) { RemoveAt(key); }
2938  __inline void Remove(const PString & key) { RemoveAt(key); }
2939  __inline void Remove(const PCaselessString & key) { RemoveAt(key); }
2940  __inline void Remove(const PCaselessString & (*key)()) { RemoveAt(key); }
2941 };
2942 
2943 
2950 {
2951  PCLASSINFO(PRegularExpression, PObject);
2952 
2953  public:
2956 
2957  enum {
2967  };
2969  enum {
2979  };
2980 
2983 
2987  const PString & pattern,
2988  int flags = IgnoreCase
2989  );
2990 
2994  const char * cpattern,
2995  int flags = IgnoreCase
2996  );
2997 
3002  const PRegularExpression &
3003  );
3004 
3009  const PRegularExpression &
3010  );
3011 
3015 
3016 
3021  virtual void PrintOn(
3022  ostream & strm
3023  ) const;
3025 
3028 
3029  enum ErrorCodes {
3031  NoError = 0,
3034 
3035  // POSIX regcomp return error codes. (In the order listed in the standard.)
3060 
3061  /* Error codes we've added. */
3070  };
3071 
3077  ErrorCodes GetErrorCode() const;
3078 
3085  PString GetErrorText() const;
3086 
3088  const PString & GetPattern() const { return patternSaved; }
3090 
3094  PBoolean Compile(
3095  const PString & pattern,
3096  int flags = IgnoreCase
3097  );
3105  PBoolean Compile(
3106  const char * cpattern,
3107  int flags = IgnoreCase
3108  );
3109 
3110 
3112  PBoolean Execute(
3113  const PString & str,
3114  PINDEX & start,
3115  int flags = 0
3116  ) const;
3118  PBoolean Execute(
3119  const PString & str,
3120  PINDEX & start,
3121  PINDEX & len,
3122  int flags = 0
3123  ) const;
3125  PBoolean Execute(
3126  const char * cstr,
3127  PINDEX & start,
3128  int flags = 0
3129  ) const;
3131  PBoolean Execute(
3132  const char * cstr,
3133  PINDEX & start,
3134  PINDEX & len,
3135  int flags = 0
3136  ) const;
3138  PBoolean Execute(
3139  const PString & str,
3140  PIntArray & starts,
3141  int flags = 0
3142  ) const;
3144  PBoolean Execute(
3145  const PString & str,
3146  PIntArray & starts,
3147  PIntArray & ends,
3148  int flags = 0
3149  ) const;
3151  PBoolean Execute(
3152  const char * cstr,
3153  PIntArray & starts,
3154  int flags = 0
3155  ) const;
3172  PBoolean Execute(
3173  const char * cstr,
3174  PIntArray & starts,
3175  PIntArray & ends,
3176  int flags = 0
3177  ) const;
3194  PBoolean Execute(
3195  const char * cstr,
3196  PStringArray & substring,
3197  int flags = 0
3198  ) const;
3200 
3209  static PString EscapeString(
3210  const PString & str
3211  );
3213 
3214  protected:
3217 
3218  void * expression;
3220 };
3221 
3222 
3223 #endif // PTLIB_STRING_H
3224 
3225 
3226 // End Of File ///////////////////////////////////////////////////////////////