String search and replace

[Zilppuri]

I have been making a method for finding a string in HBufC8 and replacing it with a new one.

void StringReplaceL(HBufC8& aText, 
const TDesC8& aSearchString, 
const TDesC8& aReplaceWith)
    {
    TInt searchLength = aSearchString.Length();
    TInt replaceLength = aReplaceWith.Length();
   
    TPtr8 textPtr = aText.Des();

    TInt pos = 0;
   
    pos = 0;
   
    while(pos != KErrNotFound)
        {
        pos = textPtr.Find( aSearchString );
        if(pos != KErrNotFound)
            {           
            //Expand the buffer to hold the new data    
            aText.ReAlloc(aText.Length() - searchLength  +  replaceLength);
                      
            textPtr = aText.Des();
            textPtr.Replace(pos, searchLength, aReplaceWith);
            }
        }
    }

I'd like to get some feedback on possible problems with this code.

a) It seems that the textPtr.Replace() sometimes causes buffer overflow.

b) Calling ReAlloc() on all search results doesn't seem like a proper way to do it. I wasn't able to make a loop that would just count the results, as calling
aText.Mid(pos).Find(aSearchString )
Always returned me KErrNotFound, even with pos = 0;

c) Is
textPtr = aText.Des();
Necessary after ReAlloc()?

d) Is there ready example on how to do this efficiently?

[wizard_hu_]

a) it is documented in TDes16::Replace: you will get USER 11 if the result does not fit into the descriptor
b,c) ReAlloc/L/C re-allocates the descriptor, thus its proper usage is aText=aText->ReAllocL(...).
and after that change textPtr has to be re-initialized as well.
because you have to modify address of aText itself, it should be HBufC &* (reference to a pointer)

[Zilppuri]

Thanks for your answer.

The code is now as follows:

StringReplaceL(HBufC8*& aText, const TDesC8& aSearchString, const TDesC8& aReplaceWith ) 
	{
	TInt searchLength = aSearchString.Length();
	TInt replaceLength = aReplaceWith.Length();
	
        TPtr8 textPtr( aText->Des() );

        TInt pos = 0;
	
	while( pos != KErrNotFound )
		{
		pos = textPtr.Find( aSearchString );
		if( pos != KErrNotFound )
			{
			//Expand the buffer to hold the new data     
			aText = aText->ReAllocL(aText->Length() - searchLength +  replaceLength);		
			textPtr = aText->Des();		
		        textPtr.Replace(pos, searchLength, aReplaceWith);
			}
		}
	}

Unfortunately I still get USER 23 (Buffer overflow) in my test case.

I have the following setup:

_LIT8(KSearchTest1, "#");
_LIT8(KSearchTest2, "<img src=\"moo\">");
		
HBufC8* test = HBufC8::NewL(55);	
TPtr8 ptr(test->Des());
ptr.Append(_L("tests ##tests # tests"));

StringReplaceL(test, KSearchTest1, KSearchTest2);

It panics at the third "#" in HBufC8* test.

Any idea why it happens?

[wizard_hu_]

= is a nasty thing

Copies data into this 8-bit modifiable pointer descriptor replacing any existing data.

so textPtr is not updated. What you need is TPtr8::Set.

However you can also rely on variable scope, and use the fact that Find works on read-only descriptors (like aText) too:

void StringReplaceL(HBufC8*& aText, const TDesC8& aSearchString, const TDesC8& aReplaceWith ) 
    {
    TInt searchLength = aSearchString.Length();
    TInt replaceLength = aReplaceWith.Length();

    TInt pos = 0;
	
    while( pos != KErrNotFound )
        {
        pos = aText->Find( aSearchString );
        if( pos != KErrNotFound )
            {
            //Expand the buffer to hold the new data     
            aText = aText->ReAllocL(aText->Length() - searchLength +  replaceLength);		
            TPtr8 textPtr( aText->Des() );
            textPtr.Replace(pos, searchLength, aReplaceWith);
            }
        }
    }

In fact textPtr is used in a single statement, thus it does not have to be a separate variable any more

void StringReplaceL(HBufC8*& aText, const TDesC8& aSearchString, const TDesC8& aReplaceWith ) 
{
    TInt searchLength = aSearchString.Length();
    TInt replaceLength = aReplaceWith.Length();

    for(TInt pos = aText->Find(aSearchString); pos != KErrNotFound; pos = aText->Find(aSearchString))
    {
        aText = aText->ReAllocL(aText->Length() - searchLength +  replaceLength);		
        aText->Des().Replace(pos, searchLength, aReplaceWith);
    }
}

[Zilppuri]

Thank you!

Works like a charm

void StringReplaceL(HBufC8*& aText, const TDesC8& aSearchString, const TDesC8& aReplaceWith ) 
{
    TInt searchLength = aSearchString.Length();
    TInt replaceLength = aReplaceWith.Length();

    for(TInt pos = aText->Find(aSearchString); pos != KErrNotFound; pos = aText->Find(aSearchString))
    {
        aText = aText->ReAllocL(aText->Length() - searchLength +  replaceLength);		
        aText->Des().Replace(pos, searchLength, aReplaceWith);
    }
}