/*

 * Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: 

 *

 */

 #include <e32std.h>

 #include <e32base.h>

 #include "FLDSET.H"

 #include "FLDDEF.H"

 #include "FLDARRAY.H"

 #include "FLDSTD.H"

 EXPORT_C void CTextFieldSet::__DbgTestInvariant()const

 // Provides class invariants.  Explanations below:

 //

 	{

 #ifdef _DEBUG

 	if (!iFieldArray)

 		return;

 // check that every entry in the array has length >=0 and that all but the last have valid header handles

 	TBool valid = ETrue;

 	TInt index = iFieldArray->Count()-1;

 	if (index<0)

 		valid = EFalse;

 	else 

 		{// check last entry: should have null fieldHeader, zero field length and non-negative PreFieldLen

 		if ( (*iFieldArray)[index].iFieldHeader.iField

 		||(*iFieldArray)[index].iFieldValueLen!=0

 		||(*iFieldArray)[index].iPreFieldLen<0 )

 			{

 			valid = EFalse;

 			}

 		index--;

 		// check the other entries: should have non-null fieldHeader and non-negative field length and PreFieldLen

 		for (; (index>=0)&&(valid) ; index--)

 			{

 			if ((*iFieldArray)[index].iFieldValueLen<0

 				||(*iFieldArray)[index].iPreFieldLen<0 )

 					{

 					valid = EFalse;

 					}

 			}

 		}

 	__ASSERT_ALWAYS(valid,User::Invariant());

 #endif

 	}

 EXPORT_C CTextFieldSet* CTextFieldSet::NewL(TInt aDocumentLength)

 	{

 	CTextFieldSet* self=new(ELeave) CTextFieldSet();

 	CleanupStack::PushL(self);

 	self->ConstructL(aDocumentLength);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CTextFieldSet* CTextFieldSet::NewL(const MTextFieldFactory* aFactory,const CStreamStore& aFieldStore,TStreamId aStreamId)

 	{

 	CTextFieldSet* self=new(ELeave) CTextFieldSet();

 	CleanupStack::PushL(self);

 	self->SetFieldFactory(CONST_CAST(MTextFieldFactory*,aFactory));

 	self->ConstructL(0);

 	self->DoRestoreL(aFieldStore,aStreamId);

 	CleanupStack::Pop();

 	return self;

 	}

 CTextFieldSet::CTextFieldSet()

 	{}

 void CTextFieldSet::ConstructL(TInt aDocumentLength)

 // Creates an array in which to store all fields

 // Inserts an initial entry into the array to cover any text that lies after the last field

 //

 	{

 	iFieldArray = new(ELeave) CArrayFixSeg<TTextFieldEntry>(KFieldArrayGranularity);

 	AddInitialFieldEntryL(iFieldArray,aDocumentLength);

 	__TEST_INVARIANT;

 	}

 EXPORT_C CTextFieldSet::~CTextFieldSet()

 	{

 	delete iRollbackInfo;

 	if (iFieldArray)

 		{

 		TInt fieldCount=iFieldArray->Count();

 		for (TInt index=fieldCount-1;index>=0;index--)

 			delete (*iFieldArray)[index].iFieldHeader.iField.AsPtr(); // Delete the textField objects

 		delete iFieldArray;

 		}

 	}

 EXPORT_C void CTextFieldSet::SetFieldFactory(MTextFieldFactory* aFactory)

 	{

 	iFieldFactory = aFactory;

 	}

 EXPORT_C MTextFieldFactory* CTextFieldSet::FieldFactory()const

 	{

 	return iFieldFactory;

 	}

 void CTextFieldSet::InsertEntryL(TInt aIndex,TTextFieldEntry& aEntry)

 	{

 	InsertEntryL(aIndex,aEntry,iFieldArray);

 	}

 void CTextFieldSet::InsertEntryL(TInt aIndex,TTextFieldEntry& aEntry,CArrayFixSeg<TTextFieldEntry>* aArray)

 // if this function leaves it will be as if it had never been called...

 //

 	{

 	if (aEntry.iFieldHeader.iField.IsPtr())

 		CleanupStack::PushL(aEntry.iFieldHeader.iField.AsPtr());

 	aArray->InsertL(aIndex,aEntry); // insert new entry

 	if (aEntry.iFieldHeader.iField.IsPtr())

 		CleanupStack::Pop();

 	}

 void CTextFieldSet::AppendEntryL(TTextFieldEntry& aEntry)

 	{

 	AppendEntryL(aEntry,iFieldArray);

 	}

 void CTextFieldSet::AppendEntryL(TTextFieldEntry& aEntry,CArrayFixSeg<TTextFieldEntry>* aArray)

 	{

 	if (aEntry.iFieldHeader.iField.IsPtr())

 		CleanupStack::PushL(aEntry.iFieldHeader.iField.AsPtr());

 	aArray->AppendL(aEntry); // insert new entry

 	if (aEntry.iFieldHeader.iField.IsPtr())

 		CleanupStack::Pop();

 	}

 TInt CTextFieldSet::EntryLen(TInt aIndex)const

 	{

 	return EntryLen((*iFieldArray)[aIndex]);

 	}

 TInt CTextFieldSet::EntryLen(const TTextFieldEntry& aEntry)const

 	{

 	return aEntry.iPreFieldLen+aEntry.iFieldValueLen;

 	}

 TTextFieldEntry CTextFieldSet::SplitEntry(TInt aIndex,TInt aOffset, TInt aRange)const

 // Splits the entry aIndex, returning the part demarked by the offset (from the start of the entry) and the range

 //

 	{

 	__TEST_INVARIANT;

 	__ASSERT_DEBUG((aIndex>=0)&&(aIndex<iFieldArray->Count()),Panic(EIndexOutOfRange));

 	TInt entryLength = EntryLen(aIndex);

 	__ASSERT_DEBUG((aOffset>=0)&&(aOffset<=entryLength),Panic(EPosOutOfRange));

 	__ASSERT_DEBUG((aRange>=0),Panic(ENegativeRange));

 	if ((aOffset+aRange)>entryLength)

 		aRange = entryLength-aOffset; // scale range down to entry size if neccessary

 	if ((aOffset==0)&&(aRange==entryLength))

 		return (*iFieldArray)[aIndex]; //entry does not need to be split

 	TInt charsCopied=0;

 	TTextFieldEntry entry;

 	entry.iPreFieldLen = 0;

 	entry.iFieldValueLen = 0;

 	entry.iFieldHeader.iField = NULL;

 	if (aOffset<(*iFieldArray)[aIndex].iPreFieldLen)

 		{// At least some of the pre needs to be copied

 		entry.iPreFieldLen = (*iFieldArray)[aIndex].iPreFieldLen-aOffset;

 		if ((entry.iPreFieldLen)>aRange)

 			entry.iPreFieldLen = aRange;

 		charsCopied = entry.iPreFieldLen;

 		}

 	if (charsCopied<aRange)

 		{// more to do, so at least some of the field needs to be copied

 		if ((aOffset+aRange)==entryLength)

 			{// whole field in range so copy it

 			entry.iFieldValueLen = (*iFieldArray)[aIndex].iFieldValueLen;

 			entry.iFieldHeader = (*iFieldArray)[aIndex].iFieldHeader;

 			}

 		else

 			// only part of field in range so convert it to text

 			entry.iPreFieldLen += aRange-charsCopied;

 		}

 	return entry;

 	}

 void CTextFieldSet::AddInitialFieldEntryL(CArrayFixSeg<TTextFieldEntry>* aArray,TInt aDocumentLength)

 // Add initial entry

 	{

 	TTextFieldEntry initialEntry;

 	initialEntry.iPreFieldLen = aDocumentLength;

 	initialEntry.iFieldValueLen = 0;

 	initialEntry.iFieldHeader.iFieldType = KNullUid;

 	initialEntry.iFieldHeader.iField = NULL;

 	aArray->AppendL(initialEntry);

 	}

 EXPORT_C void CTextFieldSet::Reset()

 // deletes all fields (but not corresponding text) and reinitialises the field array

 //

 	{

 	__TEST_INVARIANT;

 	for (TInt index=FieldCount()-1 ; index>=0 ; index--)

 		delete (*iFieldArray)[index].iFieldHeader.iField.AsPtr(); // Delete the textField objects

 	iFieldArray->Reset();

 	AddInitialFieldEntryL(iFieldArray,0); // cannot leave in this context

 	iFieldArray->Compress(); // compress array

 	__TEST_INVARIANT;

 	}

 EXPORT_C CTextField* CTextFieldSet::NewFieldL(TUid aFieldType)

 	{

 	if (iFieldFactory)

 		return iFieldFactory->NewFieldL(aFieldType);

 	else

 		return NULL;

 	}

 EXPORT_C TInt CTextFieldSet::InsertFieldL(TInt aPos,CTextField* aField,TUid aFieldType)

 // Inserts a field header aField at aPos (aField should be declared on the heap)

 // The field initially has zero length: Update must be called afterward

 //

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS((aPos>=0),Panic(EPosOutsideDoc));

 	__ASSERT_DEBUG(aPos<=CharCount(),Panic(EPosOutsideDoc));

 	__ASSERT_ALWAYS(aField,Panic(ENoTextField));

 	TInt errLevel=KErrAlreadyExists;

 	TTextFieldEntry entry;

 	entry.iFieldHeader.iField = aField;

 	entry.iFieldHeader.iFieldType = aFieldType;

 	entry.iFieldValueLen = 0;

 	TInt index; TInt offset;

 	TBool inField = InField(aPos,index,offset);

 	if (!inField)

 		{// not inserting into a field

 		entry.iPreFieldLen = offset;

 		iFieldArray->InsertL(index,entry); // insert new entry

 		(*iFieldArray)[index+1].iPreFieldLen -= offset; // update old entry

 		errLevel = KErrNone;

 		}

 	else if (offset==0)

 		{// at start of field

 		entry.iPreFieldLen = (*iFieldArray)[index].iPreFieldLen;

 		iFieldArray->InsertL(index,entry); // insert new entry

 		(*iFieldArray)[index+1].iPreFieldLen = 0; // update old entry

 		errLevel = KErrNone;

 		}

 	__TEST_INVARIANT;

 	return errLevel;

 	}

 EXPORT_C const CTextField* CTextFieldSet::TextField(TInt aPos)const

 // Return a handle to the concrete field at document position aPos.

 // Returns NULL if there is no field at position aPos.

 //

 	{

 	__TEST_INVARIANT;

 	TInt index=-1;

 	TInt offset=0;

 	TBool inField=InField(aPos,index,offset);

 	if (!inField)

 		return NULL;

 	TSwizzle<CTextField> field=(*iFieldArray)[index].iFieldHeader.iField;

 	__ASSERT_DEBUG(field.IsPtr(),User::Invariant());

 	return field.AsPtr();

 	}

 EXPORT_C TInt CTextFieldSet::RemoveField(TInt aPos)

 // Removes the field from the array, adding it's content to the "before" of the next field.

 // After this function is called the text the field contained should be deleted. If this does

 //   not happen this function acts as a "ConvertFieldToText()"

 //

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS((aPos>=0),Panic(EPosOutsideDoc));

 	__ASSERT_DEBUG(aPos<=CharCount(),Panic(EPosOutsideDoc));

 	TInt errLevel=KErrNone;

 	TInt index; TInt offset;

 	if (!InField(aPos,index,offset))

 		errLevel = KErrNotFound;

 	else

 		// delete the field entry tidily

 		DeleteFieldEntry(index);

 	__TEST_INVARIANT;

 	return errLevel;

 	}

 EXPORT_C TInt CTextFieldSet::FieldCount() const

 	{

 	__TEST_INVARIANT;

 	// return count-1 because there is always an entry in the array for the text at the

 	//  end of the document, after the last field (maybe just the end of doc char)

 	return (iFieldArray->Count()-1);

 	}

 EXPORT_C TInt CTextFieldSet::CharCount() const

 // returns the number of characters in the document according to the field array

 	{

 	__TEST_INVARIANT;

 	TInt charCount = 0;

 	for (TInt index=FieldCount() ; index>=0 ; index--)

 		charCount += (*iFieldArray)[index].iPreFieldLen+(*iFieldArray)[index].iFieldValueLen;

 	return charCount;

 	}

 EXPORT_C TBool CTextFieldSet::FindFields(TInt aPos) const

 // Return ETrue if aPos is in a field

 //

 	{

 	TFindFieldInfo dummy;

 	return (FindFields(dummy,aPos,0));

 	}

 EXPORT_C TBool CTextFieldSet::FindFields(TFindFieldInfo& aInfo,TInt aPos, TInt aRange) const

 // Check whether aPos is in a field, then check whether any fields start in aRange

 //

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS(aRange>=0,Panic(ENegativeRange));

 	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutsideDoc));

 	__ASSERT_ALWAYS(aPos+aRange<=CharCount(),Panic(EPosOutsideDoc));

 	aInfo.iFieldCountInRange = 0;

 	aInfo.iFirstFieldLen = 0;

 	aInfo.iFirstFieldPos = 0;

 	TInt pos=aPos; // position in doc

 	// are we in a field to begin with?

 	TInt index; TInt offset;

 	if (InField(aPos,index,offset)) 

 		{

 		aInfo.iFieldCountInRange++;

 		aInfo.iFirstFieldLen = (*iFieldArray)[index].iFieldValueLen;

 		aInfo.iFirstFieldPos = aPos-offset;

 		pos += (*iFieldArray)[index].iFieldValueLen-offset+(*iFieldArray)[index+1].iPreFieldLen;

 		index++;

 		}

 	else

 		pos += (*iFieldArray)[index].iPreFieldLen-offset;

 	// step through array until aRange

 	while (pos<aPos+aRange)

 		// When entering this loop we're always at the beginning of a field value

 		// set aFieldEntry to first field found (if fieldcount==0)

 		// for each start of field encountered, fieldCount++

 		{

 		if (aInfo.iFieldCountInRange==0)

 			{

 			aInfo.iFirstFieldLen = (*iFieldArray)[index].iFieldValueLen;

 			aInfo.iFirstFieldPos = pos;

 			}

 		aInfo.iFieldCountInRange++;

 		pos += (*iFieldArray)[index].iFieldValueLen+(*iFieldArray)[index+1].iPreFieldLen;

 		index++;

 		}

 	// (if sensing right) check that we haven't ended adjacent to one or more zero-length fields 

 	if ( (aRange==0) && (pos==aPos) && (index<(iFieldArray->Count()-1)) && ((*iFieldArray)[index].iFieldValueLen==0) )

 		{

 		aInfo.iFieldCountInRange++;

 		index++;

 		while ( ((*iFieldArray)[index].iPreFieldLen==0) && ((*iFieldArray)[index].iFieldValueLen==0) && (index<(iFieldArray->Count()-1)) )

 			{

 			aInfo.iFieldCountInRange++;

 			index++;

 			}

 		}

 	__ASSERT_DEBUG(aInfo.iFieldCountInRange<=FieldCount(),Panic(EDebug));

 	return aInfo.iFieldCountInRange;

 	}

 EXPORT_C TInt CTextFieldSet::NewFieldValueL(HBufC*& aBuf, TInt aPos)

 // Returns the new value of the field at aPos (if applicable).

 // The method might reallocate aBuf parameter, so don't forget to:

 // 1) Push aBuf parameter in the CleanupStack before the call. The call

 //      may fail, then aBuf gets lost.

 // 2) Pop aBuf parameter from the CleanupStack after the call - aBuf may get

 //      reallocated, so the pushed pointer becomes invalid.

 // 3) Push aBuf in the CleanupStack again.

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS(aBuf,Panic(ENoBuffer));

 	__ASSERT_ALWAYS((aPos>=0),Panic(EPosOutsideDoc));

 	__ASSERT_DEBUG(aPos<=CharCount(),Panic(EPosOutsideDoc));

 	TInt errLevel = KErrNotFound;

 	TInt index; TInt offset;

 	if (InField(aPos,index,offset))

 		{// There's a field at aPos

 		TPtr bufPtr = aBuf->Des();

 		TInt reqLen = (*iFieldArray)[index].iFieldHeader.iField->Value(bufPtr);

 		while (reqLen>0)

 			{// If more storage is required for the value then reallocate the buffer

 			aBuf = aBuf->ReAllocL(reqLen); // for unicode compatability, rounds up

 			TPtr pointer = aBuf->Des();

 			reqLen = (*iFieldArray)[index].iFieldHeader.iField->Value(pointer);

 			}

 		// dont set new field length - this will be done in a subsequent NotifyInsert()

 		errLevel = KErrNone;

 		}

 	__TEST_INVARIANT;

 	return errLevel;

 	}

 EXPORT_C void CTextFieldSet::NotifyInsertion(TInt aPos, TInt aNumberAdded)

 // Informs the array that aNumberAdded characters have been inserted in the document

 //

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutsideDoc));

 	__ASSERT_DEBUG(aPos<=CharCount(),Panic(EPosOutsideDoc));

 	__ASSERT_ALWAYS(aNumberAdded>=0,Panic(EIllegalNegativeValue));

 	TInt index; TInt offset;

 	// are the extra characters in a field (matching away from fields)?

 	if (!InField(aPos,index,offset))

 		(*iFieldArray)[index].iPreFieldLen += aNumberAdded;

 	else

 		if (offset>0)

 			(*iFieldArray)[index].iFieldValueLen += aNumberAdded;

 		else

 			(*iFieldArray)[index].iPreFieldLen += aNumberAdded;

 	__TEST_INVARIANT;

 	}                             

 EXPORT_C void CTextFieldSet::NotifyFieldUpdate(TInt aPos, TInt aNewFieldValueLength)

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS((aPos>=0),Panic(EPosOutsideDoc));

 	__ASSERT_DEBUG(aPos<=CharCount(),Panic(EPosOutsideDoc));

 	__ASSERT_ALWAYS(aNewFieldValueLength>=0,Panic(EIllegalNegativeValue));

 	// Is the insert pos in a field? If so which?

 	TInt index; TInt offset;

 	__ASSERT_ALWAYS(InField(aPos,index,offset),Panic(EPosNotInField));

 	// Update the length of the relevant field

 	(*iFieldArray)[index].iFieldValueLen = aNewFieldValueLength;

 	__TEST_INVARIANT;

 	}

 EXPORT_C void CTextFieldSet::NotifyDeletion(TInt aPos,TInt aTotalRemoved)

 // Informs the array that aTotalRemoved characters have been removed from the document

 // Any fields wholely contained will be removed, those partially intersecting will just be shortened

 //

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutsideDoc));

 	__ASSERT_DEBUG(aPos<=CharCount(),Panic(EPosOutsideDoc));

 	__ASSERT_ALWAYS(aTotalRemoved>=0,Panic(EIllegalNegativeValue));

 	TInt charCount = CharCount();

 	//There is a possibility that there exists hidden end-of-document character in rich text objects.

 	//This is checked by the if statement & accordingly aTotalRemoved is decremented.

 	//i.e. aPos + aTotalRemoved could be greater by 1 than the CharCount(),  

 	//this is because the aTotalRemoved might also include 1 hidden character. - DEF095911

 	if(aPos+aTotalRemoved > charCount)

 		aTotalRemoved--;

 	__ASSERT_DEBUG(aPos+aTotalRemoved<=charCount, Panic(EPosOutsideDoc));

 	int index = 0;

 	int offset = 0;

 	int cur_pos = aPos;

 	int end_pos = aPos + aTotalRemoved;

 	TBool in_field = InField(cur_pos,index,offset);

 	TTextFieldEntry* field = NULL;

 	int field_start = 0;

 	int field_end = 0;

 	if (index >= 0 && index < iFieldArray->Count())

 		{

 		field = &(*iFieldArray)[index];

 		field_start = cur_pos - offset;

 		if (!in_field)

 			field_start += field->iPreFieldLen;

 		field_end = field_start + field->iFieldValueLen;

 		}

 	while (field)

 		{

 		// Reduce the size of the gap before the field if any.

 		int gap = Min(end_pos,field_start) - cur_pos;

 		if (gap > 0)

 			{

 			cur_pos += gap;

 			field->iPreFieldLen -= gap;

 			}

 		if (cur_pos >= end_pos)

 			break;

 		// Reduce the field length.

 		int remove_start = cur_pos;

 		int remove_end = Min(field_end,end_pos);

 		cur_pos = field_end;

 		field->iFieldValueLen -= (remove_end - remove_start);

 		// Delete the field if it is now of zero length.

 		int added_to_next = 0;

 		if (field->iFieldValueLen == 0)

 			{

 			added_to_next = field->iPreFieldLen;

 			DeleteFieldEntry(index);

 			}

 		else

 			index++;

 		// Move to the next field.

 		if (index < iFieldArray->Count())

 			{

 			field = &(*iFieldArray)[index];

 			field_start = cur_pos + field->iPreFieldLen - added_to_next;

 			field_end = field_start + field->iFieldValueLen;

 			}

 		else

 			field = NULL;

 		}

 	__TEST_INVARIANT;

 	}

 TBool CTextFieldSet::InField(const TInt aPos, TInt& anIndex, TInt& anOffset) const

 // works out whether or not aPos is in a field (matching right),

 //  sets anIndex to the index number of the field entry,

 //  and sets anOffset to the distance aPos is into the field or its preceeding gap

 //

 	{

 	__ASSERT_ALWAYS((aPos>=0),Panic(EPosOutsideDoc));

 	__ASSERT_DEBUG(aPos<=CharCount(),Panic(EPosOutsideDoc));

 	TBool inField;

 	TInt currentPos = 0;

 	anIndex = 0;

 	TInt lengthOfDoc = CharCount();

 	TInt lastFieldNum = iFieldArray->Count()-1;

 	// Find the index of the entry containing aPos

 	if (aPos == lengthOfDoc)

 		{

 		anIndex = lastFieldNum;

 		currentPos = aPos;

 		}

 	else 

 		{

 		anIndex = -1;

 		while (aPos >= currentPos)

 			{

 			anIndex++;

 			currentPos += (*iFieldArray)[anIndex].iPreFieldLen+(*iFieldArray)[anIndex].iFieldValueLen;

 			}

 		}

 	// Check that we have not skipped over any zero-length fields

 	if ( ((anIndex-1)>=0) && ((*iFieldArray)[anIndex-1].iFieldValueLen==0) )

 		{

 		TInt temp = currentPos - ((*iFieldArray)[anIndex].iPreFieldLen+(*iFieldArray)[anIndex].iFieldValueLen);

 		if (temp==aPos)

 			{// aPos is on a field boundary

 			currentPos = temp;

 			anIndex--;

 			while ( ((anIndex-1)>=0)

 				&&((*iFieldArray)[anIndex].iPreFieldLen==0)

 				&&((*iFieldArray)[anIndex-1].iFieldValueLen==0) )

 				{

 				anIndex--;

 				}

 			}

 		}

 	// Move to the start of the field (end of prefield) in entry [anIndex]

 	currentPos -= (*iFieldArray)[anIndex].iFieldValueLen;

 	// Determine whether or not aPos is in the field of entry[anIndex]

 	if (anIndex == lastFieldNum)

 		inField = EFalse;

 	else if (aPos >= currentPos)

 			inField = ETrue;

 		else

 			inField = EFalse;

 	// Calculate the offset

 	if (inField)

 		anOffset = aPos-currentPos;

 	else

 		anOffset = aPos+(*iFieldArray)[anIndex].iPreFieldLen-currentPos;

 	return inField;

 	}

 void CTextFieldSet::DeleteFieldEntry(TInt anIndex)

 	{

 	DeleteFieldEntry(iFieldArray,anIndex);

 	}

 void CTextFieldSet::DeleteFieldEntry(CArrayFixSeg<TTextFieldEntry>* aArray,TInt anIndex)

 // remove the entry anIndex from the array but don't delete the text from the doc.

 //

 	{

 	__ASSERT_ALWAYS(anIndex<(aArray->Count()-1),Panic(EIndexOutOfRange));

 	// add the entry's "before" to the "before" of the next entry.

 	(*aArray)[anIndex+1].iPreFieldLen += (*aArray)[anIndex].iPreFieldLen;

 	// add the field's length to the "before" of the next entry.	

 	(*aArray)[anIndex+1].iPreFieldLen += (*aArray)[anIndex].iFieldValueLen;

 	if ((*aArray)[anIndex].iFieldHeader.iField.IsPtr())

 		delete (*aArray)[anIndex].iFieldHeader.iField.AsPtr(); // delete the field

 	aArray->Delete(anIndex); // remove the entry from the array

 	}

 ///////////////////////////////////////////////

 // TTextFieldEntry

 ///////////////////////////////////////////////

 EXPORT_C void TTextFieldEntry::InternalizeL(RReadStream& aStream)

 // entry must have a header (ie cant be last entry in the array)

 	{

 	iPreFieldLen = aStream.ReadInt32L();

 	iFieldValueLen = aStream.ReadInt32L();

 	aStream>> iFieldHeader;

 	}

 EXPORT_C void TTextFieldEntry::ExternalizeL(RWriteStream& aStream)const

 // entry must have a header (ie cant be last entry in the array)

 	{

 	aStream.WriteInt32L(iPreFieldLen);

 	aStream.WriteInt32L(iFieldValueLen);

 	aStream<< iFieldHeader;

 	}