int32_t nsAString::Find(const char *aStr, uint32_t aOffset, bool aIgnoreCase) const { bool (*match)(const PRUnichar*, const char*, uint32_t) = aIgnoreCase ? ns_strnimatch : ns_strnmatch; const char_type *begin, *end; uint32_t selflen = BeginReading(&begin, &end); if (aOffset > selflen) return -1; uint32_t otherlen = strlen(aStr); if (otherlen > selflen - aOffset) return -1; // We want to stop searching otherlen characters before the end of the string end -= otherlen; for (const char_type *cur = begin + aOffset; cur <= end; ++cur) { if (match(cur, aStr, otherlen)) { return cur - begin; } } return -1; }
int32_t nsACString::Find(const self_type& aStr, uint32_t aOffset, ComparatorFunc c) const { const char_type *begin, *end; uint32_t selflen = BeginReading(&begin, &end); if (aOffset > selflen) return -1; const char_type *other; uint32_t otherlen = aStr.BeginReading(&other); if (otherlen > selflen - aOffset) return -1; // We want to stop searching otherlen characters before the end of the string end -= otherlen; for (const char_type *cur = begin + aOffset; cur <= end; ++cur) { if (!c(cur, other, otherlen)) return cur - begin; } return -1; }
int32_t nsAString::RFind(const char *aStr, int32_t aOffset, bool aIgnoreCase) const { bool (*match)(const PRUnichar*, const char*, uint32_t) = aIgnoreCase ? ns_strnimatch : ns_strnmatch; const char_type *begin, *end; uint32_t selflen = BeginReading(&begin, &end); uint32_t otherlen = strlen(aStr); if (selflen < otherlen) return -1; if (aOffset < 0 || uint32_t(aOffset) > (selflen - otherlen)) end -= otherlen; else end = begin + aOffset; for (const char_type *cur = end; cur >= begin; --cur) { if (match(cur, aStr, otherlen)) { return cur - begin; } } return -1; }
int32_t nsACString::RFind(const char_type* aStr, int32_t aLen, ComparatorFunc aComparator) const { const char_type* begin; const char_type* end; uint32_t selflen = BeginReading(&begin, &end); if (aLen <= 0) { NS_WARNING("Searching for zero-length string."); return -1; } if (uint32_t(aLen) > selflen) { return -1; } // We want to start searching otherlen characters before the end of the string end -= aLen; for (const char_type* cur = end; cur >= begin; --cur) { if (!aComparator(cur, aStr, aLen)) { return cur - begin; } } return -1; }
PRInt32 nsAString::RFind(const char *aStr, PRInt32 aOffset, PRBool aIgnoreCase) const { PRBool (*match)(const PRUnichar*, const char*, PRUint32) = aIgnoreCase ? ns_strnimatch : ns_strnmatch; const char_type *begin, *end; PRUint32 selflen = BeginReading(&begin, &end); PRUint32 otherlen = strlen(aStr); if (selflen < otherlen) return -1; if (aOffset < 0 || aOffset > (selflen - otherlen)) end -= otherlen; else end = begin + aOffset; for (const char_type *cur = end; cur >= begin; --cur) { if (match(cur, aStr, otherlen)) { return cur - begin; } } return -1; }
int32_t nsACString::RFind(const self_type& aStr, int32_t aOffset, ComparatorFunc aComparator) const { const char_type* begin; const char_type* end; uint32_t selflen = BeginReading(&begin, &end); const char_type* other; uint32_t otherlen = aStr.BeginReading(&other); if (selflen < otherlen) { return -1; } if (aOffset < 0 || uint32_t(aOffset) > (selflen - otherlen)) { end -= otherlen; } else { end = begin + aOffset; } for (const char_type* cur = end; cur >= begin; --cur) { if (!aComparator(cur, other, otherlen)) { return cur - begin; } } return -1; }
void nsACString::Trim(const char* aSet, bool aLeading, bool aTrailing) { NS_ASSERTION(aLeading || aTrailing, "Ineffective Trim"); const char* start; const char* end; uint32_t cutLen; if (aLeading) { BeginReading(&start, &end); for (cutLen = 0; start < end; ++start, ++cutLen) { const char* test; for (test = aSet; *test; ++test) { if (*test == *start) { break; } } if (!*test) { break; } } if (cutLen) { NS_CStringCutData(*this, 0, cutLen); } } if (aTrailing) { uint32_t len = BeginReading(&start, &end); --end; for (cutLen = 0; end >= start; --end, ++cutLen) { const char* test; for (test = aSet; *test; ++test) { if (*test == *end) { break; } } if (!*test) { break; } } if (cutLen) { NS_CStringCutData(*this, len - cutLen, cutLen); } } }
int32_t nsACString::RFindChar(char_type aChar) const { const char *start, *end; BeginReading(&start, &end); for (; end >= start; --end) { if (*end == aChar) return end - start; } return -1; }
PRBool nsAString::EqualsLiteral(const char *aASCIIString) const { const PRUnichar *begin, *end; BeginReading(&begin, &end); for (; begin < end; ++begin, ++aASCIIString) { if (!*aASCIIString || !NS_IsAscii(*begin) || (char) *begin != *aASCIIString) { return PR_FALSE; } } return *aASCIIString == nsnull; }
bool nsAString::LowerCaseEqualsLiteral(const char *aASCIIString) const { const PRUnichar *begin, *end; BeginReading(&begin, &end); for (; begin < end; ++begin, ++aASCIIString) { if (!*aASCIIString || !NS_IsAscii(*begin) || NS_ToLower((char) *begin) != *aASCIIString) { return false; } } return *aASCIIString == '\0'; }
bool nsAString::EqualsLiteral(const char *aASCIIString) const { const char16_t *begin, *end; BeginReading(&begin, &end); for (; begin < end; ++begin, ++aASCIIString) { if (!*aASCIIString || !NS_IsAscii(*begin) || (char) *begin != *aASCIIString) { return false; } } return *aASCIIString == '\0'; }
int32_t nsAString::RFindChar(char_type aChar) const { const PRUnichar *start, *end; BeginReading(&start, &end); do { --end; if (*end == aChar) return end - start; } while (end >= start); return -1; }
int32_t nsACString::FindChar(char_type aChar, uint32_t aOffset) const { const char_type *start, *end; uint32_t len = BeginReading(&start, &end); if (aOffset > len) return -1; const char_type *cur; for (cur = start + aOffset; cur < end; ++cur) { if (*cur == aChar) return cur - start; } return -1; }
const nsSubstring& nsScannerSubstring::AsString() const { if (mIsDirty) { nsScannerSubstring* mutable_this = NS_CONST_CAST(nsScannerSubstring*, this); if (mStart.mBuffer == mEnd.mBuffer) { // We only have a single fragment to deal with, so just return it // as a substring. mutable_this->mFlattenedRep.Rebind(mStart.mPosition, mEnd.mPosition); } else { // Otherwise, we need to copy the data into a flattened buffer. nsScannerIterator start, end; CopyUnicodeTo(BeginReading(start), EndReading(end), mutable_this->mFlattenedRep); } mutable_this->mIsDirty = PR_FALSE; } return mFlattenedRep; }
int32_t nsACString::Find(const char_type *aStr, uint32_t aLen, ComparatorFunc c) const { const char_type *begin, *end; uint32_t selflen = BeginReading(&begin, &end); if (aLen == 0) { NS_WARNING("Searching for zero-length string."); return -1; } if (aLen > selflen) return -1; // We want to stop searching otherlen characters before the end of the string end -= aLen; for (const char_type *cur = begin; cur <= end; ++cur) { if (!c(cur, aStr, aLen)) return cur - begin; } return -1; }
PRInt32 nsACString::RFind(const self_type& aStr, PRInt32 aOffset, ComparatorFunc c) const { const char_type *begin, *end; PRUint32 selflen = BeginReading(&begin, &end); const char_type *other; PRUint32 otherlen = aStr.BeginReading(&other); if (selflen < otherlen) return -1; if (aOffset < 0 || aOffset > (selflen - otherlen)) end -= otherlen; else end = begin + aOffset; for (const char_type *cur = end; cur >= begin; --cur) { if (!c(cur, other, otherlen)) return cur - begin; } return -1; }
PRInt32 nsScannerSubstring::CountChar( PRUnichar c ) const { /* re-write this to use a counting sink */ size_type result = 0; size_type lengthToExamine = Length(); nsScannerIterator iter; for ( BeginReading(iter); ; ) { PRInt32 lengthToExamineInThisFragment = iter.size_forward(); const PRUnichar* fromBegin = iter.get(); result += size_type(NS_COUNT(fromBegin, fromBegin+lengthToExamineInThisFragment, c)); if ( !(lengthToExamine -= lengthToExamineInThisFragment) ) return result; iter.advance(lengthToExamineInThisFragment); } // never reached; quiets warnings return 0; }
PRInt32 nsACString::RFind(const char_type *aStr, PRInt32 aLen, ComparatorFunc c) const { const char_type *begin, *end; PRUint32 selflen = BeginReading(&begin, &end); if (aLen <= 0) { NS_WARNING("Searching for zero-length string."); return -1; } if (PRUint32(aLen) > selflen) return -1; // We want to start searching otherlen characters before the end of the string end -= aLen; for (const char_type *cur = end; cur >= begin; --cur) { if (!c(cur, aStr, aLen)) return cur - begin; } return -1; }