string.h

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

    */
    String& append(const Char16& c);

    /** Append n characters from str to this String.
    @param str REVIEWERS: Insert text here.
    @param n REVIEWERS: Insert text here.
    @exception NullPointer Thrown if str is NULL.
    @exception bad_alloc Thrown if there is insufficient memory.
    */
    String& append(const Char16* str, Uint32 n);

    /** Append the given String to this String.
    @param str String to append.
    @return This String.
    <pre>
        String test = "abc";
        test.append("def");
        assert(test == "abcdef");
    </pre>
    @exception bad_alloc Thrown if there is insufficient memory.
    */
    String& append(const String& str);

    /** Remove size characters from the string starting at the given
    index. If size is PEG_NOT_FOUND, then all characters after
    <TT>index</TT> are removed.
    @param index Position in string to start remove.
    @param size Number of characters to remove. Default is PEG_NOT_FOUND
    which causes all characters after <TT>index</TT> to be removed.
    <pre>
        String s;
        s = "abc";
        s.remove(0, 1);
        assert(String::equal(s, "bc"));
        assert(s.size() == 2);
        s.remove(0);
        assert(String::equal(s, ""));
        assert(s.size() == 0);
    </pre>
    @exception IndexOutOfBoundsException If size is greater than
    length of String plus starting index for remove.
    */
    void remove(Uint32 index, Uint32 size = PEG_NOT_FOUND);

    /** Return a new String which is initialzed with <TT>length</TT>
    characters from this string starting at <TT>index</TT>.
    @param index Specifies the index in string to start getting the
    substring.
    @param length Specifies the number of characters to get. If length
    is PEG_NOT_FOUND, then all characters after index are added to the new
    string.
    @return String Specifies the Sting with the defined substring.
    @exception bad_alloc Thrown if there is insufficient memory.
    */
    String subString(Uint32 index, Uint32 length = PEG_NOT_FOUND) const;

    /** Find the index of the first occurrence of the character c.
    If the character is not found, PEG_NOT_FOUND is returned.
    @param c Char to be found in the String.
    @return Position of the character in the string or PEG_NOT_FOUND if not
    found.
    */
    Uint32 find(Char16 c) const;

    /** Find the index of the first occurence of the character c.
    If the character is not found, PEG_NOT_FOUND is returned.
    Searching begins from the specified index.
    @param c Char to be found in the String.
    @return Position of the character in the string or PEG_NOT_FOUND if the
    character is not found.
    */
    Uint32 find(Uint32 index, Char16 c) const;

    /** Find the index of the first occurence of the string object.
    This function finds one string inside another.
    If the matching substring is not found, PEG_NOT_FOUND is returned.
    @param s String object to be found in the String.
    @return Position of the substring in the String or PEG_NOT_FOUND if the
    substring is not found.
    */
    Uint32 find(const String& s) const;

    /** Same as find() but start looking in reverse (last character first).
    @param c Char16 character to find in String.
    @return Position of the character in the string or PEG_NOT_FOUND if the
    character is not found.
    */
    Uint32 reverseFind(Char16 c) const;

    /** Converts all characters in this string to lowercase characters,
    */
    void toLower();

#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
    /** <I><B>Experimental Interface</B></I><BR>
        Converts all characters in this string to uppercase characters.
    */
    void toUpper();
#endif

    /**
        Compares the first n characters of two String objects.
        @param s1 The first String to compare.
        @param s2 The second String to compare.
        @param n The maximum number of characters to compare.
        @return Returns a negative integer if the first n characters of s1
        are lexographically less than s2, 0 if the first n characters of s1
        and s2 are equal, and a positive integer otherwise.
    */
    static int compare(const String& s1, const String& s2, Uint32 n);

    /**
        Compares two String objects.
        @param s1 The first String to compare.
        @param s2 The second String to compare.
        @return Returns a negative integer if s1 is lexographically less
        than s2, 0 if s1 and s2 are equal, and a positive integer otherwise.

        NOTE: Use the comparison operators <,<= > >= to compare
        String objects.
    */
    static int compare(const String& s1, const String& s2);

    /**
        Compares two String objects, ignoring case differences.
        @param s1 The first String to compare.
        @param s2 The second String to compare.
        @return Returns a negative integer if s1 is lexographically less
        than s2, 0 if s1 and s2 are equal, and a positive integer otherwise.
        (Case differences are ignored in all cases.)
    */
    static int compareNoCase(const String& s1, const String& s2);

    /** Compare two String objects for equality.
    @param s1 First <TT>String</TT> for comparison.
    @param s2 Second <TT>String</TT> for comparison.

    @return true If the two strings are equal; otherwise, false. For example,
    <pre>
        String s1 = "Hello World";
        String s2 = s1;
        String s3(s2);
        assert(String::equal(s1, s3));
    </pre>
    */
    static Boolean equal(const String& str1, const String& str2);

    /** Compares two strings and returns true if they
    are equal indepedent of case of the characters.
    @param str1 First String parameter.
    @param str2 Second String parameter.
    @return true If strings are equal independent of case, flase
        otherwise.
    */
    static Boolean equalNoCase(const String& str1, const String& str2);

#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES

    String(const String& s1, const String& s2);

    String(const String& s1, const char* s2);

    String(const char* s1, const String& s2);

    String& operator=(const char* str);

    Uint32 find(const char* s) const;

    static Boolean equal(const String& s1, const char* s2);

    static int compare(const String& s1, const char* s2);

    String& append(const char* str);

    String& append(const char* str, Uint32 size);

    static Boolean equalNoCase(const String& s1, const char* s2);

#endif /* PEGASUS_USE_EXPERIMENTAL_INTERFACES */

private:

    StringRep* _rep;
};

/** String operator == tests for equality between two strings of any of the
    types String or char*.
    @return true If the strings are equal; otherwise, false.
    @param str1 REVIEWERS: Insert description here.
    @param str2 REVIEWERS: Insert description here.
*/
PEGASUS_COMMON_LINKAGE Boolean operator==(
    const String& str1,
    const String& str2);

/** String operator ==. Test for equality between two strings.
    @param str1 REVIEWERS: Insert description here.
    @param str2 REVIEWERS: Insert description here.
*/
PEGASUS_COMMON_LINKAGE Boolean operator==(const String& str1, const char* str2);

/** String operator ==. Test for equality between two strings.
    @param str1 REVIEWERS: Insert description here.
    @param str2 REVIEWERS: Insert description here.
*/
PEGASUS_COMMON_LINKAGE Boolean operator==(const char* str1, const String& str2);

/** String operator ==. Test for equality between two strings.
    @param str1 REVIEWERS: Insert description here.
    @param str2 REVIEWERS: Insert description here.
*/
PEGASUS_COMMON_LINKAGE Boolean operator!=(
    const String& str1,
    const String& str2);

/** REVIEWERS: Insert description here.
    @param str REVIEWERS: Insert description here.
    @param os REVIEWERS: Insert description here.
*/
PEGASUS_COMMON_LINKAGE PEGASUS_STD(ostream)& operator<<(
    PEGASUS_STD(ostream)& os,
    const String& str);

/** This overload operator (+) concatenates String objects. For example,
    <pre>
        String t1 = "abc";
        String t2;
        t2 = t1 + "def"
        assert(t2 == "abcdef");
    </pre>
*/
PEGASUS_COMMON_LINKAGE String operator+(const String& str1, const String& str2);

/** The overload operator (<) compares String obects.
    <pre>
        String t1 = "def";
        String t2 = "a";
        assert (t2 < t1);
    </pre>
    @param str1 REVIEWERS: Insert description here.
    @param str2 REVIEWERS: Insert description here.
*/
PEGASUS_COMMON_LINKAGE Boolean operator<(
    const String& str1,
    const String& str2);

/** The overload operator (<=) compares String objects.
    @param str1 REVIEWERS: Insert description here.
    @param str2 REVIEWERS: Insert description here.
*/
PEGASUS_COMMON_LINKAGE Boolean operator<=(
    const String& str1,
    const String& str2);

/** The overload operator (>) compares String objects.
    @param str1 REVIEWERS: Insert description here.
    @param str2 REVIEWERS: Insert description here.
*/
PEGASUS_COMMON_LINKAGE Boolean operator>(
    const String& str1,
    const String& str2);

/** The overload operator (>=) compares String objects.
    @param str1 REVIEWERS: Insert description here.
    @param str2 REVIEWERS: Insert description here.
*/
PEGASUS_COMMON_LINKAGE Boolean operator>=(
    const String& str1,
    const String& str2);

#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES

PEGASUS_COMMON_LINKAGE Boolean operator==(const String& s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator==(const String& s1, const char* s2);

PEGASUS_COMMON_LINKAGE Boolean operator==(const char* s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator!=(const String& s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator!=(const String& s1, const char* s2);

PEGASUS_COMMON_LINKAGE Boolean operator!=(const char* s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator<(const String& s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator<(const String& s1, const char* s2);

PEGASUS_COMMON_LINKAGE Boolean operator<(const char* s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator>(const String& s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator>(const String& s1, const char* s2);

PEGASUS_COMMON_LINKAGE Boolean operator>(const char* s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator<=(const String& s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator<=(const String& s1, const char* s2);

PEGASUS_COMMON_LINKAGE Boolean operator<=(const char* s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator>=(const String& s1, const String& s2);

PEGASUS_COMMON_LINKAGE Boolean operator>=(const String& s1, const char* s2);

PEGASUS_COMMON_LINKAGE Boolean operator>=(const char* s1, const String& s2);

PEGASUS_COMMON_LINKAGE String operator+(const String& s1, const String& s2);

PEGASUS_COMMON_LINKAGE String operator+(const String& s1, const char* s2);

PEGASUS_COMMON_LINKAGE String operator+(const char* s1, const String& s2);

#endif /* PEGASUS_USE_EXPERIMENTAL_INTERFACES */

PEGASUS_NAMESPACE_END

#if defined(PEGASUS_INTERNALONLY) && !defined(PEGASUS_DISABLE_INTERNAL_INLINES)
# include "StringInline.h"
#endif

#endif /* Pegasus_String_h */