(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.47 and 1.48

version 1.47, 2002/04/29 15:12:44 version 1.48, 2002/05/06 20:13:09
Line 23 
Line 23 
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By: Karl Schopmeyer(k.schopmeyer@opengroup.org) // 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;
  
     /** allocateCString - 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 357 
Line 352 
     */     */
     void toLower();     void toLower();
  
       /// Convert the plain old C-string to lower case:
       static void toLower(char* str);
   
     /** 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 372 
     */     */
     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 383 
     */     */
     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);
   
     /** 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 401 
             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);
  
     /** equalNoCase - Compares two strings and returuns true if they     /** equalNoCase - Compares two strings and returuns true if they
         are equal indpedent of case of the characters.         are equal indpedent of case of the characters.
         @param x First String parameter          @param str1 First String parameter
         @param y Second String parameter          @param str2 Second String parameter
         @return true if strings are equal independent of case.         @return true if strings are equal independent of case.
     */     */
     static Boolean equalNoCase(const String& x, const String& y);      static Boolean equalNoCase(const String& str1, const String& str2);
   
     /// Convert the plain old C-string to lower case:  
     static void toLower(char* str);  
   
     /** 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;  
  
     /** match matches a string against a GLOB style pattern.     /** match matches a string against a GLOB style pattern.
         Return trues if the String parameter matches the pattern. C-Shell style         Return trues if the String parameter matches the pattern. C-Shell style
Line 457 
Line 446 
     */     */
     static Boolean match(const String& str, const String& pattern);     static Boolean match(const String& str, const String& pattern);
  
     /** matcHoCase Matchses a String against a GLOB style pattern independent      /** matchNoCase Matches a String against a GLOB style pattern independent
         of case.         of case.
         Returns true if the str parameter matches the pattern. C-Shell style         Returns true if the str parameter matches the pattern. C-Shell style
         glob matching is used. Ignore case in all comparisons. Case is         glob matching is used. Ignore case in all comparisons. Case is
Line 471 
Line 460 
  
 private: private:
  
     static Uint32 _pegasusMin(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 523 
Line 501 
         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 535 
Line 510 
         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 591 
Line 551 
 { {
 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 606 
Line 566 
         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 628 
Line 588 
  
     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.47  
changed lines
  Added in v.1.48
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2