(file) Return to String.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/String.h between version 1.39.2.6 and 1.49

version 1.39.2.6, 2001/08/22 08:11:08 version 1.49, 2002/05/09 22:29:54
Line 22 
Line 22 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Karl Schopmeyer(k.schopmeyer@opengroup.org)
   //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 50 
Line 51 
 { {
 public: public:
  
       /** EMPTY - Represent an empty string.
           This member is used to represent empty strings. Using this member
           avoids an expensive construction of an empty string (e.g., String()).
       */
       static const String EMPTY;
   
     /** Default constructor without parameters. This constructor creates a     /** Default constructor without parameters. This constructor creates a
         null string         null string
         <pre>         <pre>
Line 59 
Line 66 
     String();     String();
  
     /// Copy constructor.     /// Copy constructor.
     String(const String& x);      String(const String& str);
  
     /// Initialize with first n characters from x.      /// Initialize with first n characters from str.
     String(const String& x, Uint32 n);      String(const String& str, Uint32 n);
  
     /// Initialize with x.      /// Initialize with str.
     String(const Char16* x);      String(const Char16* str);
  
     /// Initialize with first n characters of x.      /// Initialize with first n characters of str.
     String(const Char16* x, Uint32 n);      String(const Char16* str, Uint32 n);
  
     /// Initialize from a plain old C-String:     /// Initialize from a plain old C-String:
     String(const char* x);      String(const char* str);
  
     /// Initialize from the first n characters of a plain old C-String:     /// Initialize from the first n characters of a plain old C-String:
     String(const char* x, Uint32 n);      String(const char* str, Uint32 n);
  
     /// String destructor. Used by the representation of the String object     /// String destructor. Used by the representation of the String object
     ~String();     ~String();
  
     /** Assign this string with x.      /** Assign this string with str.
         <pre>         <pre>
             String t1 = "abc";             String t1 = "abc";
             String t2 = t1;             String t2 = t1;
         </pre>         </pre>
     */     */
     String& operator=(const String& x) { return assign(x); }      String& operator=(const String& str);
  
     /// Assign this string with Char16 x.      /// Assign this string with Char16 str.
     String& operator=(const Char16* x) { assign(x); return *this; }      String& operator=(const Char16* str);
  
     /** Assign this string with String x      /** Assign this string with String str
     @param x String to assign      @param str String to assign
     @return Returns the String     @return Returns the String
     */     */
     String& assign(const String& x);      String& assign(const String& str);
  
     /// Assign this string with x.      /// Assign this string with str.
     String& assign(const Char16* x);      String& assign(const Char16* str);
  
     /// Assign this string with first n characters of x.      /// Assign this string with first n characters of str.
     String& assign(const Char16* x, Uint32 n);      String& assign(const Char16* str, Uint32 n);
  
     /// Assign this string with the plain old C-String x.      /// Assign this string with the plain old C-String str.
     String& assign(const char* x);      String& assign(const char* str);
  
     /// Assign this string with first n characters of the plain old C-String x.      /// Assign this string with first n characters of the plain old C-String str.
     String& assign(const char* x, Uint32 n);      String& assign(const char* str, Uint32 n);
  
     /** clear - Clear this string. After calling clear(), size() will return 0.     /** clear - Clear this string. After calling clear(), size() will return 0.
         <pre>         <pre>
Line 135 
Line 142 
             assert(s.size() == 4);             assert(s.size() == 4);
         </pre>         </pre>
     */     */
     Uint32 size() const { return _rep.size() - 1; }      Uint32 size() const;
  
     /** getData Returns a pointer to the first character in the     /** getData Returns a pointer to the first character in the
         null-terminated string string of the String object.         null-terminated string string of the String object.
Line 145 
Line 152 
             const Char16* q = t1.getData();             const Char16* q = t1.getData();
         </pre>         </pre>
     */     */
     const Char16* getData() const { return _rep.getData(); }      const Char16* getData() const;
  
     /** AallocateCString - llocates an 8 bit representation of this String      /** allocateCString - allocates an 8 bit representation of this String
         object. The user is responsible for freeing the result. If any         object. The user is responsible for freeing the result. If any
         characters are truncated, a TruncatedCharacter exception is thrown.         characters are truncated, a TruncatedCharacter exception is thrown.
         This exception may be suppressed by passing true as the noThrow         This exception may be suppressed by passing true as the noThrow
Line 229 
Line 236 
     String& append(const Char16* str, Uint32 n);     String& append(const Char16* str, Uint32 n);
  
     /// Append the characters of str to this String object.     /// Append the characters of str to this String object.
     String& append(const String& str)      String& append(const String& str);
     {  
         return append(str.getData(), str.size());  
     }  
  
     /** Overload operator += appends the parameter String to this String.     /** Overload operator += appends the parameter String to this String.
         @param String to append.         @param String to append.
Line 243 
Line 247 
         assert(test == "abcdef");         assert(test == "abcdef");
         </pre>         </pre>
     */     */
     String& operator+=(const String& x)      String& operator+=(const String& str);
     {  
         return append(x);  
     }  
  
     /** Append the character given by c to this String object.     /** Append the character given by c to this String object.
         @param c Single character to be appended         @param c Single character to be appended
         @return String with appended character         @return String with appended character
     */     */
     String& operator+=(Char16 c)      String& operator+=(Char16 c);
     {  
         return append(c);  
     }  
  
     /** Append the character given by c to this string.     /** Append the character given by c to this string.
         <pre>         <pre>
Line 264 
Line 262 
             assert(t1 == "abcd");             assert(t1 == "abcd");
         </pre>         </pre>
     */     */
     String& operator+=(char c)      String& operator+=(char c);
     {  
         return append(Char16(c));  
     }  
  
     /** Remove size characters from the string starting at the given     /** Remove size characters from the string starting at the given
         position. If size is PEG_NOT_FOUND, then all characters after pos are         position. If size is PEG_NOT_FOUND, then all characters after pos are
Line 353 
Line 348 
     */     */
     Uint32 reverseFind(Char16 c) const;     Uint32 reverseFind(Char16 c) const;
  
   #ifdef PEGASUS_INTERNALONLY
       // ATTN-RK-P3-20020509: Define case-sensitivity for non-English characters
     /** Converts all characters in this string to lower case.     /** Converts all characters in this string to lower case.
     */     */
     void toLower();     void toLower();
  
       /// Convert the plain old C-string to lower case:
       static void toLower(char* str);
   #endif
   
     /** Translate any occurences of fromChar to toChar.     /** Translate any occurences of fromChar to toChar.
     */     */
     void translate(Char16 fromChar, Char16 toChar);     void translate(Char16 fromChar, Char16 toChar);
Line 374 
Line 375 
     */     */
     static int compare(const Char16* s1, const Char16* s2, Uint32 n);     static int compare(const Char16* s1, const Char16* s2, Uint32 n);
  
     /** Just like one above except ignores case differences.  
     */  
     static int compareNoCase(const char* s1, const char* s2, Uint32 n);  
   
     static int compareNoCase(const char* s1, const char* s2);  
   
     /** Compare two null-terminated strings.     /** Compare two null-terminated strings.
         @param s1 First null-terminated string for the comparison.         @param s1 First null-terminated string for the comparison.
         @param s2 Second null-terminated string for the comparison.         @param s2 Second null-terminated string for the comparison.
Line 391 
Line 386 
     */     */
     static int compare(const Char16* s1, const Char16* s2);     static int compare(const Char16* s1, const Char16* s2);
  
       /** Just like one above except ignores case differences.
       */
       static int compareNoCase(const char* s1, const char* s2, Uint32 n);
   
       static int compareNoCase(const char* s1, const char* s2);
   
   #ifdef PEGASUS_INTERNALONLY
       static int compareNoCase(const String& s1, const String& s2);
   #endif
   
     /** Compare two String objects for equality.     /** Compare two String objects for equality.
         @param s1 First <TT>String</TT> for comparison.         @param s1 First <TT>String</TT> for comparison.
         @param s2 Second <TT>String</TT> for comparison.         @param s2 Second <TT>String</TT> for comparison.
Line 403 
Line 408 
             assert(String::equal(s1, s3));             assert(String::equal(s1, s3));
         </pre>         </pre>
     */     */
     static Boolean equal(const String& x, const String& y);      static Boolean equal(const String& str1, const String& str2);
  
     /// Return true if the two strings are equal.     /// Return true if the two strings are equal.
     static Boolean equal(const String& x, const Char16* y);      static Boolean equal(const String& str1, const Char16* str2);
  
     /// Return true if the two strings are equal.     /// Return true if the two strings are equal.
     static Boolean equal(const Char16* x, const String& y);      static Boolean equal(const Char16* str1, const String& str2);
  
     /// Return true if the two strings are equal.     /// Return true if the two strings are equal.
     static Boolean equal(const String& x, const char* y);      static Boolean equal(const String& str1, const char* str2);
  
     /// Return true if the two strings are equal.     /// Return true if the two strings are equal.
     static Boolean equal(const char* x, const String& y);      static Boolean equal(const char* str1, const String& str2);
   
     static Boolean equalNoCase(const String& x, const String& y);  
  
     /// Convert the plain old C-string to lower case:      /** equalNoCase - Compares two strings and returuns true if they
     static void toLower(char* str);          are equal indpedent of case of the characters.
           @param str1 First String parameter
     /** EMPTY - Represent an empty string.          @param str2 Second String parameter
         This member is used to represent empty strings. Using this member          @return true if strings are equal independent of case.
         avoids an expensive construction of an empty string (e.g., String()).  
     */     */
     static const String EMPTY;      static Boolean equalNoCase(const String& str1, const String& str2);
  
     /** Return true if the str parameter matches the pattern. C-Shell style      /** match matches a string against a GLOB style pattern.
           Return trues if the String parameter matches the pattern. C-Shell style
         glob matching is used.         glob matching is used.
           @param str String to be matched against the pattern
           @param pattern Pattern to use in the match
           @return Boolean true if str matches pattern
           The pattern definition is as follows:
           <pre>
           *             Matches any number of any characters
           ?             Match exactly one character
           [chars]       Match any character in chars
           [chara-charb] Match any character in the range between chara and charb
           </pre>
           The literal characters *, ?, [, ] can be included in a string by
           escaping them with backslash "\".  Ranges of characters can be concatenated.
           <pre>
           examples:
           Boolean result = String::match("This is a test", "*is*");
           Boolean works =  String::match("abcdef123", "*[0-9]");
           </pre>
     */     */
     static Boolean match(const String& str, const String& pattern);     static Boolean match(const String& str, const String& pattern);
  
     /** Return true if the str parameter matches the pattern. C-Shell style      /** matchNoCase Matches a String against a GLOB style pattern independent
         glob matching is used. Ignore case in all comparisons.          of case.
           Returns true if the str parameter matches the pattern. C-Shell style
           glob matching is used. Ignore case in all comparisons. Case is
           ignored in the match.
           @parm str String containing the string to be matched\
           @parm pattern GLOB style patterh to use in the match.
           @return Boolean true if str matches patterh
           @SeeAlso match
     */     */
     static Boolean matchNoCase(const String& str, const String& pattern);     static Boolean matchNoCase(const String& str, const String& pattern);
  
 private: private:
  
     static Uint32 _min(Uint32 x, Uint32 y) { return x < y ? x : y; }  
   
     Array<Char16> _rep;     Array<Char16> _rep;
 }; };
  
 /** String operator ==. Test for equality between two strings of any of the /** String operator ==. Test for equality between two strings of any of the
     types String or char*.     types String or char*.
     @return Boolean - True if the strings are equal     @return Boolean - True if the strings are equal
   
 */ */
 inline Boolean operator==(const String& x, const String& y)  PEGASUS_COMMON_LINKAGE Boolean operator==(
 {      const String& str1,
     return String::equal(x, y);      const String& str2);
 }  
  
 /** String operator ==. Test for equality between two strings /** String operator ==. Test for equality between two strings
  
 */ */
 inline Boolean operator==(const String& x, const char* y)  PEGASUS_COMMON_LINKAGE Boolean operator==(const String& str1, const char* str2);
 {  
     return String::equal(x, y);  
 }  
  
 /** String operator ==. Test for equality between two strings /** String operator ==. Test for equality between two strings
  
 */ */
 inline Boolean operator==(const char* x, const String& y)  PEGASUS_COMMON_LINKAGE Boolean operator==(const char* str1, const String& str2);
 {  
     return String::equal(x, y);  
 }  
  
 /** String operator ==. Test for equality between two strings /** String operator ==. Test for equality between two strings
  
 */ */
 inline Boolean operator!=(const String& x, const String& y)  PEGASUS_COMMON_LINKAGE Boolean operator!=(
 {      const String& str1,
     return !String::equal(x, y);      const String& str2);
 }  
  
 PEGASUS_COMMON_LINKAGE PEGASUS_STD(ostream)& operator<<( PEGASUS_COMMON_LINKAGE PEGASUS_STD(ostream)& operator<<(
     PEGASUS_STD(ostream)& os,     PEGASUS_STD(ostream)& os,
     const String& x);      const String& str);
  
 /** overload operator +  - Concatenates String objects. /** overload operator +  - Concatenates String objects.
  
Line 492 
Line 508 
         assert(t2 == "abcdef");         assert(t2 == "abcdef");
     </pre>     </pre>
 */ */
 inline String operator+(const String& x, const String& y)  PEGASUS_COMMON_LINKAGE String operator+(const String& str1, const String& str2);
 {  
     return String(x).append(y);  
 }  
  
 /** overload operator < - Compares String obects. /** overload operator < - Compares String obects.
     <pre>     <pre>
Line 504 
Line 517 
         assert (t2 < t1);         assert (t2 < t1);
     </pre>     </pre>
 */ */
 inline Boolean operator<(const String& x, const String& y)  PEGASUS_COMMON_LINKAGE Boolean operator<(
 {      const String& str1,
     return String::compare(x.getData(), y.getData()) < 0;      const String& str2);
 }  
  
 /** overload operator <= compares String objects. /** overload operator <= compares String objects.
  
 */ */
 inline Boolean operator<=(const String& x, const String& y)  PEGASUS_COMMON_LINKAGE Boolean operator<=(
 {      const String& str1,
     return String::compare(x.getData(), y.getData()) <= 0;      const String& str2);
 }  
  
 /** Overload operator > compares String objects /** Overload operator > compares String objects
 */ */
 inline Boolean operator>(const String& x, const String& y)  PEGASUS_COMMON_LINKAGE Boolean operator>(
 {      const String& str1,
     return String::compare(x.getData(), y.getData()) > 0;      const String& str2);
 }  
  
 /** overload operator >= - Compares String objects /** overload operator >= - Compares String objects
 */ */
 inline Boolean operator>=(const String& x, const String& y)  PEGASUS_COMMON_LINKAGE Boolean operator>=(
 {      const String& str1,
     return String::compare(x.getData(), y.getData()) >= 0;      const String& str2);
 }  
   
 /** Return a version of this string whose characters have been shifted  
     to lower case.  
 */  
 PEGASUS_COMMON_LINKAGE String ToLower(const String& str);  
  
 /** Compare two strings but ignore any case differences. /** Compare two strings but ignore any case differences.
 */ */
 PEGASUS_COMMON_LINKAGE int CompareNoCase(const char* s1, const char* s2); PEGASUS_COMMON_LINKAGE int CompareNoCase(const char* s1, const char* s2);
  
 inline int EqualNoCase(const char* s1, const char* s2)  PEGASUS_COMMON_LINKAGE int EqualNoCase(const char* s1, const char* s2);
 {  
     return CompareNoCase(s1, s2) == 0;  
 }  
   
 /** Get the next line from the input file.  
 */  
 PEGASUS_COMMON_LINKAGE Boolean GetLine(PEGASUS_STD(istream)& is, String& line);  
  
   #ifdef PEGASUS_INTERNALONLY
 /*  This is an internal class to be used by the internal Pegasus /*  This is an internal class to be used by the internal Pegasus
     components only. It provides an easy way to create an 8-bit string     components only. It provides an easy way to create an 8-bit string
     representation on the fly without calling allocateCString() and     representation on the fly without calling allocateCString() and
Line 560 
Line 558 
 { {
 public: public:
  
     _CString(const String& x)      _CString(const String& str)
     {     {
         _rep = x.allocateCString();          _rep = str.allocateCString();
     }     }
  
     _CString(const _CString& x)      _CString(const _CString& str)
     {     {
         _rep = strcpy(new char[strlen(x._rep) + 1], x._rep);          _rep = strcpy(new char[strlen(str._rep) + 1], str._rep);
     }     }
  
     ~_CString()     ~_CString()
Line 575 
Line 573 
         delete [] _rep;         delete [] _rep;
     }     }
  
     _CString& operator=(const _CString& x)      _CString& operator=(const _CString& str)
     {     {
         if (this != &x)          if (this != &str)
             _rep = strcpy(new char[strlen(x._rep) + 1], x._rep);              _rep = strcpy(new char[strlen(str._rep) + 1], str._rep);
  
         return *this;         return *this;
     }     }
Line 597 
Line 595 
  
     char* _rep;     char* _rep;
 }; };
   #endif
 inline Uint32 _Length(const String& s1) { return s1.size(); }  
   
 inline Uint32 _Length(const char* s1) { return strlen(s1); }  
   
 inline Uint32 _Length(const char) { return 1; }  
   
 template<class S1, class S2>  
 inline String Cat(const S1& s1, const S2& s2)  
 {  
     String tmp;  
     tmp.reserve(_Length(s1) + _Length(s2));  
     tmp.append(s1);  
     tmp.append(s2);  
     return tmp;  
 }  
   
 template<class S1, class S2, class S3>  
 inline String Cat(const S1& s1, const S2& s2, const S3& s3)  
 {  
     String tmp;  
     tmp.reserve(_Length(s1) + _Length(s2) + _Length(s3));  
     tmp.append(s1);  
     tmp.append(s2);  
     tmp.append(s3);  
     return tmp;  
 }  
   
 template<class S1, class S2, class S3, class S4>  
 inline String Cat(const S1& s1, const S2& s2, const S3& s3, const S4& s4)  
 {  
     String tmp;  
     tmp.reserve(_Length(s1) + _Length(s2) + _Length(s3) + _Length(s4));  
     tmp.append(s1);  
     tmp.append(s2);  
     tmp.append(s3);  
     tmp.append(s4);  
     return tmp;  
 }  
   
 template<class S1, class S2, class S3, class S4, class S5>  
 inline String Cat(  
     const S1& s1,  
     const S2& s2,  
     const S3& s3,  
     const S4& s4,  
     const S5& s5)  
 {  
     String tmp;  
   
     tmp.reserve(_Length(s1) + _Length(s2) + _Length(s3) + _Length(s4) +  
         _Length(s5));  
   
     tmp.append(s1);  
     tmp.append(s2);  
     tmp.append(s3);  
     tmp.append(s4);  
     tmp.append(s5);  
   
     return tmp;  
 }  
   
 template<class S1, class S2, class S3, class S4, class S5, class S6>  
 inline String Cat(  
     const S1& s1,  
     const S2& s2,  
     const S3& s3,  
     const S4& s4,  
     const S5& s5,  
     const S6& s6)  
 {  
     String tmp;  
   
     tmp.reserve(_Length(s1) + _Length(s2) + _Length(s3) + _Length(s4) +  
         _Length(s5) + _Length(s6));  
   
     tmp.append(s1);  
     tmp.append(s2);  
     tmp.append(s3);  
     tmp.append(s4);  
     tmp.append(s5);  
     tmp.append(s6);  
   
     return tmp;  
 }  
   
 PEGASUS_COMMON_LINKAGE const Array<String>& EmptyStringArray();  
   
 PEGASUS_COMMON_LINKAGE Boolean Equal(const String& x, const String& y);  
   
 inline Boolean Open(PEGASUS_STD(ifstream)& is, const String& path)  
 {  
     char* tmpPath = path.allocateCString();  
     is.open(tmpPath);  
     delete [] tmpPath;  
     return !!is;  
 }  
   
 inline Boolean Open(PEGASUS_STD(ofstream)& os, const String& path)  
 {  
     char* tmpPath = path.allocateCString();  
     os.open(tmpPath);  
     delete [] tmpPath;  
     return !!os;  
 }  
   
 inline Boolean OpenAppend(PEGASUS_STD(ofstream)& os, const String& path)  
 {  
     char* tmpPath = path.allocateCString();  
     os.open(tmpPath, PEGASUS_STD(ios::app));  
     delete [] tmpPath;  
     return !!os;  
 }  
  
 #define PEGASUS_ARRAY_T String #define PEGASUS_ARRAY_T String
 #include <Pegasus/Common/ArrayInter.h> #include <Pegasus/Common/ArrayInter.h>

Legend:
Removed from v.1.39.2.6  
changed lines
  Added in v.1.49
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2