pstring.h

Go to the documentation of this file.

/*
 * pstring.h
 *
 * Character string class.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 21788 $
 * $Author: rjongbloed $
 * $Date: 2008-12-11 23:42:13 -0600 (Thu, 11 Dec 2008) $
 */

#ifndef PTLIB_STRING_H
#define PTLIB_STRING_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <string>
#include <vector>
#include <ptlib/array.h>

// PString class

class PStringArray;
class PRegularExpression;
class PString;

PString psprintf(const char * fmt, ...);

PString pvsprintf(const char * fmt, va_list arg);

#if (defined(_WIN32) || defined(_WIN32_WCE)) && (!defined(_NATIVE_WCHAR_T_DEFINED)) && (!defined(__MINGW32__))
PBASEARRAY(PWCharArray, unsigned short);
#else
PBASEARRAY(PWCharArray, wchar_t);
#endif

class PString : public PCharArray {
  PCLASSINFO(PString, PCharArray);

//  using namespace std;

  public:
    PINLINE PString();

    PINLINE PString(
      const PString & str  
    );

    PINLINE PString(
      const std::string & str
    );

    PString(
      const char * cstr 
    );

    PString(
      const wchar_t * ustr 
    );

    PString(
      const char * cstr,  
      PINDEX len          
    );

    PString(
      const wchar_t * ustr,  
      PINDEX len          
    );

    PString(
      const PWCharArray & ustr 
    );

    PString(
      char ch    
    );

    PString(
      short n   
    );

    PString(
      unsigned short n   
    );

    PString(
      int n   
    );

    PString(
      unsigned int n   
    );

    PString(
      long n   
    );

    PString(
      unsigned long n   
    );

    PString(
      PInt64 n   
    );

    PString(
      PUInt64 n   
    );

 
    enum ConversionType {
      Pascal,   // Data is a length byte followed by characters.
      Basic,    // Data is two length bytes followed by characters.
      Literal,  // Data is C language style string with \ escape codes.
      Signed,   // Convert a signed integer to a string.
      Unsigned, // Convert an unsigned integer to a string.
      Decimal,  // Convert a real number to a string in decimal format.
      Exponent, // Convert a real number to a string in exponent format.
      Printf,   // Formatted output, sprintf() style function.
      NumConversionTypes
    };
    /* Type of conversion to make in the conversion constructors.
     */

    /* Contruct a new string converting from the spcified data source into
       a string array.
     */
    PString(
      ConversionType type,  
      const char * str,    
      ...                 
    );
    PString(
      ConversionType type,  
      long value,           
      unsigned base = 10    
    );
    PString(
      ConversionType type,  
      double value,         
      unsigned places       
    );

    PString & operator=(
      const PString & str  
    );

    PString & operator=(
      const char * cstr  
    );

    PString & operator=(
      char ch            
    );

    PString & operator=(
      short n   
    );

    PString & operator=(
      unsigned short n   
    );

    PString & operator=(
      int n   
    );

    PString & operator=(
      unsigned int n   
    );

    PString & operator=(
      long n   
    );

    PString & operator=(
      unsigned long n   
    );

    PString & operator=(
      PInt64 n   
    );

    PString & operator=(
      PUInt64 n   
    );

    virtual PString & MakeEmpty();

    static PString Empty();

    virtual PObject * Clone() const;

    virtual Comparison Compare(
      const PObject & obj   
    ) const;

    virtual void PrintOn(
      ostream & strm  
    ) const;

    virtual void ReadFrom(
      istream & strm  
    );

    virtual PINDEX HashFunction() const;

    virtual PBoolean SetSize(
      PINDEX newSize  
    );

    virtual PBoolean IsEmpty() const;

    virtual PBoolean MakeUnique();


    PBoolean MakeMinimumSize();

    PINLINE PINDEX GetLength() const;

    bool operator!() const;

    PString operator+(
      const PString & str   
    ) const;

    PString operator+(
      const char * cstr  
    ) const;

    PString operator+(
      char ch   
    ) const;

    friend PString operator+(
      const char * cstr,    
      const PString & str   
    );

    friend PString operator+(
      char  c,              
      const PString & str   
    );

    PString & operator+=(
      const PString & str   
    );

    PString & operator+=(
      const char * cstr  
    );

    PString & operator+=(
      char ch   
    );


    PString operator&(
      const PString & str   
    ) const;

    PString operator&(
      const char * cstr  
    ) const;

    PString operator&(
      char ch   
    ) const;

    friend PString operator&(
      const char * cstr,    
      const PString & str   
    );

    friend PString operator&(
      char  ch,              
      const PString & str   
    );

    PString & operator&=(
      const PString & str   
    );

    PString & operator&=(
      const char * cstr  
    );


    PString & operator&=(
      char ch  
    );


    bool operator*=(
      const PString & str  
    ) const;

    bool operator==(
      const PObject & str  
    ) const;

    bool operator!=(
      const PObject & str  
    ) const;

    bool operator<(
      const PObject & str  
    ) const;

    bool operator>(
      const PObject & str  
    ) const;

    bool operator<=(
      const PObject & str  
    ) const;

    bool operator>=(
      const PObject & str  
    ) const;


    bool operator*=(
      const char * cstr  
    ) const;

    bool operator==(
      const char * cstr  
    ) const;

    bool operator!=(
      const char * cstr  
    ) const;

    bool operator<(
      const char * cstr  
    ) const;

    bool operator>(
      const char * cstr  
    ) const;

    bool operator<=(
      const char * cstr  
    ) const;

    bool operator>=(
      const char * cstr  
    ) const;

    Comparison NumCompare(
      const PString & str,        
      PINDEX count = P_MAX_INDEX, 
      PINDEX offset = 0           
    ) const;

    Comparison NumCompare(
      const char * cstr,          
      PINDEX count = P_MAX_INDEX, 
      PINDEX offset = 0           
    ) const;


    PINDEX Find(
      char ch,              
      PINDEX offset = 0     
    ) const;

    PINDEX Find(
      const PString & str,  
      PINDEX offset = 0     
    ) const;

    /* Locate the position within the string of the character or substring. The
       search will begin at the character offset provided.
       
       If #offset# is beyond the length of the string, then the
       function will always return #P_MAX_INDEX#.
       
       The matching will be for identical character or string. If a search
       ignoring case is required then the string should be converted to a
       #PCaselessString# before the search is made.

       @return
       position of character or substring in the string, or P_MAX_INDEX if the
       character or substring is not in the string.
     */
    PINDEX Find(
      const char * cstr,    
      PINDEX offset = 0     
    ) const;

    PINDEX FindLast(
      char ch,                     
      PINDEX offset = P_MAX_INDEX  
    ) const;

    PINDEX FindLast(
      const PString & str,         
      PINDEX offset = P_MAX_INDEX  
    ) const;

    PINDEX FindLast(
      const char * cstr,           
      PINDEX offset = P_MAX_INDEX  
    ) const;

    PINDEX FindOneOf(
      const PString & set,  
      PINDEX offset = 0     
    ) const;

    PINDEX FindOneOf(
      const char * cset,    
      PINDEX offset = 0     
    ) const;

    PINDEX FindSpan(
      const PString & set,  
      PINDEX offset = 0     
    ) const;

    PINDEX FindSpan(
      const char * cset,    
      PINDEX offset = 0     
    ) const;

    PINDEX FindRegEx(
      const PRegularExpression & regex, 
      PINDEX offset = 0                 
    ) const;

    PBoolean FindRegEx(
      const PRegularExpression & regex, 
      PINDEX & pos,                     
      PINDEX & len,                     
      PINDEX offset = 0,                
      PINDEX maxPos = P_MAX_INDEX       
    ) const;


    void Replace(
      const PString & target,   
      const PString & subs,     
      PBoolean all = PFalse,         
      PINDEX offset = 0         
    );

    void Splice(
      const PString & str,  
      PINDEX pos,           
      PINDEX len = 0        
    );

    void Splice(
      const char * cstr,    
      PINDEX pos,           
      PINDEX len = 0        
    );

    void Delete(
      PINDEX start,   
      PINDEX len      
    );


    PString operator()(
      PINDEX start,  
      PINDEX end     
    ) const;

    PString Left(
      PINDEX len   
    ) const;

    PString Right(
      PINDEX len   
    ) const;

    PString Mid(
      PINDEX start,             
      PINDEX len = P_MAX_INDEX  
    ) const;


    PString LeftTrim() const;

    PString RightTrim() const;

    PString Trim() const;


    PString ToLower() const;

    PString ToUpper() const;


    PStringArray Tokenise(
      const PString & separators,
      PBoolean onePerSeparator = PTrue
    ) const;
    PStringArray Tokenise(
      const char * cseparators,
      PBoolean onePerSeparator = PTrue
    ) const;

    PStringArray Lines() const;

    PString & sprintf(
      const char * cfmt,   
      ...                  
    );

    friend PString psprintf(
      const char * cfmt,   
      ...                  
    );

    PString & vsprintf(
      const PString & fmt, 
      va_list args         
    );
    PString & vsprintf(
      const char * cfmt,   
      va_list args         
    );

    friend PString pvsprintf(
      const char * cfmt,   
      va_list args         
    );
    friend PString pvsprintf(
      const PString & fmt, 
      va_list args         
    );


    long AsInteger(
      unsigned base = 10    
    ) const;
    DWORD AsUnsigned(
      unsigned base = 10    
    ) const;
    PInt64 AsInt64(
      unsigned base = 10    
    ) const;
    PUInt64 AsUnsigned64(
      unsigned base = 10    
    ) const;

    double AsReal() const;
     
    PWCharArray AsUCS2() const;

    PBYTEArray ToPascal() const;

    PString ToLiteral() const;

    operator const unsigned char *() const;

    operator std::string () const
    { return std::string(theArray); }


  protected:
    void InternalFromUCS2(
      const wchar_t * ptr,
      PINDEX len
    );
    virtual Comparison InternalCompare(
      PINDEX offset,      // Offset into string to compare.
      char c              // Character to compare against.
    ) const;
    virtual Comparison InternalCompare(
      PINDEX offset,      // Offset into string to compare.
      PINDEX length,      // Number of characters to compare.
      const char * cstr   // C string to compare against.
    ) const;
    /* Internal function to compare the current string value against the
       specified C string.

       @return
       relative rank of the two strings.
     */

    PString(int dummy, const PString * str);
};


inline ostream & operator<<(ostream & stream, const PString & string)
{
  string.PrintOn(stream);
  return stream;
}


inline wostream & operator<<(wostream & stream, const PString & string)
{
  return stream << (const char *)string;
}


#ifdef _WIN32
  class PWideString : public PWCharArray {
    PCLASSINFO(PWideString, PWCharArray);

    public:
      PWideString() { }
      PWideString(const PWCharArray & arr) : PWCharArray(arr) { }
      PWideString(const PString     & str) : PWCharArray(str.AsUCS2()) { }
      PWideString(const char        * str) : PWCharArray(PString(str).AsUCS2()) { }
      PWideString & operator=(const PWideString & str) { PWCharArray::operator=(str); return *this; }
      PWideString & operator=(const PString     & str) { PWCharArray::operator=(str.AsUCS2()); return *this; }
      PWideString & operator=(const char        * str) { PWCharArray::operator=(PString(str).AsUCS2()); return *this; }
      friend inline ostream & operator<<(ostream & stream, const PWideString & string) { return stream << PString(string); }
  };

  #ifdef UNICODE
    typedef PWideString PVarString;
  #else
    typedef PString PVarString;
  #endif
#endif



class PCaselessString : public PString
{
  PCLASSINFO(PCaselessString, PString);

  public:
    PCaselessString();

    PCaselessString(
      const char * cstr   
    );

    PCaselessString(
      const PString & str  
    );


    PCaselessString(
      const std::string & str  
      ) : PString(str)
    { }

    PCaselessString & operator=(
      const PString & str  
    );

    PCaselessString & operator=(
      const char * cstr  
    );

    PCaselessString & operator=(
      char ch            
    );


  // Overrides from class PObject
    virtual PObject * Clone() const;

  protected:
  // Overrides from class PString
    virtual Comparison InternalCompare(
      PINDEX offset,      // Offset into string to compare.
      char c              // Character to compare against.
    ) const;
    virtual Comparison InternalCompare(
      PINDEX offset,      // Offset into string to compare.
      PINDEX length,      // Number of characters to compare.
      const char * cstr   // C string to compare against.
    ) const;
    /* Internal function to compare the current string value against the
       specified C string.

       @return
       relative rank of the two strings or characters.
     */

    PCaselessString(int dummy, const PCaselessString * str);
};


class PStringStream;

class PStringStream : public PString, public iostream
{
  PCLASSINFO(PStringStream, PString);

  public:
    PStringStream();

    PStringStream(
      PINDEX fixedBufferSize
    );

    PStringStream(
      const PString & str   
    );

    PStringStream(
      const char * cstr   
    );

    virtual PString & MakeEmpty();

    PStringStream & operator=(
      const PStringStream & strm
    );

    PStringStream & operator=(
      const PString & str  
    );

    PStringStream & operator=(
      const char * cstr  
    );

    PStringStream & operator=(
      char ch            
    );


    virtual ~PStringStream();


  protected:
    virtual void AssignContents(const PContainer & cont);

  private:
    PStringStream(int, const PStringStream &) : iostream(cout.rdbuf()) { }

    class Buffer : public streambuf {
      public:
        Buffer(PStringStream & str, PINDEX size);
        Buffer(const Buffer & sbuf);
        Buffer & operator=(const Buffer & sbuf);
        virtual int_type overflow(int_type = EOF);
        virtual int_type underflow();
        virtual int sync();
        virtual pos_type seekoff(off_type, ios_base::seekdir, ios_base::openmode = ios_base::in | ios_base::out);
        virtual pos_type seekpos(pos_type, ios_base::openmode = ios_base::in | ios_base::out);
        PStringStream & string;
        PBoolean            fixedBufferSize;
    };
};


class PStringList;
class PSortedStringList;

#ifdef DOC_PLUS_PLUS
class PStringArray : public PArray {
#endif
  PDECLARE_ARRAY(PStringArray, PString);
  public:
    PStringArray(
      PINDEX count,                 
      char const * const * strarr,  
      PBoolean caseless = PFalse         
    );
    PStringArray(
      const PString & str  
    );
    PStringArray(
      const PStringList & list  
    );
    PStringArray(
      const PSortedStringList & list  
    );

    PStringArray(
      const std::vector<PString> & vec
    )
    {
      for (std::vector<PString>::const_iterator r = vec.begin(); r != vec.end(); ++r)
        AppendString(*r);
    }

    PStringArray(
      const std::vector<std::string> & vec
    )
    {
      for (std::vector<std::string>::const_iterator r = vec.begin(); r != vec.end(); ++r)
        AppendString(PString(*r));
    }

    template <typename stlContainer>
    static PStringArray container(
      const stlContainer & vec
    )
    {
      PStringArray list;
      for (typename stlContainer::const_iterator r = vec.begin(); r != vec.end(); ++r)
        list.AppendString(PString(*r));
      return list;
    }


    virtual void ReadFrom(
      istream &strm   // Stream to read the objects contents from.
    );

    PINDEX GetStringsIndex(
      const PString & str 
    ) const;

    PString operator[](
      PINDEX index  
    ) const;

    PString & operator[](
      PINDEX index  
    );

    PINDEX AppendString(
      const PString & str 
    );

    PStringArray & operator +=(const PStringArray & array);
    PStringArray & operator +=(const PString & str);


    PStringArray operator + (const PStringArray & array);
    PStringArray operator + (const PString & str);

    char ** ToCharArray(
      PCharArray * storage = NULL
    ) const;
};


#ifdef DOC_PLUS_PLUS
class PStringList : public PList {
#endif
PDECLARE_LIST(PStringList, PString);
  public:
    PStringList(
      PINDEX count,                 
      char const * const * strarr,  
      PBoolean caseless = PFalse         
    );
    PStringList(
      const PString & str  
    );
    PStringList(
      const PStringArray & array  
    );
    PStringList(
      const PSortedStringList & list  
    );

    virtual void ReadFrom(
      istream &strm   // Stream to read the objects contents from.
    );

    PINDEX AppendString(
      const PString & str 
    );

    PINDEX InsertString(
      const PString & before,   
      const PString & str       
    );

    PINDEX GetStringsIndex(
      const PString & str   
    ) const;

    PStringList & operator +=(const PStringList & list);
    PStringList & operator +=(const PString & str);


    PStringList operator + (const PStringList & array);
    PStringList operator + (const PString & str);

    template <typename stlContainer>
    static PStringList container(
      const stlContainer & vec
    )
    {
      PStringList list;
      for (typename stlContainer::const_iterator r = vec.begin(); r != vec.end(); ++r)
        list.AppendString(PString(*r));
      return list;
    }
};


#ifdef DOC_PLUS_PLUS
class PSortedStringList : public PSortedList {
#endif
PDECLARE_SORTED_LIST(PSortedStringList, PString);
  public:
    PSortedStringList(
      PINDEX count,                 
      char const * const * strarr,  
      PBoolean caseless = PFalse         
    );
    PSortedStringList(
      const PString & str  
    );
    PSortedStringList(
      const PStringArray & array  
    );
    PSortedStringList(
      const PStringList & list  
    );

    virtual void ReadFrom(
      istream &strm   // Stream to read the objects contents from.
    );

    PINDEX AppendString(
      const PString & str 
    );

    PINDEX GetStringsIndex(
      const PString & str   
    ) const;

    PINDEX GetNextStringsIndex(
      const PString & str   
    ) const;

  protected:
    PINDEX InternalStringSelect(
      const char * str,
      PINDEX len,
      Element * thisElement,
      Element * & lastElement
    ) const;
};


#ifdef DOC_PLUS_PLUS
class PStringSet : public PSet {
#endif
PDECLARE_SET(PStringSet, PString, PTrue);
  public:
    PStringSet(
      PINDEX count,                 
      char const * const * strarr,  
      PBoolean caseless = PFalse         
    );
    PStringSet(
      const PString & str  
    );

    virtual void ReadFrom(
      istream &strm   
    );

    void Include(
      const PString & key 
    );
    PStringSet & operator+=(
      const PString & key 
    );
    void Exclude(
      const PString & key 
    );
    PStringSet & operator-=(
      const PString & key 
    );
};


template <class K> class PStringDictionary : public PAbstractDictionary
{
  PCLASSINFO(PStringDictionary, PAbstractDictionary);

  public:
    PStringDictionary()
      : PAbstractDictionary() { }

    virtual PObject * Clone() const
      { return PNEW PStringDictionary(0, this); }

    const PString & operator[](const K & key) const
      { return (const PString &)GetRefAt(key); }

    PString operator()(const K & key, const char * dflt = "") const
      { if (AbstractContains(key)) return (*this)[key]; return dflt; }

    PBoolean Contains(
      const K & key   // Key to look for in the dictionary.
      ) const { return AbstractContains(key); }

    virtual PString * RemoveAt(
      const K & key   // Key for position in dictionary to get object.
    ) {
        PString * s = GetAt(key); AbstractSetAt(key, NULL);
        return reference->deleteObjects ? (s ? (PString *)-1 : NULL) : s;
      }

    virtual PString * GetAt(
      const K & key   // Key for position in dictionary to get object.
    ) const { return (PString *)AbstractGetAt(key); }

    virtual PBoolean SetDataAt(
      PINDEX index,        // Ordinal index in the dictionary.
      const PString & str  // New string value to put into the dictionary.
    ) { return PAbstractDictionary::SetDataAt(index, PNEW PString(str)); }

    virtual PBoolean SetAt(
      const K & key,       // Key for position in dictionary to add object.
      const PString & str  // New string value to put into the dictionary.
    ) { return AbstractSetAt(key, PNEW PString(str)); }

    const K & GetKeyAt(PINDEX index) const
      { return (const K &)AbstractGetKeyAt(index); }

    PString & GetDataAt(PINDEX index) const
      { return (PString &)AbstractGetDataAt(index); }

  protected:
    PStringDictionary(int dummy, const PStringDictionary * c)
      : PAbstractDictionary(dummy, c) { }
};


#define PDECLARE_STRING_DICTIONARY(cls, K) \
  PDECLARE_CLASS(cls, PStringDictionary<K>) \
  protected: \
    cls(int dummy, const cls * c) \
      : PStringDictionary<K>(dummy, c) { } \
  public: \
    cls() \
      : PStringDictionary<K>() { } \
    virtual PObject * Clone() const \
      { return PNEW cls(0, this); } \


#define PSTRING_DICTIONARY(cls, K) typedef PStringDictionary<K> cls


#ifdef DOC_PLUS_PLUS
class POrdinalToString : public PStringDictionary {
#endif
PDECLARE_STRING_DICTIONARY(POrdinalToString, POrdinalKey);
  public:

    struct Initialiser {
      PINDEX key;
      const char * value;
    };
    POrdinalToString(
      PINDEX count,                
      const Initialiser * init     
    );

    virtual void ReadFrom(
      istream &strm   // Stream to read the objects contents from.
    );
};

#ifdef DOC_PLUS_PLUS
class PStringToOrdinal : public POrdinalDictionary {
#endif
PDECLARE_ORDINAL_DICTIONARY(PStringToOrdinal, PString);
  public:

    struct Initialiser {
      const char * key;
      PINDEX value;
    };
    PStringToOrdinal(
      PINDEX count,                
      const Initialiser * init,    
      PBoolean caseless = PFalse        
    );

    virtual void ReadFrom(
      istream &strm   // Stream to read the objects contents from.
    );
};


#ifdef DOC_PLUS_PLUS
class PStringToString : public PStringDictionary {
#endif
PDECLARE_STRING_DICTIONARY(PStringToString, PString);
  public:

    struct Initialiser {
      const char * key;
      const char * value;
    };
    PStringToString(
      PINDEX count,                
      const Initialiser * init,    
      PBoolean caselessKeys = PFalse,   
      PBoolean caselessValues = PFalse  
    );

    virtual void ReadFrom(
      istream &strm   // Stream to read the objects contents from.
    );

    char ** ToCharArray(
      bool withEqualSign,
      PCharArray * storage = NULL
    ) const;
};


class PRegularExpression : public PObject
{
  PCLASSINFO(PRegularExpression, PObject);

  public:

    enum {
      Extended = 1,
      IgnoreCase = 2,
      AnchorNewLine = 4
    };
    enum {
      NotBeginningOfLine = 1,
      NotEndofLine = 2
    };

    PRegularExpression();

    PRegularExpression(
      const PString & pattern,    
      int flags = IgnoreCase      
    );

    PRegularExpression(
      const char * cpattern,      
      int flags = IgnoreCase      
    );

    PRegularExpression(
      const PRegularExpression &
    );

    PRegularExpression & operator =(
      const PRegularExpression &
    );

    ~PRegularExpression();


    enum ErrorCodes {
      NoError = 0,    
      NoMatch,      

      // POSIX regcomp return error codes.  (In the order listed in the standard.)
      BadPattern,  
      CollateError,  
      BadClassType,  
      BadEscape,    
      BadSubReg,
      UnmatchedBracket, 
      UnmatchedParen,
      UnmatchedBrace,
      BadBR,        
      RangeError,  
      OutOfMemory,
      BadRepitition,

      /* Error codes we've added.  */
      PrematureEnd,
      TooBig,
      UnmatchedRParen,
      NotCompiled
    };

    ErrorCodes GetErrorCode() const;

    PString GetErrorText() const;

    PBoolean Compile(
      const PString & pattern,    
      int flags = IgnoreCase      
    );
    PBoolean Compile(
      const char * cpattern,      
      int flags = IgnoreCase      
    );


    PBoolean Execute(
      const PString & str,    
      PINDEX & start,         
      int flags = 0           
    ) const;
    PBoolean Execute(
      const PString & str,    
      PINDEX & start,         
      PINDEX & len,           
      int flags = 0           
    ) const;
    PBoolean Execute(
      const char * cstr,      
      PINDEX & start,         
      int flags = 0           
    ) const;
    PBoolean Execute(
      const char * cstr,      
      PINDEX & start,         
      PINDEX & len,           
      int flags = 0           
    ) const;
    PBoolean Execute(
      const PString & str,    
      PIntArray & starts,     
      int flags = 0           
    ) const;
    PBoolean Execute(
      const PString & str,    
      PIntArray & starts,     
      PIntArray & ends,       
      int flags = 0           
    ) const;
    PBoolean Execute(
      const char * cstr,      
      PIntArray & starts,     
      int flags = 0           
    ) const;
    PBoolean Execute(
      const char * cstr,      
      PIntArray & starts,     
      PIntArray & ends,       
      int flags = 0           
    ) const;

    static PString EscapeString(
      const PString & str     
    );

  protected:
    PString patternSaved;
    int flagsSaved;

    void * expression;
    mutable ErrorCodes lastError;
};


#endif // #ifndef PTLIB_STRING_H


// End Of File ///////////////////////////////////////////////////////////////

---