From f563b72b3879380dc314abdee194145bff509dfc Mon Sep 17 00:00:00 2001 From: "scc%netscape.com" Date: Fri, 31 Mar 2000 07:26:13 +0000 Subject: [PATCH] more work bringing |ns[C]String| into line with the new implementations. Again, this is no change when |NEW_STRING_APIS| is not defined. --- string/obsolete/nsStr.cpp | 4 +- string/obsolete/nsStr.h | 30 ++++++---- string/obsolete/nsString.cpp | 68 +++++++++++---------- string/obsolete/nsString.h | 66 ++++++++++++++------- string/obsolete/nsString2.cpp | 92 +++++++++++++++-------------- string/obsolete/nsString2.h | 80 +++++++++++++++++-------- xpcom/ds/nsStr.cpp | 4 +- xpcom/ds/nsStr.h | 30 ++++++---- xpcom/ds/nsString.cpp | 68 +++++++++++---------- xpcom/ds/nsString.h | 66 ++++++++++++++------- xpcom/ds/nsString2.cpp | 92 +++++++++++++++-------------- xpcom/ds/nsString2.h | 80 +++++++++++++++++-------- xpcom/string/obsolete/nsStr.cpp | 4 +- xpcom/string/obsolete/nsStr.h | 30 ++++++---- xpcom/string/obsolete/nsString.cpp | 68 +++++++++++---------- xpcom/string/obsolete/nsString.h | 66 ++++++++++++++------- xpcom/string/obsolete/nsString2.cpp | 92 +++++++++++++++-------------- xpcom/string/obsolete/nsString2.h | 80 +++++++++++++++++-------- 18 files changed, 606 insertions(+), 414 deletions(-) diff --git a/string/obsolete/nsStr.cpp b/string/obsolete/nsStr.cpp index 3b53abe65970..75097714abb3 100644 --- a/string/obsolete/nsStr.cpp +++ b/string/obsolete/nsStr.cpp @@ -592,7 +592,7 @@ PRInt32 nsStr::RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnor * @param aIgnorecase tells us whether to search with case sensitivity * @return aDestaSource=1 */ -PRInt32 nsStr::Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) { +PRInt32 nsStr::StrCompare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) { PRInt32 result=0; if(aCount) { @@ -850,7 +850,7 @@ nsStr_Compare(const void *v1, const void *v2) { nsStr* str1 = (nsStr*)v1; nsStr* str2 = (nsStr*)v2; - return nsStr::Compare(*str1, *str2, -1, PR_FALSE) == 0; + return nsStr::StrCompare(*str1, *str2, -1, PR_FALSE) == 0; } nsStringInfo* diff --git a/string/obsolete/nsStr.h b/string/obsolete/nsStr.h index 0b7ef49e7d41..cb7cd218769e 100644 --- a/string/obsolete/nsStr.h +++ b/string/obsolete/nsStr.h @@ -310,18 +310,6 @@ struct NS_COM nsStr { */ static void StrInsert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount); -#ifndef NEW_STRING_APIS - static void Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { - StrAppend(aDest, aSource, anOffset, aCount); - } - static void Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { - StrAssign(aDest, aSource, anOffset, aCount); - } - static void Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount) { - StrInsert(aDest, aDestOffset, aSource, aSrcOffset, aCount); - } -#endif - /** * This method deletes chars from the given str. * The given allocator may choose to resize the str as well. @@ -402,7 +390,7 @@ struct NS_COM nsStr { * @param aIgnorecase tells us whether to use a case-sensitive comparison * @return -1,0,1 depending on <,==,> */ - static PRInt32 Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase); + static PRInt32 StrCompare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase); /** * These methods scan the given string for 1 or more chars in a given direction @@ -431,6 +419,22 @@ struct NS_COM nsStr { */ static PRUint32 HashCode(const nsStr& aDest); + +#ifndef NEW_STRING_APIS + static void Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { + StrAppend(aDest, aSource, anOffset, aCount); + } + static void Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { + StrAssign(aDest, aSource, anOffset, aCount); + } + static void Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount) { + StrInsert(aDest, aDestOffset, aSource, aSrcOffset, aCount); + } + static PRInt32 Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) { + return StrCompare(aDest, aSource, aCount, aIgnoreCase); + } +#endif + #ifdef NS_STR_STATS /** * Prints an nsStr. If truncate is true, the string is only printed up to diff --git a/string/obsolete/nsString.cpp b/string/obsolete/nsString.cpp index 7f1fcc2eb07f..3475210fc928 100644 --- a/string/obsolete/nsString.cpp +++ b/string/obsolete/nsString.cpp @@ -1518,27 +1518,6 @@ PRInt32 nsCString::RFindCharInSet(const nsStr& aSet,PRInt32 anOffset) const{ **************************************************************/ -/** - * Compares given cstring to this string. - * @update gess 01/04/99 - * @param aCString points to a cstring - * @param aIgnoreCase tells us how to treat case - * @param aCount tells us how many chars to test; -1 implies full length - * @return -1,0,1 - */ -PRInt32 nsCString::Compare(const char *aCString,PRBool aIgnoreCase,PRInt32 aCount) const { - NS_ASSERTION(0!=aCString,kNullPointerError); - - if(aCString) { - nsStr temp; - nsStr::Initialize(temp,eOneByte); - temp.mLength=nsCRT::strlen(aCString); - temp.mStr=(char*)aCString; - return nsStr::Compare(*this,temp,aCount,aIgnoreCase); - } - return 0; -} - /** * Compares given unistring to this string. * @update gess 01/04/99 @@ -1547,7 +1526,7 @@ PRInt32 nsCString::Compare(const char *aCString,PRBool aIgnoreCase,PRInt32 aCoun * @param aCount tells us how many chars to test; -1 implies full length * @return -1,0,1 */ -PRInt32 nsCString::Compare(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { +PRInt32 nsCString::CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { NS_ASSERTION(0!=aString,kNullPointerError); if(aString) { @@ -1555,11 +1534,33 @@ PRInt32 nsCString::Compare(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 a nsStr::Initialize(temp,eTwoByte); temp.mLength=nsCRT::strlen(aString); temp.mUStr=(PRUnichar*)aString; - return nsStr::Compare(*this,temp,aCount,aIgnoreCase); + return nsStr::StrCompare(*this,temp,aCount,aIgnoreCase); } return 0; } +/** + * Compares given cstring to this string. + * @update gess 01/04/99 + * @param aCString points to a cstring + * @param aIgnoreCase tells us how to treat case + * @param aCount tells us how many chars to test; -1 implies full length + * @return -1,0,1 + */ +PRInt32 nsCString::CompareWithConversion(const char *aCString,PRBool aIgnoreCase,PRInt32 aCount) const { + NS_ASSERTION(0!=aCString,kNullPointerError); + + if(aCString) { + nsStr temp; + nsStr::Initialize(temp,eOneByte); + temp.mLength=nsCRT::strlen(aCString); + temp.mStr=(char*)aCString; + return nsStr::StrCompare(*this,temp,aCount,aIgnoreCase); + } + return 0; +} + +#ifndef NEW_STRING_APIS /** * Compare given nsStr with this cstring. * @@ -1569,8 +1570,9 @@ PRInt32 nsCString::Compare(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 a * @return -1,0,1 */ PRInt32 nsCString::Compare(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - return nsStr::Compare(*this,aString,aCount,aIgnoreCase); + return nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); } +#endif #ifndef NEW_STRING_APIS /** @@ -1601,19 +1603,22 @@ PRBool nsCString::operator>=(const char* s) const {return PRBool(Compare(s)>=0); PRBool nsCString::operator>=(const PRUnichar* s) const {return PRBool(Compare(s)>=0);} #endif +#ifndef NEW_STRING_APIS PRBool nsCString::EqualsIgnoreCase(const nsStr& aString) const { return Equals(aString,PR_TRUE); } +#endif PRBool nsCString::EqualsIgnoreCase(const char* aString,PRInt32 aLength) const { - return Equals(aString,PR_TRUE,aLength); + return EqualsWithConversion(aString,PR_TRUE,aLength); } PRBool nsCString::EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aLength) const { - return Equals(aString,PR_TRUE,aLength); + return EqualsWithConversion(aString,PR_TRUE,aLength); } +#ifndef NEW_STRING_APIS /** * Compare this to given string; note that we compare full strings here. * @@ -1624,10 +1629,11 @@ PRBool nsCString::EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aLength) con * @return TRUE if equal */ PRBool nsCString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=nsStr::Compare(*this,aString,aCount,aIgnoreCase); + PRInt32 theAnswer=nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); PRBool result=PRBool(0==theAnswer); return result; } +#endif /** * Compare this to given string; note that we compare full strings here. @@ -1638,14 +1644,14 @@ PRBool nsCString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsCString::Equals(const char* aCString,PRBool aIgnoreCase,PRInt32 aCount) const{ - PRInt32 theAnswer=Compare(aCString,aIgnoreCase,aCount); +PRBool nsCString::EqualsWithConversion(const char* aCString,PRBool aIgnoreCase,PRInt32 aCount) const{ + PRInt32 theAnswer=CompareWithConversion(aCString,aIgnoreCase,aCount); PRBool result=PRBool(0==theAnswer); return result; } -PRBool nsCString::Equals(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=Compare(aString,aIgnoreCase,aCount); +PRBool nsCString::EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=CompareWithConversion(aString,aIgnoreCase,aCount); PRBool result=PRBool(0==theAnswer); return result; } diff --git a/string/obsolete/nsString.h b/string/obsolete/nsString.h index 26f0abfcfb72..d6f79db21907 100644 --- a/string/obsolete/nsString.h +++ b/string/obsolete/nsString.h @@ -655,11 +655,52 @@ public: * @param aCount tells us how many chars to compare * @return -1,0,1 */ - virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; + PRBool EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aCount=-1) const; #ifndef NEW_STRING_APIS + virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + /** + * Compare this to given string; note that we compare full strings here. + * The optional length argument just lets us know how long the given string is. + * If you provide a length, it is compared to length of this string as an + * optimization. + * + * @param aString -- the string to compare to this + * @param aCount -- number of chars in given string you want to compare + * @return TRUE if equal + */ + PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsIgnoreCase(const nsStr& aString) const; + /** * These methods compare a given string type to this one * @param aString is the string to be compared to this @@ -715,25 +756,6 @@ public: PRBool operator>=(const PRUnichar* aString) const; #endif // !defined(NEW_STRING_APIS) - /** - * Compare this to given string; note that we compare full strings here. - * The optional length argument just lets us know how long the given string is. - * If you provide a length, it is compared to length of this string as an - * optimization. - * - * @param aString -- the string to compare to this - * @param aCount -- number of chars in given string you want to compare - * @return TRUE if equal - */ - PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - - PRBool EqualsIgnoreCase(const nsStr& aString) const; - PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; - PRBool EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aCount=-1) const; - void DebugDump(void) const; diff --git a/string/obsolete/nsString2.cpp b/string/obsolete/nsString2.cpp index 517f5381e46d..c97cbc58a07f 100644 --- a/string/obsolete/nsString2.cpp +++ b/string/obsolete/nsString2.cpp @@ -1807,9 +1807,20 @@ PRInt32 nsString::RFindCharInSet(const PRUnichar* aStringSet,PRInt32 anOffset) c * @param aCount tells us how many chars to test; -1 implies full length * @return -1,0,1 */ -PRInt32 nsString::Compare(const nsString& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 result=nsStr::Compare(*this,aString,aCount,aIgnoreCase); - return result; +PRInt32 nsString::CompareWithConversion(const char *aCString,PRBool aIgnoreCase,PRInt32 aCount) const { + NS_ASSERTION(0!=aCString,kNullPointerError); + + if(aCString) { + nsStr temp; + nsStr::Initialize(temp,eOneByte); + + temp.mLength= (0=(const PRUnichar* s) const {return PRBool(Compare(s)> #endif // !defined(NEW_STRING_APIS) PRBool nsString::EqualsIgnoreCase(const nsString& aString) const { - return Equals(aString,PR_TRUE); + return EqualsWithConversion(aString,PR_TRUE); } PRBool nsString::EqualsIgnoreCase(const char* aString,PRInt32 aLength) const { - return Equals(aString,PR_TRUE,aLength); + return EqualsWithConversion(aString,PR_TRUE,aLength); } +#ifndef NEW_STRING_APIS PRBool nsString::EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const { return Equals(aAtom,PR_TRUE); } @@ -1922,7 +1924,7 @@ PRBool nsString::EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const { PRBool nsString::EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const { return Equals(s1,s2,PR_TRUE); } - +#endif /** * Compare this to given string; note that we compare full strings here. @@ -1932,27 +1934,13 @@ PRBool nsString::EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) cons * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsString::Equals(const nsString& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=nsStr::Compare(*this,aString,aCount,aIgnoreCase); +PRBool nsString::EqualsWithConversion(const nsString& aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); PRBool result=PRBool(0==theAnswer); return result; } -/** - * Compare this to given string; note that we compare full strings here. - * - * @update gess 01/04/99 - * @param aString is the other nsString to be compared to - * @param aCount tells us how many chars to test; -1 implies full length - * @return TRUE if equal - */ -PRBool nsString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=nsStr::Compare(*this,aString,aCount,aIgnoreCase); - PRBool result=PRBool(0==theAnswer); - return result; -} - /** * Compare this to given c-string; note that we compare full strings here. * @@ -1961,8 +1949,8 @@ PRBool nsString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsString::Equals(const char* aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=Compare(aString,aIgnoreCase,aCount); +PRBool nsString::EqualsWithConversion(const char* aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=CompareWithConversion(aString,aIgnoreCase,aCount); PRBool result=PRBool(0==theAnswer); return result; } @@ -1975,8 +1963,23 @@ PRBool nsString::Equals(const char* aString,PRBool aIgnoreCase,PRInt32 aCount) c * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsString::Equals(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=Compare(aString,aIgnoreCase,aCount); +PRBool nsString::EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=CompareWithConversion(aString,aIgnoreCase,aCount); + PRBool result=PRBool(0==theAnswer); + return result; +} + +#ifndef NEW_STRING_APIS +/** + * Compare this to given string; note that we compare full strings here. + * + * @update gess 01/04/99 + * @param aString is the other nsString to be compared to + * @param aCount tells us how many chars to test; -1 implies full length + * @return TRUE if equal + */ +PRBool nsString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); PRBool result=PRBool(0==theAnswer); return result; } @@ -2028,6 +2031,7 @@ PRBool nsString::Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreC return result; } +#endif /** * Determine if given char in valid alpha range diff --git a/string/obsolete/nsString2.h b/string/obsolete/nsString2.h index 526d69b928f0..01ebb5b5e1d5 100644 --- a/string/obsolete/nsString2.h +++ b/string/obsolete/nsString2.h @@ -709,12 +709,62 @@ public: * @param aCount tells us how many chars to compare * @return -1,0,1 */ - virtual PRInt32 Compare(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsIgnoreCase(const nsString& aString) const; + PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; + PRBool EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const; + PRBool EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const; #ifndef NEW_STRING_APIS + virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + + /** + * Compare this to given string; note that we compare full strings here. + * The optional length argument just lets us know how long the given string is. + * If you provide a length, it is compared to length of this string as an + * optimization. + * + * @param aString -- the string to compare to this + * @param aCount -- number of chars to be compared. + * @return TRUE if equal + */ + PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(/*FIX: const */nsIAtom* anAtom,PRBool aIgnoreCase) const; + PRBool Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreCase=PR_FALSE) const; + PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + /** * These methods compare a given string type to this one * @param aString is the string to be compared to this @@ -776,28 +826,6 @@ public: PRBool operator>=(const PRUnichar* aString) const; #endif // !defined(NEW_STRING_APIS) - /** - * Compare this to given string; note that we compare full strings here. - * The optional length argument just lets us know how long the given string is. - * If you provide a length, it is compared to length of this string as an - * optimization. - * - * @param aString -- the string to compare to this - * @param aCount -- number of chars to be compared. - * @return TRUE if equal - */ - PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(/*FIX: const */nsIAtom* anAtom,PRBool aIgnoreCase) const; - PRBool Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreCase=PR_FALSE) const; - - PRBool EqualsIgnoreCase(const nsString& aString) const; - PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; - PRBool EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const; - PRBool EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const; - /** * Determine if given buffer is plain ascii * diff --git a/xpcom/ds/nsStr.cpp b/xpcom/ds/nsStr.cpp index 3b53abe65970..75097714abb3 100644 --- a/xpcom/ds/nsStr.cpp +++ b/xpcom/ds/nsStr.cpp @@ -592,7 +592,7 @@ PRInt32 nsStr::RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnor * @param aIgnorecase tells us whether to search with case sensitivity * @return aDestaSource=1 */ -PRInt32 nsStr::Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) { +PRInt32 nsStr::StrCompare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) { PRInt32 result=0; if(aCount) { @@ -850,7 +850,7 @@ nsStr_Compare(const void *v1, const void *v2) { nsStr* str1 = (nsStr*)v1; nsStr* str2 = (nsStr*)v2; - return nsStr::Compare(*str1, *str2, -1, PR_FALSE) == 0; + return nsStr::StrCompare(*str1, *str2, -1, PR_FALSE) == 0; } nsStringInfo* diff --git a/xpcom/ds/nsStr.h b/xpcom/ds/nsStr.h index 0b7ef49e7d41..cb7cd218769e 100644 --- a/xpcom/ds/nsStr.h +++ b/xpcom/ds/nsStr.h @@ -310,18 +310,6 @@ struct NS_COM nsStr { */ static void StrInsert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount); -#ifndef NEW_STRING_APIS - static void Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { - StrAppend(aDest, aSource, anOffset, aCount); - } - static void Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { - StrAssign(aDest, aSource, anOffset, aCount); - } - static void Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount) { - StrInsert(aDest, aDestOffset, aSource, aSrcOffset, aCount); - } -#endif - /** * This method deletes chars from the given str. * The given allocator may choose to resize the str as well. @@ -402,7 +390,7 @@ struct NS_COM nsStr { * @param aIgnorecase tells us whether to use a case-sensitive comparison * @return -1,0,1 depending on <,==,> */ - static PRInt32 Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase); + static PRInt32 StrCompare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase); /** * These methods scan the given string for 1 or more chars in a given direction @@ -431,6 +419,22 @@ struct NS_COM nsStr { */ static PRUint32 HashCode(const nsStr& aDest); + +#ifndef NEW_STRING_APIS + static void Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { + StrAppend(aDest, aSource, anOffset, aCount); + } + static void Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { + StrAssign(aDest, aSource, anOffset, aCount); + } + static void Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount) { + StrInsert(aDest, aDestOffset, aSource, aSrcOffset, aCount); + } + static PRInt32 Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) { + return StrCompare(aDest, aSource, aCount, aIgnoreCase); + } +#endif + #ifdef NS_STR_STATS /** * Prints an nsStr. If truncate is true, the string is only printed up to diff --git a/xpcom/ds/nsString.cpp b/xpcom/ds/nsString.cpp index 7f1fcc2eb07f..3475210fc928 100644 --- a/xpcom/ds/nsString.cpp +++ b/xpcom/ds/nsString.cpp @@ -1518,27 +1518,6 @@ PRInt32 nsCString::RFindCharInSet(const nsStr& aSet,PRInt32 anOffset) const{ **************************************************************/ -/** - * Compares given cstring to this string. - * @update gess 01/04/99 - * @param aCString points to a cstring - * @param aIgnoreCase tells us how to treat case - * @param aCount tells us how many chars to test; -1 implies full length - * @return -1,0,1 - */ -PRInt32 nsCString::Compare(const char *aCString,PRBool aIgnoreCase,PRInt32 aCount) const { - NS_ASSERTION(0!=aCString,kNullPointerError); - - if(aCString) { - nsStr temp; - nsStr::Initialize(temp,eOneByte); - temp.mLength=nsCRT::strlen(aCString); - temp.mStr=(char*)aCString; - return nsStr::Compare(*this,temp,aCount,aIgnoreCase); - } - return 0; -} - /** * Compares given unistring to this string. * @update gess 01/04/99 @@ -1547,7 +1526,7 @@ PRInt32 nsCString::Compare(const char *aCString,PRBool aIgnoreCase,PRInt32 aCoun * @param aCount tells us how many chars to test; -1 implies full length * @return -1,0,1 */ -PRInt32 nsCString::Compare(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { +PRInt32 nsCString::CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { NS_ASSERTION(0!=aString,kNullPointerError); if(aString) { @@ -1555,11 +1534,33 @@ PRInt32 nsCString::Compare(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 a nsStr::Initialize(temp,eTwoByte); temp.mLength=nsCRT::strlen(aString); temp.mUStr=(PRUnichar*)aString; - return nsStr::Compare(*this,temp,aCount,aIgnoreCase); + return nsStr::StrCompare(*this,temp,aCount,aIgnoreCase); } return 0; } +/** + * Compares given cstring to this string. + * @update gess 01/04/99 + * @param aCString points to a cstring + * @param aIgnoreCase tells us how to treat case + * @param aCount tells us how many chars to test; -1 implies full length + * @return -1,0,1 + */ +PRInt32 nsCString::CompareWithConversion(const char *aCString,PRBool aIgnoreCase,PRInt32 aCount) const { + NS_ASSERTION(0!=aCString,kNullPointerError); + + if(aCString) { + nsStr temp; + nsStr::Initialize(temp,eOneByte); + temp.mLength=nsCRT::strlen(aCString); + temp.mStr=(char*)aCString; + return nsStr::StrCompare(*this,temp,aCount,aIgnoreCase); + } + return 0; +} + +#ifndef NEW_STRING_APIS /** * Compare given nsStr with this cstring. * @@ -1569,8 +1570,9 @@ PRInt32 nsCString::Compare(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 a * @return -1,0,1 */ PRInt32 nsCString::Compare(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - return nsStr::Compare(*this,aString,aCount,aIgnoreCase); + return nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); } +#endif #ifndef NEW_STRING_APIS /** @@ -1601,19 +1603,22 @@ PRBool nsCString::operator>=(const char* s) const {return PRBool(Compare(s)>=0); PRBool nsCString::operator>=(const PRUnichar* s) const {return PRBool(Compare(s)>=0);} #endif +#ifndef NEW_STRING_APIS PRBool nsCString::EqualsIgnoreCase(const nsStr& aString) const { return Equals(aString,PR_TRUE); } +#endif PRBool nsCString::EqualsIgnoreCase(const char* aString,PRInt32 aLength) const { - return Equals(aString,PR_TRUE,aLength); + return EqualsWithConversion(aString,PR_TRUE,aLength); } PRBool nsCString::EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aLength) const { - return Equals(aString,PR_TRUE,aLength); + return EqualsWithConversion(aString,PR_TRUE,aLength); } +#ifndef NEW_STRING_APIS /** * Compare this to given string; note that we compare full strings here. * @@ -1624,10 +1629,11 @@ PRBool nsCString::EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aLength) con * @return TRUE if equal */ PRBool nsCString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=nsStr::Compare(*this,aString,aCount,aIgnoreCase); + PRInt32 theAnswer=nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); PRBool result=PRBool(0==theAnswer); return result; } +#endif /** * Compare this to given string; note that we compare full strings here. @@ -1638,14 +1644,14 @@ PRBool nsCString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsCString::Equals(const char* aCString,PRBool aIgnoreCase,PRInt32 aCount) const{ - PRInt32 theAnswer=Compare(aCString,aIgnoreCase,aCount); +PRBool nsCString::EqualsWithConversion(const char* aCString,PRBool aIgnoreCase,PRInt32 aCount) const{ + PRInt32 theAnswer=CompareWithConversion(aCString,aIgnoreCase,aCount); PRBool result=PRBool(0==theAnswer); return result; } -PRBool nsCString::Equals(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=Compare(aString,aIgnoreCase,aCount); +PRBool nsCString::EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=CompareWithConversion(aString,aIgnoreCase,aCount); PRBool result=PRBool(0==theAnswer); return result; } diff --git a/xpcom/ds/nsString.h b/xpcom/ds/nsString.h index 26f0abfcfb72..d6f79db21907 100644 --- a/xpcom/ds/nsString.h +++ b/xpcom/ds/nsString.h @@ -655,11 +655,52 @@ public: * @param aCount tells us how many chars to compare * @return -1,0,1 */ - virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; + PRBool EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aCount=-1) const; #ifndef NEW_STRING_APIS + virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + /** + * Compare this to given string; note that we compare full strings here. + * The optional length argument just lets us know how long the given string is. + * If you provide a length, it is compared to length of this string as an + * optimization. + * + * @param aString -- the string to compare to this + * @param aCount -- number of chars in given string you want to compare + * @return TRUE if equal + */ + PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsIgnoreCase(const nsStr& aString) const; + /** * These methods compare a given string type to this one * @param aString is the string to be compared to this @@ -715,25 +756,6 @@ public: PRBool operator>=(const PRUnichar* aString) const; #endif // !defined(NEW_STRING_APIS) - /** - * Compare this to given string; note that we compare full strings here. - * The optional length argument just lets us know how long the given string is. - * If you provide a length, it is compared to length of this string as an - * optimization. - * - * @param aString -- the string to compare to this - * @param aCount -- number of chars in given string you want to compare - * @return TRUE if equal - */ - PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - - PRBool EqualsIgnoreCase(const nsStr& aString) const; - PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; - PRBool EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aCount=-1) const; - void DebugDump(void) const; diff --git a/xpcom/ds/nsString2.cpp b/xpcom/ds/nsString2.cpp index 517f5381e46d..c97cbc58a07f 100644 --- a/xpcom/ds/nsString2.cpp +++ b/xpcom/ds/nsString2.cpp @@ -1807,9 +1807,20 @@ PRInt32 nsString::RFindCharInSet(const PRUnichar* aStringSet,PRInt32 anOffset) c * @param aCount tells us how many chars to test; -1 implies full length * @return -1,0,1 */ -PRInt32 nsString::Compare(const nsString& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 result=nsStr::Compare(*this,aString,aCount,aIgnoreCase); - return result; +PRInt32 nsString::CompareWithConversion(const char *aCString,PRBool aIgnoreCase,PRInt32 aCount) const { + NS_ASSERTION(0!=aCString,kNullPointerError); + + if(aCString) { + nsStr temp; + nsStr::Initialize(temp,eOneByte); + + temp.mLength= (0=(const PRUnichar* s) const {return PRBool(Compare(s)> #endif // !defined(NEW_STRING_APIS) PRBool nsString::EqualsIgnoreCase(const nsString& aString) const { - return Equals(aString,PR_TRUE); + return EqualsWithConversion(aString,PR_TRUE); } PRBool nsString::EqualsIgnoreCase(const char* aString,PRInt32 aLength) const { - return Equals(aString,PR_TRUE,aLength); + return EqualsWithConversion(aString,PR_TRUE,aLength); } +#ifndef NEW_STRING_APIS PRBool nsString::EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const { return Equals(aAtom,PR_TRUE); } @@ -1922,7 +1924,7 @@ PRBool nsString::EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const { PRBool nsString::EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const { return Equals(s1,s2,PR_TRUE); } - +#endif /** * Compare this to given string; note that we compare full strings here. @@ -1932,27 +1934,13 @@ PRBool nsString::EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) cons * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsString::Equals(const nsString& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=nsStr::Compare(*this,aString,aCount,aIgnoreCase); +PRBool nsString::EqualsWithConversion(const nsString& aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); PRBool result=PRBool(0==theAnswer); return result; } -/** - * Compare this to given string; note that we compare full strings here. - * - * @update gess 01/04/99 - * @param aString is the other nsString to be compared to - * @param aCount tells us how many chars to test; -1 implies full length - * @return TRUE if equal - */ -PRBool nsString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=nsStr::Compare(*this,aString,aCount,aIgnoreCase); - PRBool result=PRBool(0==theAnswer); - return result; -} - /** * Compare this to given c-string; note that we compare full strings here. * @@ -1961,8 +1949,8 @@ PRBool nsString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsString::Equals(const char* aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=Compare(aString,aIgnoreCase,aCount); +PRBool nsString::EqualsWithConversion(const char* aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=CompareWithConversion(aString,aIgnoreCase,aCount); PRBool result=PRBool(0==theAnswer); return result; } @@ -1975,8 +1963,23 @@ PRBool nsString::Equals(const char* aString,PRBool aIgnoreCase,PRInt32 aCount) c * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsString::Equals(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=Compare(aString,aIgnoreCase,aCount); +PRBool nsString::EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=CompareWithConversion(aString,aIgnoreCase,aCount); + PRBool result=PRBool(0==theAnswer); + return result; +} + +#ifndef NEW_STRING_APIS +/** + * Compare this to given string; note that we compare full strings here. + * + * @update gess 01/04/99 + * @param aString is the other nsString to be compared to + * @param aCount tells us how many chars to test; -1 implies full length + * @return TRUE if equal + */ +PRBool nsString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); PRBool result=PRBool(0==theAnswer); return result; } @@ -2028,6 +2031,7 @@ PRBool nsString::Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreC return result; } +#endif /** * Determine if given char in valid alpha range diff --git a/xpcom/ds/nsString2.h b/xpcom/ds/nsString2.h index 526d69b928f0..01ebb5b5e1d5 100644 --- a/xpcom/ds/nsString2.h +++ b/xpcom/ds/nsString2.h @@ -709,12 +709,62 @@ public: * @param aCount tells us how many chars to compare * @return -1,0,1 */ - virtual PRInt32 Compare(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsIgnoreCase(const nsString& aString) const; + PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; + PRBool EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const; + PRBool EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const; #ifndef NEW_STRING_APIS + virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + + /** + * Compare this to given string; note that we compare full strings here. + * The optional length argument just lets us know how long the given string is. + * If you provide a length, it is compared to length of this string as an + * optimization. + * + * @param aString -- the string to compare to this + * @param aCount -- number of chars to be compared. + * @return TRUE if equal + */ + PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(/*FIX: const */nsIAtom* anAtom,PRBool aIgnoreCase) const; + PRBool Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreCase=PR_FALSE) const; + PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + /** * These methods compare a given string type to this one * @param aString is the string to be compared to this @@ -776,28 +826,6 @@ public: PRBool operator>=(const PRUnichar* aString) const; #endif // !defined(NEW_STRING_APIS) - /** - * Compare this to given string; note that we compare full strings here. - * The optional length argument just lets us know how long the given string is. - * If you provide a length, it is compared to length of this string as an - * optimization. - * - * @param aString -- the string to compare to this - * @param aCount -- number of chars to be compared. - * @return TRUE if equal - */ - PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(/*FIX: const */nsIAtom* anAtom,PRBool aIgnoreCase) const; - PRBool Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreCase=PR_FALSE) const; - - PRBool EqualsIgnoreCase(const nsString& aString) const; - PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; - PRBool EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const; - PRBool EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const; - /** * Determine if given buffer is plain ascii * diff --git a/xpcom/string/obsolete/nsStr.cpp b/xpcom/string/obsolete/nsStr.cpp index 3b53abe65970..75097714abb3 100644 --- a/xpcom/string/obsolete/nsStr.cpp +++ b/xpcom/string/obsolete/nsStr.cpp @@ -592,7 +592,7 @@ PRInt32 nsStr::RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnor * @param aIgnorecase tells us whether to search with case sensitivity * @return aDestaSource=1 */ -PRInt32 nsStr::Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) { +PRInt32 nsStr::StrCompare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) { PRInt32 result=0; if(aCount) { @@ -850,7 +850,7 @@ nsStr_Compare(const void *v1, const void *v2) { nsStr* str1 = (nsStr*)v1; nsStr* str2 = (nsStr*)v2; - return nsStr::Compare(*str1, *str2, -1, PR_FALSE) == 0; + return nsStr::StrCompare(*str1, *str2, -1, PR_FALSE) == 0; } nsStringInfo* diff --git a/xpcom/string/obsolete/nsStr.h b/xpcom/string/obsolete/nsStr.h index 0b7ef49e7d41..cb7cd218769e 100644 --- a/xpcom/string/obsolete/nsStr.h +++ b/xpcom/string/obsolete/nsStr.h @@ -310,18 +310,6 @@ struct NS_COM nsStr { */ static void StrInsert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount); -#ifndef NEW_STRING_APIS - static void Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { - StrAppend(aDest, aSource, anOffset, aCount); - } - static void Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { - StrAssign(aDest, aSource, anOffset, aCount); - } - static void Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount) { - StrInsert(aDest, aDestOffset, aSource, aSrcOffset, aCount); - } -#endif - /** * This method deletes chars from the given str. * The given allocator may choose to resize the str as well. @@ -402,7 +390,7 @@ struct NS_COM nsStr { * @param aIgnorecase tells us whether to use a case-sensitive comparison * @return -1,0,1 depending on <,==,> */ - static PRInt32 Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase); + static PRInt32 StrCompare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase); /** * These methods scan the given string for 1 or more chars in a given direction @@ -431,6 +419,22 @@ struct NS_COM nsStr { */ static PRUint32 HashCode(const nsStr& aDest); + +#ifndef NEW_STRING_APIS + static void Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { + StrAppend(aDest, aSource, anOffset, aCount); + } + static void Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount) { + StrAssign(aDest, aSource, anOffset, aCount); + } + static void Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount) { + StrInsert(aDest, aDestOffset, aSource, aSrcOffset, aCount); + } + static PRInt32 Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) { + return StrCompare(aDest, aSource, aCount, aIgnoreCase); + } +#endif + #ifdef NS_STR_STATS /** * Prints an nsStr. If truncate is true, the string is only printed up to diff --git a/xpcom/string/obsolete/nsString.cpp b/xpcom/string/obsolete/nsString.cpp index 7f1fcc2eb07f..3475210fc928 100644 --- a/xpcom/string/obsolete/nsString.cpp +++ b/xpcom/string/obsolete/nsString.cpp @@ -1518,27 +1518,6 @@ PRInt32 nsCString::RFindCharInSet(const nsStr& aSet,PRInt32 anOffset) const{ **************************************************************/ -/** - * Compares given cstring to this string. - * @update gess 01/04/99 - * @param aCString points to a cstring - * @param aIgnoreCase tells us how to treat case - * @param aCount tells us how many chars to test; -1 implies full length - * @return -1,0,1 - */ -PRInt32 nsCString::Compare(const char *aCString,PRBool aIgnoreCase,PRInt32 aCount) const { - NS_ASSERTION(0!=aCString,kNullPointerError); - - if(aCString) { - nsStr temp; - nsStr::Initialize(temp,eOneByte); - temp.mLength=nsCRT::strlen(aCString); - temp.mStr=(char*)aCString; - return nsStr::Compare(*this,temp,aCount,aIgnoreCase); - } - return 0; -} - /** * Compares given unistring to this string. * @update gess 01/04/99 @@ -1547,7 +1526,7 @@ PRInt32 nsCString::Compare(const char *aCString,PRBool aIgnoreCase,PRInt32 aCoun * @param aCount tells us how many chars to test; -1 implies full length * @return -1,0,1 */ -PRInt32 nsCString::Compare(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { +PRInt32 nsCString::CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { NS_ASSERTION(0!=aString,kNullPointerError); if(aString) { @@ -1555,11 +1534,33 @@ PRInt32 nsCString::Compare(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 a nsStr::Initialize(temp,eTwoByte); temp.mLength=nsCRT::strlen(aString); temp.mUStr=(PRUnichar*)aString; - return nsStr::Compare(*this,temp,aCount,aIgnoreCase); + return nsStr::StrCompare(*this,temp,aCount,aIgnoreCase); } return 0; } +/** + * Compares given cstring to this string. + * @update gess 01/04/99 + * @param aCString points to a cstring + * @param aIgnoreCase tells us how to treat case + * @param aCount tells us how many chars to test; -1 implies full length + * @return -1,0,1 + */ +PRInt32 nsCString::CompareWithConversion(const char *aCString,PRBool aIgnoreCase,PRInt32 aCount) const { + NS_ASSERTION(0!=aCString,kNullPointerError); + + if(aCString) { + nsStr temp; + nsStr::Initialize(temp,eOneByte); + temp.mLength=nsCRT::strlen(aCString); + temp.mStr=(char*)aCString; + return nsStr::StrCompare(*this,temp,aCount,aIgnoreCase); + } + return 0; +} + +#ifndef NEW_STRING_APIS /** * Compare given nsStr with this cstring. * @@ -1569,8 +1570,9 @@ PRInt32 nsCString::Compare(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 a * @return -1,0,1 */ PRInt32 nsCString::Compare(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - return nsStr::Compare(*this,aString,aCount,aIgnoreCase); + return nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); } +#endif #ifndef NEW_STRING_APIS /** @@ -1601,19 +1603,22 @@ PRBool nsCString::operator>=(const char* s) const {return PRBool(Compare(s)>=0); PRBool nsCString::operator>=(const PRUnichar* s) const {return PRBool(Compare(s)>=0);} #endif +#ifndef NEW_STRING_APIS PRBool nsCString::EqualsIgnoreCase(const nsStr& aString) const { return Equals(aString,PR_TRUE); } +#endif PRBool nsCString::EqualsIgnoreCase(const char* aString,PRInt32 aLength) const { - return Equals(aString,PR_TRUE,aLength); + return EqualsWithConversion(aString,PR_TRUE,aLength); } PRBool nsCString::EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aLength) const { - return Equals(aString,PR_TRUE,aLength); + return EqualsWithConversion(aString,PR_TRUE,aLength); } +#ifndef NEW_STRING_APIS /** * Compare this to given string; note that we compare full strings here. * @@ -1624,10 +1629,11 @@ PRBool nsCString::EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aLength) con * @return TRUE if equal */ PRBool nsCString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=nsStr::Compare(*this,aString,aCount,aIgnoreCase); + PRInt32 theAnswer=nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); PRBool result=PRBool(0==theAnswer); return result; } +#endif /** * Compare this to given string; note that we compare full strings here. @@ -1638,14 +1644,14 @@ PRBool nsCString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsCString::Equals(const char* aCString,PRBool aIgnoreCase,PRInt32 aCount) const{ - PRInt32 theAnswer=Compare(aCString,aIgnoreCase,aCount); +PRBool nsCString::EqualsWithConversion(const char* aCString,PRBool aIgnoreCase,PRInt32 aCount) const{ + PRInt32 theAnswer=CompareWithConversion(aCString,aIgnoreCase,aCount); PRBool result=PRBool(0==theAnswer); return result; } -PRBool nsCString::Equals(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=Compare(aString,aIgnoreCase,aCount); +PRBool nsCString::EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=CompareWithConversion(aString,aIgnoreCase,aCount); PRBool result=PRBool(0==theAnswer); return result; } diff --git a/xpcom/string/obsolete/nsString.h b/xpcom/string/obsolete/nsString.h index 26f0abfcfb72..d6f79db21907 100644 --- a/xpcom/string/obsolete/nsString.h +++ b/xpcom/string/obsolete/nsString.h @@ -655,11 +655,52 @@ public: * @param aCount tells us how many chars to compare * @return -1,0,1 */ - virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; + PRBool EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aCount=-1) const; #ifndef NEW_STRING_APIS + virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + /** + * Compare this to given string; note that we compare full strings here. + * The optional length argument just lets us know how long the given string is. + * If you provide a length, it is compared to length of this string as an + * optimization. + * + * @param aString -- the string to compare to this + * @param aCount -- number of chars in given string you want to compare + * @return TRUE if equal + */ + PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsIgnoreCase(const nsStr& aString) const; + /** * These methods compare a given string type to this one * @param aString is the string to be compared to this @@ -715,25 +756,6 @@ public: PRBool operator>=(const PRUnichar* aString) const; #endif // !defined(NEW_STRING_APIS) - /** - * Compare this to given string; note that we compare full strings here. - * The optional length argument just lets us know how long the given string is. - * If you provide a length, it is compared to length of this string as an - * optimization. - * - * @param aString -- the string to compare to this - * @param aCount -- number of chars in given string you want to compare - * @return TRUE if equal - */ - PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - - PRBool EqualsIgnoreCase(const nsStr& aString) const; - PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; - PRBool EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aCount=-1) const; - void DebugDump(void) const; diff --git a/xpcom/string/obsolete/nsString2.cpp b/xpcom/string/obsolete/nsString2.cpp index 517f5381e46d..c97cbc58a07f 100644 --- a/xpcom/string/obsolete/nsString2.cpp +++ b/xpcom/string/obsolete/nsString2.cpp @@ -1807,9 +1807,20 @@ PRInt32 nsString::RFindCharInSet(const PRUnichar* aStringSet,PRInt32 anOffset) c * @param aCount tells us how many chars to test; -1 implies full length * @return -1,0,1 */ -PRInt32 nsString::Compare(const nsString& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 result=nsStr::Compare(*this,aString,aCount,aIgnoreCase); - return result; +PRInt32 nsString::CompareWithConversion(const char *aCString,PRBool aIgnoreCase,PRInt32 aCount) const { + NS_ASSERTION(0!=aCString,kNullPointerError); + + if(aCString) { + nsStr temp; + nsStr::Initialize(temp,eOneByte); + + temp.mLength= (0=(const PRUnichar* s) const {return PRBool(Compare(s)> #endif // !defined(NEW_STRING_APIS) PRBool nsString::EqualsIgnoreCase(const nsString& aString) const { - return Equals(aString,PR_TRUE); + return EqualsWithConversion(aString,PR_TRUE); } PRBool nsString::EqualsIgnoreCase(const char* aString,PRInt32 aLength) const { - return Equals(aString,PR_TRUE,aLength); + return EqualsWithConversion(aString,PR_TRUE,aLength); } +#ifndef NEW_STRING_APIS PRBool nsString::EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const { return Equals(aAtom,PR_TRUE); } @@ -1922,7 +1924,7 @@ PRBool nsString::EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const { PRBool nsString::EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const { return Equals(s1,s2,PR_TRUE); } - +#endif /** * Compare this to given string; note that we compare full strings here. @@ -1932,27 +1934,13 @@ PRBool nsString::EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) cons * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsString::Equals(const nsString& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=nsStr::Compare(*this,aString,aCount,aIgnoreCase); +PRBool nsString::EqualsWithConversion(const nsString& aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); PRBool result=PRBool(0==theAnswer); return result; } -/** - * Compare this to given string; note that we compare full strings here. - * - * @update gess 01/04/99 - * @param aString is the other nsString to be compared to - * @param aCount tells us how many chars to test; -1 implies full length - * @return TRUE if equal - */ -PRBool nsString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=nsStr::Compare(*this,aString,aCount,aIgnoreCase); - PRBool result=PRBool(0==theAnswer); - return result; -} - /** * Compare this to given c-string; note that we compare full strings here. * @@ -1961,8 +1949,8 @@ PRBool nsString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsString::Equals(const char* aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=Compare(aString,aIgnoreCase,aCount); +PRBool nsString::EqualsWithConversion(const char* aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=CompareWithConversion(aString,aIgnoreCase,aCount); PRBool result=PRBool(0==theAnswer); return result; } @@ -1975,8 +1963,23 @@ PRBool nsString::Equals(const char* aString,PRBool aIgnoreCase,PRInt32 aCount) c * @param aCount tells us how many chars to test; -1 implies full length * @return TRUE if equal */ -PRBool nsString::Equals(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { - PRInt32 theAnswer=Compare(aString,aIgnoreCase,aCount); +PRBool nsString::EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=CompareWithConversion(aString,aIgnoreCase,aCount); + PRBool result=PRBool(0==theAnswer); + return result; +} + +#ifndef NEW_STRING_APIS +/** + * Compare this to given string; note that we compare full strings here. + * + * @update gess 01/04/99 + * @param aString is the other nsString to be compared to + * @param aCount tells us how many chars to test; -1 implies full length + * @return TRUE if equal + */ +PRBool nsString::Equals(const nsStr& aString,PRBool aIgnoreCase,PRInt32 aCount) const { + PRInt32 theAnswer=nsStr::StrCompare(*this,aString,aCount,aIgnoreCase); PRBool result=PRBool(0==theAnswer); return result; } @@ -2028,6 +2031,7 @@ PRBool nsString::Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreC return result; } +#endif /** * Determine if given char in valid alpha range diff --git a/xpcom/string/obsolete/nsString2.h b/xpcom/string/obsolete/nsString2.h index 526d69b928f0..01ebb5b5e1d5 100644 --- a/xpcom/string/obsolete/nsString2.h +++ b/xpcom/string/obsolete/nsString2.h @@ -709,12 +709,62 @@ public: * @param aCount tells us how many chars to compare * @return -1,0,1 */ - virtual PRInt32 Compare(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + PRBool EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + PRBool EqualsIgnoreCase(const nsString& aString) const; + PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; + PRBool EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const; + PRBool EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const; #ifndef NEW_STRING_APIS + virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return CompareWithConversion(aString,aIgnoreCase,aCount); + } + + virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + + /** + * Compare this to given string; note that we compare full strings here. + * The optional length argument just lets us know how long the given string is. + * If you provide a length, it is compared to length of this string as an + * optimization. + * + * @param aString -- the string to compare to this + * @param aCount -- number of chars to be compared. + * @return TRUE if equal + */ + PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const { + return EqualsWithConversion(aString,aIgnoreCase,aCount); + } + + PRBool Equals(/*FIX: const */nsIAtom* anAtom,PRBool aIgnoreCase) const; + PRBool Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreCase=PR_FALSE) const; + PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; + + /** * These methods compare a given string type to this one * @param aString is the string to be compared to this @@ -776,28 +826,6 @@ public: PRBool operator>=(const PRUnichar* aString) const; #endif // !defined(NEW_STRING_APIS) - /** - * Compare this to given string; note that we compare full strings here. - * The optional length argument just lets us know how long the given string is. - * If you provide a length, it is compared to length of this string as an - * optimization. - * - * @param aString -- the string to compare to this - * @param aCount -- number of chars to be compared. - * @return TRUE if equal - */ - PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const; - PRBool Equals(/*FIX: const */nsIAtom* anAtom,PRBool aIgnoreCase) const; - PRBool Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreCase=PR_FALSE) const; - - PRBool EqualsIgnoreCase(const nsString& aString) const; - PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; - PRBool EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const; - PRBool EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const; - /** * Determine if given buffer is plain ascii *