(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.51

version 1.39.2.6, 2001/08/22 08:11:08 version 1.51, 2002/07/17 18:52:23
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 22 
Line 23 
 // //
 // 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 34 
Line 36 
 #include <cstring> #include <cstring>
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/Char16.h> #include <Pegasus/Common/Char16.h>
 #include <Pegasus/Common/Array.h>  
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   class StringRep;
   
 /** /**
     The Pegasus String C++ Class implements the CIM string type.     The Pegasus String C++ Class implements the CIM string type.
     This class is based on the general handle/representation pattern     This class is based on the general handle/representation pattern
Line 50 
Line 53 
 { {
 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 68 
     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.  
     String& operator=(const Char16* x) { assign(x); return *this; }  
  
     /** 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 117 
Line 123 
     void clear();     void clear();
  
  
     /** reserve - Reserves memory for capacity characters. Notice that this does      /** reserve - Reserves memory for capacity characters. Notice that this
     not          does not change the size of the string (size() returns what it did
         change the size of the string (size() returns what it did before).          before).  If the capacity of the string is already greater or equal
         If the capacity of the string is already greater or equal to the          to the capacity argument, this method has no effect.  The capacity
         capacity argument, this method has no effect. After calling reserve(),          of a String object has no bearing on its external behavior.  The
         getCapicty() returns a value which is greater or equal to the          capacity of a String is set only for performance reasons.
         capacity argument.  
         @param capacity defines the capacity in characters to reserve.         @param capacity defines the capacity in characters to reserve.
     */     */
     void reserve(Uint32 capacity);      void reserveCapacity(Uint32 capacity);
  
     /** Returns the length of the String object.     /** Returns the length of the String object.
         @return Length of the string in characters.         @return Length of the string in characters.
Line 135 
Line 140 
             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 150 
             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 234 
     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 245 
         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 260 
             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 326 
Line 319 
     */     */
     Uint32 find(const String& s) const;     Uint32 find(const String& s) const;
  
     /** Find substring  
         @ param 16 bit character pointer  
         @seealso find  
         @return Position of the substring in the String or PEG_NOT_FOUND if not  
         found.  
     */  
     Uint32 find(const Char16* s) const;  
   
     /** find substring  
         @param s char* to substring  
         @return Position of the substring in the String or PEG_NOT_FOUND if not  
         found.  
     */  
     Uint32 find(const char* s) const;  
   
     /** reverseFind - Same as find() but start looking in reverse (last     /** reverseFind - Same as find() but start looking in reverse (last
     character first).     character first).
         @param c Char16 character to find in String.         @param c Char16 character to find in String.
Line 353 
Line 331 
     */     */
     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();
  
     /** Translate any occurences of fromChar to toChar.      /// Convert the plain old C-string to lower case:
     */      static void toLower(char* str);
     void translate(Char16 fromChar, Char16 toChar);  #endif
   
     /** Method for printing a string.  
     */  
     void print() const;  
  
     /** Compare the first n characters of the two strings..     /** Compare the first n characters of the two strings..
         @param s1 First null-terminated string for the comparison.         @param s1 First null-terminated string for the comparison.
Line 372 
Line 348 
         @return Return -1 if s1 is lexographically less than s2. If they are         @return Return -1 if s1 is lexographically less than s2. If they are
         equavalent return 0. Otherwise return 1.         equavalent return 0. Otherwise return 1.
     */     */
     static int compare(const Char16* s1, const Char16* s2, Uint32 n);      static int compare(const String& s1, const String& 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.
Line 389 
Line 359 
         NOTE: Use the comparison operators <,<= > >= to compare         NOTE: Use the comparison operators <,<= > >= to compare
         String objects.         String objects.
     */     */
     static int compare(const Char16* s1, const Char16* s2);      static int compare(const String& s1, const String& 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.
Line 403 
Line 383 
             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.  
     static Boolean equal(const String& x, const Char16* y);  
   
     /// Return true if the two strings are equal.  
     static Boolean equal(const Char16* x, const String& y);  
   
     /// Return true if the two strings are equal.  
     static Boolean equal(const String& x, const char* y);  
  
     /// Return true if the two strings are equal.      /** equalNoCase - Compares two strings and returuns true if they
     static Boolean equal(const char* x, const String& y);          are equal indpedent of case of the characters.
           @param str1 First String parameter
     static Boolean equalNoCase(const String& x, const String& y);          @param str2 Second String parameter
           @return true if strings are equal independent of case.
     /// 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;      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; }      StringRep* _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 471 
         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 480 
         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 521 
 { {
 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 536 
         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 558 
  
     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  
 #include <Pegasus/Common/ArrayInter.h>  
 #undef PEGASUS_ARRAY_T  
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  

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