Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-24 18:55:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
8917c72738
gecko-dev/xpcom/ds/nsBufferManager.h

1407 lines
40 KiB
C++
Raw Blame History

/*************************************************************************************
*
* MODULES NOTES:
*
* 1. See nsStringImpl.h
*
* Contributor(s):
* Rick Gessner <rickg@netscape.com>
*
* History:
*
* 02.29.2000: Original files (rickg)
* 03.02.2000: Flesh out the interface to be compatible with old library (rickg)
* 03.03.2000: Finished mapping original nsStr functionality to template form (rickg)
*
*************************************************************************************/
#ifndef NS_BUFFERMANAGER_
#define NS_BUFFERMANAGER_
#include "nsStringValue.h"
#include <string.h>
#include "nsCRT.h"
class nsAReadableString;
class nsAReadableStringIterator;
/***************************************************************************
*
* The following (hack) template functions will go away, but for now they
* provide basic string copying and appending for my prototype. (rickg)
*
***************************************************************************/
inline size_t stringlen(const PRUnichar* theString) {
const PRUnichar* theEnd=theString;
while(*theEnd++); //skip to end of aDest...
size_t result=theEnd-theString-1;
return result;
}
inline size_t stringlen(const char* theString) {
return ::strlen(theString);
}
template <class CharType1,class CharType2>
void strncopy(CharType1* aDest,const CharType2* aSource, size_t aLength) {
const CharType2* aLast=aSource+aLength;
while(aSource<aLast) {
*aDest++=(CharType1)*aSource++;
}
}
template <class CharType1,class CharType2>
void strcatn(CharType1* aDest,const CharType2* aSource, size_t aLength) {
while(*aDest++); //skip to end of aDest...
strncopy(aDest,aSource,aLength);
}
/*************************************************************************************
*
* These methods offer the low level buffer manipulation routines used throughout
* the string hierarchy. T1 and T2 will be types of stringvalues. (rickg)
*
*************************************************************************************/
template <class T1,class T2>
inline PRInt32 MinInt(T1 anInt1,T2 anInt2){
return (anInt1<(T1)anInt2) ? anInt1 : anInt2;
}
template <class T1,class T2>
inline PRInt32 MaxInt(T1 anInt1,T2 anInt2){
return (anInt1<(T1)anInt2) ? anInt2 : anInt1;
}
template <class CharType>
inline void SVAddNullTerminator( nsStringValueImpl<CharType>& aDest) {
if(aDest.mBuffer) {
aDest.mBuffer[aDest.mLength]=0;
}
}
static const PRUnichar gCommonEmptyBuffer[1] = {0};
static nsresult gStringAcquiredMemory = NS_OK;
template <class CharType>
inline nsresult SVAlloc( nsStringValueImpl<CharType>& aDest, PRUint32 aCount) {
nsresult result=NS_OK;
static int mAllocCount=0;
mAllocCount++;
//we're given the acount value in charunits; now scale up to next multiple.
aDest.mCapacity=kDefaultStringSize;
while(aDest.mCapacity<aCount){
aDest.mCapacity<<=1;
}
aDest.mBuffer = new CharType[1+aDest.mCapacity];
// PRUint32 theSize=(theNewCapacity<<aDest.mCharSize);
// aDest.mBuffer = (char*)nsAllocator::Alloc(theSize);
if(aDest.mBuffer) {
aDest.mBuffer[0]=0;
gStringAcquiredMemory=PR_TRUE;
}
else {
gStringAcquiredMemory=PR_FALSE;
result=NS_MEMORY_ERROR;
}
return result;
}
/**
* Free memory from given stringvalueimpl
*
* @update rickg 03.02.2000
* @return memory error (usually returns NS_OK)
*/
template <class CharType>
inline nsresult SVFree( nsStringValueImpl<CharType>& aDest){
if(aDest.mBuffer){
delete [] aDest.mBuffer; // nsAllocator::Free(aDest.mBuffer);
aDest.mBuffer=0;
}
return NS_OK;
}
/**
* Realloc memory from given stringvalueimpl
*
* @update rickg 03.02.2000
* @return memory error (usually returns NS_OK)
*/
template <class CharType>
inline nsresult SVRealloc(nsStringValueImpl<CharType>&aDest,PRUint32 aCount){
nsStringValueImpl<CharType> temp(aDest);
nsresult result=SVAlloc<CharType>(temp,aCount);
if(NS_SUCCESS(result)) {
SVFree<CharType>(aDest);
aDest.mBuffer=temp.mBuffer;
aDest.mCapacity=temp.mCapacity;
}
return result;
}
/**
* Retrieve last memory error
*
* @update rickg 03.02.2000
* @return memory error (usually returns NS_OK)
*/
static PRBool DidAcquireMemory(void) {
return gStringAcquiredMemory;
}
//----------------------------------------------------------------------------------------
/**
* This is the low-level buffer copying routine between 2 stringvalues.
*
* @update rickg 03.01.2000
* @param aDest is the destination stringvalue
* @param aSource is the source stringvalue (you must account for offset yourself in calling routine)
* @param aLength tells us how many chars to copy from aSource
*/
template <class CharType1,class CharType2>
inline nsresult SVCopyBuffer_( CharType1* aDest, const CharType2* aSource, PRInt32 aLength) {
if(sizeof(CharType1)==sizeof(CharType2)) {
memcpy(aDest,aSource,aLength*sizeof(CharType1));
}
else {
const CharType2* aLast=aSource+aLength;
while(aSource<aLast) {
*aDest++=(CharType1)*aSource++;
}
}
return NS_OK;
}
//----------------------------------------------------------------------------------------
/**
* This is the low-level buffer copying routine between 2 stringvalues.
*
* @update rickg 03.01.2000
* @param aDest is the destination stringvalue
* @param aSource is the source stringvalue
* @param anOffset tells us where in aSource to begin copying from
* @param aLength tells us how many chars to copy from aSource
*/
template <class CharType1,class CharType2>
inline nsresult SVCopyBuffer( nsStringValueImpl<CharType1>& aDest,const nsStringValueImpl<CharType2>& aSource,PRInt32 aLength,PRInt32 aSrcOffset) {
nsresult result=NS_OK;
if((0<aSource.mLength)) {
CharType1* theDest = aDest.mBuffer;
CharType2* theSource= aSource.mBuffer;
CharType2* from = theSource+aSrcOffset;
result=SVCopyBuffer_<CharType1,CharType2>(aDest.mBuffer,aSource.mBuffer,aLength);
}
return result;
}
//----------------------------------------------------------------------------------------
/**
* This method destroys the given stringvalue, and *MAY*
* deallocate it's memory depending on the setting
* of the internal mOwnsBUffer flag.
*
* @update rickg 03.01.2000
* @param aStringValue is the stringvalue to be destroyed
*/
template <class CharType>
inline nsresult SVDestroy(nsStringValueImpl<CharType> &aStringValue) {
nsresult result=NS_OK;
return result;
}
/**
* These methods are where memory allocation/reallocation occur.
*
* @update rickg 03.01.2000
* @param aString is the stringvalue to be manipulated
* @return
*/
template <class CharType>
inline nsresult SVEnsureCapacity(nsStringValueImpl<CharType>& aString,PRUint32 aNewLength){
nsresult result=NS_OK;
if(aNewLength>aString.mCapacity) {
result=SVRealloc< CharType>(aString,aNewLength);
SVAddNullTerminator<CharType>(aString);
}
return result;
}
/**
* Attempt to grow the capacity of the given stringvalueimp by given amount
* (It's possible the length is already larger, so this can fall out.)
*
* @update rickg 03.02.2000
* @return memory error (usually returns NS_OK)
*/
template <class CharType>
inline nsresult SVGrowCapacity(nsStringValueImpl<CharType>& aDest,PRUint32 aNewLength){
nsresult result=NS_OK;
if(aNewLength>aDest.mCapacity) {
nsStringValueImpl<CharType> theTempStr;
nsresult result=SVAlloc<CharType>(theTempStr,aNewLength);
if(NS_SUCCESS(result)) {
if(0<aDest.mLength) {
result=SVCopyBuffer_<CharType,CharType>(theTempStr.mBuffer,aDest.mBuffer,aDest.mLength);
theTempStr.mLength=aDest.mLength;
SVAddNullTerminator<CharType>(aDest);
}
result=SVFree<CharType>(aDest);
aDest=theTempStr;
theTempStr.mBuffer=0; //make sure to null this out so that you don't lose the buffer you just stole...
}
}
return result;
}
/**
* This method deletes chars from the given str.
* The given allocator may choose to resize the str as well.
*
* @update rickg 03.01.2000
* @param aDest is the stringvalue to be modified
* @param aDestOffset tells us where in dest to start deleting
* @param aCount tells us the (max) # of chars to delete
*/
template <class CharType>
inline nsresult SVDelete( nsStringValueImpl<CharType>& aDest,PRUint32 aDestOffset,PRInt32 aCount){
nsresult result=NS_OK;
if((0<aCount) && (aDestOffset<aDest.mLength)){
CharType* root=aDest.mBuffer;
CharType* dst1=root+aDestOffset;
CharType* dst2=dst1+aCount;
CharType* end =root+aDest.mLength;
CharType* last = (dst2<end) ? dst2 : end;
if(last<end) {
aDest.mLength-=(last-dst1);
memmove(dst1,last,(end-last)*sizeof(CharType));
}
else aDest.mLength=aDestOffset;
SVAddNullTerminator<CharType>(aDest);
}
return result;
}
/**
* This method is used to truncate the given string.
* The given allocator may choose to resize the str as well (but it's not likely).
*
* @update rickg 03.01.2000
* @param aDest is the stringvalue to be modified
* @param aDestOffset tells us where in dest to truncate
*/
template <class CharType>
inline void SVTruncate( nsStringValueImpl<CharType>& aDest,PRUint32 aDestOffset) {
if(aDestOffset<aDest.mLength){
aDest.mLength=aDestOffset;
SVAddNullTerminator<CharType>(aDest);
}
};
/**
* These methods are used to append content to the given stringvalue
*
* @update rickg 03.01.2000
* @param aDest is the stringvalue to be modified
* @param aSource is the buffer to be copied from
* @param anOffset tells us where in source to start copying
* @param aCount tells us the (max) # of chars to copy
*/
template <class CharType1, class CharType2>
inline nsresult SVAppend( nsStringValueImpl<CharType1>& aDest,const nsStringValueImpl<CharType2>& aSource,PRInt32 aCount,PRInt32 aSrcOffset){
nsresult result=NS_OK;
if(aSrcOffset<(PRInt32)aSource.mLength){
PRInt32 theRealLen=(aCount<0) ? aSource.mLength : MinInt(aCount,aSource.mLength);
PRInt32 theLength=(aSrcOffset+theRealLen<(PRInt32)aSource.mLength) ? theRealLen : (aSource.mLength-aSrcOffset);
if(0<theLength){
PRBool isBigEnough=PR_TRUE;
if(aDest.mLength+theLength > aDest.mCapacity) {
result=SVGrowCapacity<CharType1>(aDest,aDest.mLength+theLength);
}
if(NS_SUCCESS(result)) {
//now append new chars, starting at offset
CharType1* theDest = &aDest.mBuffer[aDest.mLength];
CharType2* theSource = &aSource.mBuffer[aSrcOffset];
CharType2 *theLastChar = theSource+theLength;
result=SVCopyBuffer_<CharType1,CharType2>(theDest,theSource,theLength);
aDest.mLength+=theLength;
}
SVAddNullTerminator<CharType1>(aDest);
}
}
return result;
}
/**
* This method is used to append content to the given stringvalue from an nsAReadableString
*
* @update rickg 03.01.2000
* @param aDest is the stringvalue to be modified
* @param aSource is the readablestring to be copied from
* @param anOffset tells us where in source to start copying
* @param aCount tells us the (max) # of chars to copy
*/
template <class CharType1>
inline nsresult SVAppendReadable( nsStringValueImpl<CharType1>& aDest,const nsAReadableString& aSource,PRInt32 aCount,PRInt32 anSrcOffset){
nsresult result=NS_OK;
/*
//I expect a pattern similar to this that could work on any readable string
nsAReadableStringIterator theFirst=aSource.First();
nsAReadableStringIterator theLast=aSource.Last();
CharType1 *theDest=aDest.mBuffer;
while(theFirst<theLast) {
*theDest++=theFirst++;
}
*/
return result;
}
/**
* These methods are used to assign contents of a source string to dest string
*
* @update rickg 03.01.2000
* @param aDest is the stringvalue to be modified
* @param aSource is the buffer to be copied from
* @param anOffset tells us where in source to start copying
* @param aCount tells us the (max) # of chars to copy
*/
template <class CharType1, class CharType2>
inline nsresult SVAssign(nsStringValueImpl<CharType1>& aDest,const nsStringValueImpl<CharType2>& aSource,PRInt32 aCount,PRInt32 aSrcOffset) {
nsresult result=NS_OK;
if((void*)aDest.mBuffer!=(void*)aSource.mBuffer){
SVTruncate(aDest,0);
SVAppend(aDest,aSource,aCount,aSrcOffset);
}
return result;
}
/**
* These methods are used to insert content from source string to the dest stringvalue
*
* @update rickg 03.01.2000
* @param aDest is the stringvalue to be modified
* @param aDestOffset tells us where in dest to start insertion
* @param aSource is the buffer to be copied from
* @param aSrcOffset tells us where in source to start copying
* @param aCount tells us the (max) # of chars to insert
*/
template <class CharType1, class CharType2>
inline nsresult SVInsert( nsStringValueImpl<CharType1>& aDest,PRUint32 aDestOffset,const nsStringValueImpl<CharType2>& aSource,PRInt32 aCount,PRInt32 aSrcOffset) {
nsresult result=NS_OK;
//there are a few cases for insert:
// 1. You're inserting chars into an empty string (assign)
// 2. You're inserting onto the end of a string (append)
// 3. You're inserting onto the 1..n-1 pos of a string (the hard case).
if(0<aSource.mLength){
if(aDest.mLength){
if(aDestOffset<aDest.mLength){
PRUint32 theRealLen=(aCount<0) ? aSource.mLength : MinInt(aCount,aSource.mLength);
PRUint32 theLength=(aSrcOffset+theRealLen<aSource.mLength) ? theRealLen : (aSource.mLength-aSrcOffset);
if(aSrcOffset<(PRInt32)aSource.mLength) {
//here's the only new case we have to handle.
//chars are really being inserted into our buffer...
if(aDest.mLength+theLength > aDest.mCapacity) {
nsStringValueImpl<CharType1> theTempStr;
result=SVEnsureCapacity<CharType1>(theTempStr,aDest.mLength+theLength);
if(NS_SUCCESS(result)) {
if(aDestOffset) {
SVAppend(theTempStr,aDest,aDestOffset,0); //first copy leftmost data...
}
SVAppend(theTempStr,aSource,aSource.mLength,0); //next copy inserted (new) data
PRUint32 theRemains=aDest.mLength-aDestOffset;
if(theRemains) {
SVAppend(theTempStr,aDest,theRemains,aDestOffset); //next copy rightmost data
}
SVFree(aDest);
aDest=theTempStr;
theTempStr.mBuffer=0; //make sure to null this out so that you don't lose the buffer you just stole...
}
}
else {
CharType1* root=aDest.mBuffer;
CharType1* end= root+aDest.mLength;
CharType1* dst2 = root+aDestOffset;
CharType1* dst1 = root+aDestOffset+aCount;
memmove(dst1,dst2,sizeof(CharType1)*(end-dst2));
nsStringValueImpl<CharType1> theString(dst2,theLength);
result=SVCopyBuffer< CharType1, CharType2 >(theString,aSource,theLength,aSrcOffset);
//finally, make sure to update the string length...
aDest.mLength+=theLength;
SVAddNullTerminator(aDest);
}
}//if
//else nothing to do!
}
else SVAppend(aDest,aSource,aCount,0);
}
else SVAppend(aDest,aSource,aCount,0);
}
return result;
}
/**
* This method compares characters strings of two types, and ignores case
*
* @update rickg 03.01.2000
* @param aLeft
* @param aLast
* @param aMax
* @param anEnd
* @param aTarget
* @return aDest<aSource=-1;aDest==aSource==0;aDest>aSource=1
*/
template <class CharType1,class CharType2>
inline PRInt32 SVCompareCase_(const CharType1* aLeft,const CharType1* anEnd,const CharType2* aTarget){
while(aLeft<anEnd){
PRUnichar theChar=(PRUnichar)nsCRT::ToUpper(*aLeft++);
PRUnichar theTargetChar=(PRUnichar)nsCRT::ToUpper(*aTarget++);
if(theChar<theTargetChar)
return -1;
else if(theTargetChar<theChar)
return 1;
} //while
return 0;
}
/**
* This method compares characters strings of two types (case sensitive)
*
* @update rickg 03.01.2000
* @param aLeft
* @param aLast
* @param aMax
* @param anEnd
* @param aTarget
* @return aDest<aSource=-1;aDest==aSource==0;aDest>aSource=1
*/
template <class CharType1,class CharType2>
inline PRInt32 SVCompare_(const CharType1* aLeft,const CharType1* anEnd,const CharType2* aTarget){
while(aLeft<anEnd){
CharType1 theChar=*aLeft++;
CharType2 theTargetChar=*aTarget++;
if(theChar<theTargetChar)
return -1;
else if(theTargetChar<theChar)
return 1;
} //while
return 0;
}
/**
* This method removes characters from the given set from this string.
* NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
*
* @update rickg 03.01.2000
* @param aDest
* @param aString
* @param aIgnoreCase
* @param aCount --- tells us how many iterations to make.
* @return aDest<aSource=-1;aDest==aSource==0;aDest>aSource=1
*/
template <class CharType1,class CharType2>
inline PRInt32 SVCompare(const nsStringValueImpl<CharType1>& aDest,const nsStringValueImpl<CharType2>& aSource,PRBool aIgnoreCase, PRUint32 aCount){
PRInt32 result=0;
if(aCount) {
PRUint32 minlen=(aSource.mLength<aDest.mLength) ? aSource.mLength : aDest.mLength;
if(0==minlen) {
if ((aDest.mLength == 0) && (aSource.mLength == 0))
return 0;
if (aDest.mLength == 0)
return -1;
return 1;
}
PRUint32 theCount = (aCount<0) ? minlen: MinInt(aCount,minlen);
const CharType1* left= aDest.mBuffer;
const CharType1* last= left+theCount;
const CharType1* max = left+aDest.mLength;
const CharType1* end = (last<max) ? last : max;
const CharType2* target = aSource.mBuffer;
if(aIgnoreCase)
result = SVCompareCase_<CharType1,CharType2>(left,end,target) ;
else result =SVCompare_<CharType1,CharType2>(left,end,target);
if (0==result) {
if(-1==aCount) {
//Since the caller didn't give us a length to test, and minlen characters matched,
//we have to assume that the longer string is greater.
if (aDest.mLength != aSource.mLength) {
//we think they match, but we've only compared minlen characters.
//if the string lengths are different, then they don't really match.
result = (aDest.mLength<aSource.mLength) ? -1 : 1;
}
} //if
}
}
return result;
}
/**
* This method removes characters from the given set from this string.
* NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
*
* @update rickg 03.01.2000
* @param aDest
* @param aTarget
* @param aIgnoreCase
* @param aCount : tells us how many iterations to make, starting at offset
* @param aOffset: tells us where to start searching within aDest
* @return nothing
*/
template <class CharType1,class CharType2>
inline PRInt32 SVFind(const nsStringValueImpl<CharType1>& aDest,const nsStringValueImpl<CharType2>& aTarget,PRBool aIgnoreCase,PRInt32 aCount,PRInt32 aSrcOffset) {
PRUint32 minlen=(aTarget.mLength<aDest.mLength) ? aTarget.mLength : aDest.mLength;
aCount = (-1==aCount) ? aDest.mLength-minlen : aCount;
if((0<aCount) && minlen) {
const CharType1* root = aDest.mBuffer;
const CharType1* left = root+aSrcOffset;
const CharType1* last = left+aCount;
const CharType1* max = root+aDest.mLength;
const CharType1* end = (last<max) ? last : max;
PRInt32 cmp=0;
if(aIgnoreCase) {
while(left<=end) {
cmp = SVCompareCase_<CharType1,CharType2>(left,left+minlen,aTarget.mBuffer) ;
if(0==cmp) {
return left-root;
}
left++;
}
}
else {
PRBool theFastWay = ((1==sizeof(CharType1)) && (1==sizeof(CharType2)));
while(left<=end) {
if(theFastWay) {
size_t theCount=end-left;
cmp = memcmp(left,aTarget.mBuffer,minlen);
}
else cmp =SVCompare_<CharType1,CharType2>(left,left+minlen,aTarget.mBuffer);
if(0==cmp) {
return left-root;
}
left++;
}
}
}
return kNotFound;
}
/**
* This searches for the given char withing the given string
* NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
*
* @update rickg 03.02.2000
* @param aDest
* @param aSet
* @param aEliminateLeading
* @param aEliminateTrailing
* @return nothing
*/
template <class CharType>
PRInt32 SVFindChar(const nsStringValueImpl<CharType>& aDest,PRUnichar aChar,PRBool aIgnoreCase,PRInt32 aCount,PRInt32 aSrcOffset) {
if(aSrcOffset<0)
aSrcOffset=0;
if(aCount<0)
aCount = (PRInt32)aDest.mLength;
size_t theCharSize=sizeof(CharType);
if((2==theCharSize) || (aChar<256)) {
if((0<aDest.mLength) && ((PRUint32)aSrcOffset<aDest.mLength)) {
//We'll only search if the given aChar is within the normal ascii a range,
//(Since this string is definitely within the ascii range).
if(0<aCount) {
const CharType* root= aDest.mBuffer;
const CharType* left= root+aSrcOffset;
const CharType* last= left+aCount;
const CharType* max = left+aDest.mLength;
const CharType* end = (last<max) ? last : max;
if(aIgnoreCase) {
CharType theChar=(CharType)nsCRT::ToUpper(aChar);
while(left<end){
if(nsCRT::ToUpper(*left)==theChar)
return left-root;
++left;
}
}
else if (1==theCharSize){
PRInt32 theMax = end-left;
if(0<theMax) {
CharType theChar=(CharType)aChar;
const char* result=(const char*)memchr(left, theChar, theMax);
if(result) {
return result-(char*)root;
}
}
}
else {
while(left<end){
if(*left==aChar)
return (left-root);
++left;
} //while
} //else
}
} //if
}//if
return kNotFound;
}
/**
* This searches for the given char withing the given string
* NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
*
* @update rickg 03.02.2000
* @param aDest
* @param aSet
* @param aEliminateLeading
* @param aEliminateTrailing
* @return nothing
*/
template <class CharType1,class CharType2>
inline PRInt32 SVFindCharInSet(const nsStringValueImpl<CharType1>& aDest,const nsStringValueImpl<CharType2>& aSet,PRBool aIgnoreCase,PRInt32 aCount,PRInt32 anOffset) {
if(anOffset<0)
anOffset=0;
if(aCount<0)
aCount = (PRInt32)aDest.mLength;
if((0<aCount) && (0<aSet.mLength)){
const CharType1* root = aDest.mBuffer;
const CharType1* left = root+anOffset;
const CharType1* last = left+aCount;
const CharType1* max = root+aDest.mLength;
const CharType1* end = (last<max) ? last : max;
PRInt32 cmp=0;
while(left<=end) {
PRUnichar theChar=(PRUnichar)*left;
PRInt32 thePos=SVFindChar<CharType2>(aSet,theChar,aIgnoreCase,aSet.mLength,0);
if(kNotFound<thePos) {
return left-root;
}
left++;
}
}
return kNotFound;
}
/**
* This method removes characters from the given set from this string.
* NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
*
* @update rickg 03.01.2000
* @param aDest
* @param aSet
* @param aEliminateLeading
* @param aEliminateTrailing
* @return nothing
*/
template <class CharType1,class CharType2>
inline PRInt32 SVRFind(const nsStringValueImpl<CharType1>& aDest,const nsStringValueImpl<CharType2>& aTarget,PRBool aIgnoreCase,PRInt32 aCount,PRInt32 aSrcOffset) {
if(aSrcOffset<0)
aSrcOffset=(PRInt32)aDest.mLength-1;
if(aCount<0)
aCount = aSrcOffset;
size_t theCharSize=sizeof(CharType1);
if((0<aTarget.mLength) && (0<aDest.mLength) && ((PRUint32)aSrcOffset<aDest.mLength)) {
//We'll only search if the given aChar is within the normal ascii a range,
//(Since this string is definitely within the ascii range).
if(0<aCount) {
const CharType1* root = aDest.mBuffer;
const CharType1* rightmost = root+aSrcOffset;
const CharType1* min = rightmost-aCount+1;
const CharType1* leftmost = (min<root) ? root : min;
PRInt32 cmp=0;
while(leftmost<=rightmost) {
if(aIgnoreCase)
cmp = SVCompareCase_<CharType1,CharType2>(rightmost,rightmost+aTarget.mLength,aTarget.mBuffer) ;
else cmp =SVCompare_<CharType1,CharType2>(rightmost,rightmost+aTarget.mLength,aTarget.mBuffer);
if(0==cmp) {
return rightmost-root;
}
rightmost--;
}
}
}
return kNotFound;
}
/**
* This methods cans the given buffer (in reverse) for the given char
*
* @update gess 02/17/00
* @param aDest is the buffer to be searched
* @param anOffset is the start pos to begin searching
* @param aChar is the target character we're looking for
* @param aIgnorecase tells us whether to use a case sensitive search
* @param aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.
* @return index of pos if found, else -1 (kNotFound)
*/
template <class CharType>
PRInt32 SVRFindChar(const nsStringValueImpl<CharType>& aDest,PRUnichar aChar,PRBool aIgnoreCase,PRInt32 aCount,PRInt32 aSrcOffset) {
if(aSrcOffset<0)
aSrcOffset=(PRInt32)aDest.mLength-1;
if(aCount<0)
aCount = aSrcOffset;
size_t theCharSize=sizeof(CharType);
if((2==theCharSize) || (aChar<256)) {
if((0<aDest.mLength) && ((PRUint32)aSrcOffset<aDest.mLength)) {
//We'll only search if the given aChar is within the normal ascii a range,
//(Since this string is definitely within the ascii range).
if(0<aCount) {
const CharType* root = aDest.mBuffer;
const CharType* rightmost = root+aSrcOffset;
const CharType* min = rightmost-aCount+1;
const CharType* leftmost = (min<root) ? root : min;
CharType theChar=(CharType)aChar;
if(aIgnoreCase) {
while(leftmost<=rightmost){
if(nsCRT::ToUpper(*rightmost)==theChar)
return rightmost-root;
--rightmost;
}
}
else {
while(leftmost<=rightmost){
if((*rightmost)==theChar)
return rightmost-root;
--rightmost;
}
}
}
}
}
return kNotFound;
}
/**
* This methods cans the given buffer (in reverse) for the given char
*
* @update gess 02/17/00
* @param aDest is the buffer to be searched
* @param anOffset is the start pos to begin searching
* @param aChar is the target character we're looking for
* @param aIgnorecase tells us whether to use a case sensitive search
* @param aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.
* @return index of pos if found, else -1 (kNotFound)
*/
template <class CharType1,class CharType2>
inline PRInt32 SVRFindCharInSet(const nsStringValueImpl<CharType1>& aDest,const nsStringValueImpl<CharType2>& aSet,PRBool aIgnoreCase,PRInt32 aCount,PRInt32 aSrcOffset) {
if(aSrcOffset<0)
aSrcOffset=(PRInt32)aDest.mLength-1;
if(aCount<0)
aCount = aSrcOffset;
if((0<aDest.mLength) && ((PRUint32)aSrcOffset<aDest.mLength)) {
//We'll only search if the given aChar is within the normal ascii a range,
//(Since this string is definitely within the ascii range).
if(0<aCount) {
const CharType1* root = aDest.mBuffer;
const CharType1* rightmost = root+aSrcOffset;
while(root<=--rightmost){
CharType1 theChar=(aIgnoreCase) ? nsCRT::ToUpper(*rightmost) : *rightmost;
PRInt32 thePos=SVFindChar<CharType2>(aSet,theChar,aIgnoreCase,aSet.mLength,0);
if(kNotFound<thePos) {
return rightmost-root;
}
}
}
}
return kNotFound;
}
/**
* This method removes characters from the given set from this string.
* NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
*
* @update rickg 03.01.2000
* @param aDest
* @param aSet
* @param aEliminateLeading
* @param aEliminateTrailing
* @return nothing
*/
template <class CharType>
nsresult SVTrim(nsStringValueImpl<CharType>& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing){
nsresult result=NS_OK;
if(0<aDest.mLength) {
CharType *root= aDest.mBuffer;
CharType *end = root+aDest.mLength;
nsStringValueImpl<char> theSet(const_cast<char*>(aSet));
if(aEliminateTrailing) {
while(root<=--end) {
CharType theChar=*end;
PRInt32 thePos=SVFindChar<char>(theSet,theChar,PR_FALSE,theSet.mLength,0);
if(kNotFound==thePos)
break;
}
*(end+1)=0;
aDest.mLength=(end-root)+1;
}
CharType *cp = root-1;
if(aEliminateLeading) {
while(++cp<end) {
CharType theChar=*cp;
PRInt32 thePos=SVFindChar<char>(theSet,theChar,PR_FALSE,theSet.mLength,0);
if(kNotFound==thePos)
break;
}
size_t theCount=cp-root;
if(0<theCount) {
result=SVDelete(aDest,0,theCount);
}
}
}
return result;
}
/**
* This method removes characters from the given set from this string.
* NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
*
* @update rickg 03.01.2000
* @param aDest
* @param aSet
* @param aEliminateLeading
* @param aEliminateTrailing
* @return nothing
*/
template <class CharType>
nsresult SVStripCharsInSet(nsStringValueImpl<CharType>& aDest,const char* aSet,PRInt32 aCount,PRInt32 aSrcOffset) {
if((0<aDest.mLength) && aSet && (aSrcOffset<(PRInt32)aDest.mLength)){
CharType* left= aDest.mBuffer+aSrcOffset;
CharType* theWriteCP= left;
const CharType* last= left+aCount;
const CharType* max = left+aDest.mLength;
const CharType* end = (last<max) ? last : max;
nsStringValueImpl<char> theSet(const_cast<char*>(aSet));
while(left<end){
CharType theChar=*left;
PRInt32 thePos=SVFindChar<char>(theSet,theChar,PR_FALSE,theSet.mLength,0);
if(kNotFound==thePos) {
*theWriteCP++=*left;
}
++left;
} //while
*theWriteCP=0;
aDest.mLength-=(left-theWriteCP);
} //if
return NS_OK;
}
/**
* This method removes a given char the underlying stringvalue
*
* @update rickg 03.01.2000
* @param aDest is the stringvalue to be modified
* @param anOffset tells us where in source to start copying
* @param aCount tells us the (max) # of chars to copy
*/
template <class CharType>
nsresult SVStripChar( nsStringValueImpl<CharType>& aDest, CharType aChar,PRInt32 aCount,PRInt32 anOffset) {
nsresult result=NS_OK;
if(anOffset<(PRInt32)aDest.mLength){
CharType *theCP=&aDest.mBuffer[anOffset];
CharType *theWriteCP=theCP;
CharType *theEndCP=theCP+aDest.mLength;
while(theCP<theEndCP) {
if(*theCP!=aChar) {
*theWriteCP++=*theCP;
}
theCP++;
}
*theWriteCP=0;
aDest.mLength-=(theCP-theWriteCP);
}
return result;
}
/**
* This method removes a given char the underlying stringvalue
*
* @update rickg 03.01.2000
* @param aDest is the stringvalue to be modified
* @param anOffset tells us where in source to start copying
* @param aCount tells us the (max) # of chars to copy
*/
template <class CharType1,class CharType2>
nsresult SVReplace( nsStringValueImpl<CharType1> &aDest,
const nsStringValueImpl<CharType2> &aTarget,
const nsStringValueImpl<CharType2> &aNewValue,
PRInt32 aCount,
PRInt32 anOffset) {
nsresult result=NS_OK;
if((aTarget.mLength) && (aNewValue.mLength)) {
nsStringValueImpl<CharType1> theTempString;
PRUint32 thePrevOffset=0;
PRInt32 thePos=SVFind(aDest,aTarget,PR_FALSE,aDest.mLength,thePrevOffset);
while(kNotFound<thePos) {
if(0<thePos) {
SVAppend(theTempString,aDest,thePos-thePrevOffset,thePrevOffset);
}
SVAppend(theTempString,aNewValue,aNewValue.mLength,0);
thePrevOffset=thePos+aTarget.mLength;
thePos=SVFind(aDest,aTarget,PR_FALSE,aDest.mLength-thePrevOffset,thePrevOffset);
}
if(thePrevOffset<aDest.mLength) {
SVAppend(theTempString,aDest,aDest.mLength-thePrevOffset,thePrevOffset);
}
SVFree(aDest);
aDest=theTempString;
theTempString.mBuffer=0;
}
return result;
}
/**
* This method removes a given char the underlying stringvalue
*
* @update rickg 03.01.2000
* @param aDest is the stringvalue to be modified
* @param anOffset tells us where in source to start copying
* @param aCount tells us the (max) # of chars to copy
*/
template <class CharType>
nsresult SVReplaceChar( nsStringValueImpl<CharType>& aDest, CharType anOldChar, CharType aNewChar, PRInt32 aCount,PRInt32 anOffset) {
nsresult result=NS_OK;
if(anOffset<(PRInt32)aDest.mLength){
CharType *theCP=&aDest.mBuffer[anOffset];
CharType *theWriteCP=theCP;
CharType *theEndCP=theCP+aDest.mLength;
while(theCP<theEndCP) {
if(*theCP==anOldChar) {
*theCP=aNewChar;
}
theCP++;
}
}
return result;
}
/**
* This method removes characters from the given set from this string.
* NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
*
* @update rickg 03.01.2000
* @param aDest
* @param aSet
* @param aEliminateLeading
* @param aEliminateTrailing
* @return nothing
*/
template <class CharType>
nsresult SVReplaceCharsInSet(nsStringValueImpl<CharType>& aDest,const nsStringValueImpl<char> &aSet,PRUnichar aNewChar,PRInt32 aCount,PRInt32 anOffset) {
if((0<aDest.mLength) && (anOffset<(PRInt32)aDest.mLength)){
CharType* left= aDest.mBuffer+anOffset;
const CharType* theWriteCP= left;
const CharType* last= left+aCount;
const CharType* max = left+aDest.mLength;
const CharType* end = (last<max) ? last : max;
nsStringValueImpl<char> theSet(aSet);
while(left<end){
CharType theChar=*left;
PRInt32 thePos=SVFindChar(theSet,theChar,PR_FALSE,theSet.mLength,0);
if(kNotFound!=thePos) {
*left=(CharType)aNewChar;
}
++left;
} //while
} //if
return NS_OK;
}
/**
* This method removes characters from the given set from this string.
* NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
*
* @update rickg 03.01.2000
* @param aDest
* @param aSet
* @param aEliminateLeading
* @param aEliminateTrailing
* @return nothing
*/
template <class CharType>
nsresult SVCompressSet(nsStringValueImpl<CharType>& aDest,nsStringValueImpl<char> &aSet, PRUnichar aChar,PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE){
nsresult result=NS_OK;
if(0<aDest.mLength){
result=SVReplaceCharsInSet<CharType>(aDest, aSet, aChar, aDest.mLength,0);
SVTrim<CharType>(aDest,aSet,aEliminateLeading,aEliminateTrailing);
CharType* root = aDest.mBuffer;
CharType* end = root + aDest.mLength;
CharType* to = root;
//this code converts /n, /t, /r into normal space ' ';
//it also compresses runs of whitespace down to a single char...
PRUint32 aSetLen=strlen(aSet);
while (root < end) {
CharType theChar = *root++;
if((255<theChar) || (kNotFound!=SVFindChar<char>(aSet,theChar,PR_FALSE,aSet.mLength,0))){
*to++=theChar;
while (root <= end) {
theChar = *root++;
PRInt32 thePos=SVFindChar<char>(aSet,theChar,PR_FALSE,aSet.mLength,0);
if(kNotFound==thePos){
*to++ = theChar;
break;
}
}
} else {
*to++ = theChar;
}
}
*to = 0;
aDest.mLength = to - (CharType*)aDest.mBuffer;
}
return result;
}
template <class CharType>
void SVToLowerCase(nsStringValueImpl<CharType> &aString) {
CharType *theCP=aString.mBuffer;
CharType *theEndCP=theCP+aString.mLength;
while(theCP<theEndCP) {
CharType theChar=*theCP;
if ((theChar >= 'A') && (theChar <= 'Z')) {
*theCP = 'a' + (theChar - 'A');
}
theCP++;
}
}
template <class CharType>
void SVToUpperCase(nsStringValueImpl<CharType> &aString) {
CharType *theCP=aString.mBuffer;
CharType *theEndCP=theCP+aString.mLength;
while(theCP<theEndCP) {
CharType theChar=*theCP;
if ((theChar>= 'a') && (theChar<= 'z')) {
*theCP= 'A' + (theChar - 'a');
}
theCP++;
}
}
template <class CharType>
PRInt32 SVCountChar(const nsStringValueImpl<CharType> &aString,PRUnichar aChar) {
PRInt32 result=0;
if(aString.mLength) {
const CharType* cp=aString.mBuffer-1;
const CharType* endcp=cp+aString.mLength;
while(++cp<endcp) {
if(*cp==aChar)
result++;
}
}
return result;
}
//This will not work correctly for any unicode set other than ascii
template <class CharType>
void SVDebugDump(const nsStringValueImpl<CharType> &aString) {
if(aString.mLength) {
CharType* cp=aString.mBuffer;
CharType* endcp=cp+aString.mLength;
char theBuffer[256];
char* outp=theBuffer;
char* outendp=&theBuffer[255];
while(++cp<endcp) {
if(outp==outendp) {
*outp=0; //write null
printf("%s",theBuffer);
outp=theBuffer;
}
else {
*outp++=(char)*cp;
}
} //while
*outp=0; //force a null
printf("%s",theBuffer);
}
}
/**
* Perform string to int conversion.
* @param aErrorCode will contain error if one occurs
* @param aRadix tells us which radix to assume; kAutoDetect tells us to determine the radix for you.
* @return int rep of string value, and possible (out) error code
*/
template <class CharType>
PRInt32 SVToInteger(const nsStringValueImpl<CharType> &aString,PRInt32* anErrorCode,PRUint32 aRadix=kAutoDetect) {
CharType* cp=aString.mBuffer;
PRInt32 theRadix = (kAutoDetect==aRadix) ? 10 : aRadix;
PRInt32 result=0;
PRBool negate=PR_FALSE;
PRUnichar theChar=0;
*anErrorCode=NS_ERROR_ILLEGAL_VALUE;
if(cp) {
//begin by skipping over leading chars that shouldn't be part of the number...
CharType* endcp=cp+aString.mLength;
PRBool done=PR_FALSE;
while((cp<endcp) && (!done)){
theChar=*cp;
switch(*cp++) {
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
theRadix=16;
done=PR_TRUE;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
done=PR_TRUE;
break;
case '-':
negate=PR_TRUE; //fall through...
break;
case 'X': case 'x':
theRadix=16;
break;
default:
break;
} //switch
}
//if you don't have any valid chars, return 0, but set the error;
if(cp<=endcp) {
*anErrorCode = NS_OK;
//now iterate the numeric chars and build our result
CharType* first=--cp; //in case we have to back up.
while(cp<=endcp){
theChar=*cp++;
if(('0'<=theChar) && (theChar<='9')){
result = (theRadix * result) + (theChar-'0');
}
else if((theChar>='A') && (theChar<='F')) {
if(10==theRadix) {
if(kAutoDetect==aRadix){
theRadix=16;
cp=first; //backup
result=0;
}
else {
*anErrorCode=NS_ERROR_ILLEGAL_VALUE;
result=0;
break;
}
}
else {
result = (theRadix * result) + ((theChar-'A')+10);
}
}
else if((theChar>='a') && (theChar<='f')) {
if(10==theRadix) {
if(kAutoDetect==aRadix){
theRadix=16;
cp=first; //backup
result=0;
}
else {
*anErrorCode=NS_ERROR_ILLEGAL_VALUE;
result=0;
break;
}
}
else {
result = (theRadix * result) + ((theChar-'a')+10);
}
}
else if(('X'==theChar) || ('x'==theChar) || ('#'==theChar) || ('+'==theChar)) {
continue;
}
else {
//we've encountered a char that's not a legal number or sign
break;
}
} //while
if(negate)
result=-result;
} //if
}
return result;
}
#endif
Reference in New Issue View Git Blame Copy Permalink