CFragmentedString Class Reference

class CFragmentedString : protected CArrayPtrFlat< HBufC >

Utility that allows a single string to be built from an array of consecutive sub-strings.

The sub-strings can be inserted by reference or copied.

The object maintains information that points to a current position within the string. A typical use is to test the contents of the string using one of the Match...() functions, and then use ConsumeMatched() to advance past the matched area.

The class also supports inserting an unlimited number of marks in the string, and performing operations relative to the head (i.e. last inserted) mark.

Nested Classes and Structures

Public Member Functions
CFragmentedString ()
~CFragmentedString ()
IMPORT_C void AddStringL ( HBufC *)
IMPORT_C void AddStringL (const TDesC &)
IMPORT_C void ConsumeMatched ()
IMPORT_C HBufC * ContentL ()
IMPORT_C void DeleteMark ()
IMPORT_C void InsertStringL ( HBufC *)
IMPORT_C TInt Length ()
IMPORT_C void Mark ()
IMPORT_C HBufC * MarkedL ()
IMPORT_C HBufC * MarkedWithInitialTextL (const TDesC &)
IMPORT_C TStringMatch Match (const TDesC &)
IMPORT_C TStringMatch MatchNotSelect (const TDesC &)
IMPORT_C TStringMatch MatchRange (const TUint , const TUint )
IMPORT_C TStringMatch MatchSelect (const TDesC &)
IMPORT_C void ReplaceMarkedAndSkipL ( HBufC *)
IMPORT_C void ReplaceMarkedL ( HBufC *)
IMPORT_C void Reset ()
IMPORT_C void ResetToMark ()
IMPORT_C HBufC * StringL ()
Protected Member Functions
IMPORT_C void DeleteToMark (const TStringMark &)
CFragmentedString::TStringMatch DoMatchSelect (const TDesC &, TBool )
TBool FindNextMatchChar ( TUint &)
IMPORT_C void InsertStringToL ( HBufC *, TInt , TInt )
void StartMatch ()
HBufC * StringL ( TInt , TInt , TInt , TInt , const TDesC *)
Inherited Functions
CArrayFix< HBufC * >::AppendL(const HBufC *&)
CArrayFix< HBufC * >::AppendL(const HBufC *&,TInt)
CArrayFix< HBufC * >::AppendL(const HBufC **,TInt)
CArrayFix< HBufC * >::Array()const
CArrayFix< HBufC * >::At(TInt)
CArrayFix< HBufC * >::At(TInt)const
CArrayFix< HBufC * >::Back(TInt)
CArrayFix< HBufC * >::Back(TInt)const
CArrayFix< HBufC * >::CArrayFix(TBufRep,TInt)
CArrayFix< HBufC * >::End(TInt)
CArrayFix< HBufC * >::End(TInt)const
CArrayFix< HBufC * >::ExpandL(TInt)
CArrayFix< HBufC * >::ExtendL()
CArrayFix< HBufC * >::Find(const HBufC *&,TKeyArrayFix &,TInt &)const
CArrayFix< HBufC * >::FindIsq(const HBufC *&,TKeyArrayFix &,TInt &)const
CArrayFix< HBufC * >::InsertIsqAllowDuplicatesL(const HBufC *&,TKeyArrayFix &)
CArrayFix< HBufC * >::InsertIsqL(const HBufC *&,TKeyArrayFix &)
CArrayFix< HBufC * >::InsertL(TInt,const HBufC *&)
CArrayFix< HBufC * >::InsertL(TInt,const HBufC *&,TInt)
CArrayFix< HBufC * >::InsertL(TInt,const HBufC **,TInt)
CArrayFix< HBufC * >::ResizeL(TInt)
CArrayFix< HBufC * >::ResizeL(TInt,const HBufC *&)
CArrayFix< HBufC * >::operator[](TInt)
CArrayFix< HBufC * >::operator[](TInt)const
CArrayFixBase::AtR(const CBase *,TInt)
CArrayFixBase::CArrayFixBase(TBufRep,TInt,TInt)
CArrayFixBase::Compress()
CArrayFixBase::Count()const
CArrayFixBase::CountR(const CBase *)
CArrayFixBase::Delete(TInt)
CArrayFixBase::Delete(TInt,TInt)
CArrayFixBase::Find(const TAny *,TKeyArrayFix &,TInt &)const
CArrayFixBase::FindIsq(const TAny *,TKeyArrayFix &,TInt &)const
CArrayFixBase::InsertIsqAllowDuplicatesL(const TAny *,TKeyArrayFix &)
CArrayFixBase::InsertIsqL(const TAny *,TKeyArrayFix &)
CArrayFixBase::InsertL(TInt,const TAny *)
CArrayFixBase::InsertL(TInt,const TAny *,TInt)
CArrayFixBase::InsertRepL(TInt,const TAny *,TInt)
CArrayFixBase::ResizeL(TInt,const TAny *)
CArrayFixBase::SetKey(TKeyArrayFix &)const
CArrayFixBase::SetReserveFlatL(TInt)
CArrayFixBase::Sort(TKeyArrayFix &)
CArrayFixBase::~CArrayFixBase()
CArrayPtr< HBufC >::CArrayPtr(TBufRep,TInt)
CArrayPtr< HBufC >::ResetAndDestroy()
CArrayPtrFlat< HBufC >::CArrayPtrFlat(TInt)
CArrayPtrFlat< HBufC >::SetReserveL(TInt)
CBase::CBase()
CBase::Delete(CBase *)
CBase::Extension_(TUint,TAny *&,TAny *)
CBase::operator new(TUint)
CBase::operator new(TUint,TAny *)
CBase::operator new(TUint,TLeave)
CBase::operator new(TUint,TLeave,TUint)
CBase::operator new(TUint,TUint)
CBase::~CBase()
Public Member Enumerations
enum TStringMatch { ENoMatch , EMatch , EInsufficientData }
Protected Member Type Definitions
typedef CStack < TStringMark , ETrue > CMarkStack
Protected Attributes
TInt iCurrentCharacter
TInt iCurrentIndex
CMarkStack iMarkStack
TStringMatch iMatched
TInt iMatchedToCharacter
TInt iMatchedToIndex

Constructor & Destructor Documentation

CFragmentedString()

IMPORT_C CFragmentedString ( )

Constructor

~CFragmentedString()

IMPORT_C ~CFragmentedString ( )

Destructor.

This resets and destroys the HBufC array.

Member Functions Documentation

AddStringL(HBufC *)

IMPORT_C void AddStringL ( HBufC * aString )

Appends a sub-string to the string.

Parameters

HBufC * aString Sub-string to append

AddStringL(const TDesC &)

IMPORT_C void AddStringL ( const TDesC & aString )

Copies a sub-string and then appends the copy to the string.

Parameters

const TDesC & aString Sub-string to append

ConsumeMatched()

IMPORT_C void ConsumeMatched ( )

Removes and deletes all sub-strings occurring before the position of the last successful match.

Any sub-strings at or after a mark are not deleted, regardless of the last successful match position.

ContentL()

IMPORT_C HBufC * ContentL ( ) const

Gets the entire string in a newly-allocated buffer.

It is the caller's responsibility to clean up the returned string.

DeleteMark()

IMPORT_C void DeleteMark ( )

Deletes the head mark.

DeleteToMark(const TStringMark &)

IMPORT_C void DeleteToMark ( const TStringMark & aStringMark ) [protected]

Deletes from the current index position to the specified mark.

Parameters

const TStringMark & aStringMark Mark to delete to

DoMatchSelect(const TDesC &, TBool)

CFragmentedString::TStringMatch DoMatchSelect ( const TDesC & aSelection,
TBool aInSelection
) [protected]

Parameters

const TDesC & aSelection
TBool aInSelection

FindNextMatchChar(TUint &)

TBool FindNextMatchChar ( TUint & aChar ) [protected]

Parameters

TUint & aChar

InsertStringL(HBufC *)

IMPORT_C void InsertStringL ( HBufC * aString )

Inserts a specified string at the current index position.

Parameters

HBufC * aString String to insert

InsertStringToL(HBufC *, TInt, TInt)

IMPORT_C void InsertStringToL ( HBufC * aString,
TInt aStringIndex,
TInt aLengthIntoString
) [protected]

Inserts a string at a specified position.

1. if aLengthIntoString is 0, the function inserts a new sub-string at array position aStringIndex

2. if aLengthIntoString is equal to the length of the sub-string at aStringIndex, then it inserts a new sub-string at array position aStringIndex+1.

3. If aLengthIntoString is in the middle of theaStringIndex sub-string, then it:

a) inserts a new sub-string at aStringIndex+1 holdingaString

b) inserts a new sub-string at aStringIndex+2 holding the data from aStringIndex after aLengthIntoString

c) truncates the original aStringIndex to hold only the data before aLengthIntoString

Parameters

HBufC * aString String to insert
TInt aStringIndex Array index of the sub-string at which to insert
TInt aLengthIntoString Character position within the sub-string at which to insert

Length()

IMPORT_C TInt Length ( ) const

Gets the length of the string.

Mark()

IMPORT_C void Mark ( )

Adds a mark at the current index position.

This mark becomes the head mark.

Note this function can leave with an out of memory error.

MarkedL()

IMPORT_C HBufC * MarkedL ( )

Gets a new string containing the string contents from the head mark to the current index position.

It is the caller's responsibility to clean up the returned string.

MarkedWithInitialTextL(const TDesC &)

IMPORT_C HBufC * MarkedWithInitialTextL ( const TDesC & aInitialText )

Gets a new string containing the string contents from the head mark to the current index position, prepended with a specified string.

It is the caller's responsibility to clean up the returned string.

Parameters

const TDesC & aInitialText String to prepend to the result

Match(const TDesC &)

IMPORT_C TStringMatch Match ( const TDesC & aString )

Tests if a specified target string occurs at the current position.

The function does a byte-for-byte comparison of the string contents from the current position against aString.

Parameters

const TDesC & aString String to attempt to match

MatchNotSelect(const TDesC &)

IMPORT_C TStringMatch MatchNotSelect ( const TDesC & aSelection )

Tests if the character at the current position does not match any character in a specified string.

Parameters

const TDesC & aSelection String specifying one or more characters, any of which will result in a failed match

MatchRange(const TUint, const TUint)

IMPORT_C TStringMatch MatchRange ( const TUint aLower,
const TUint aUpper
)

Tests if the character at the current position is within a specified character code range.

Parameters

const TUint aLower Lower range (inclusive) for a match
const TUint aUpper Upper range (inclusive) for a match

MatchSelect(const TDesC &)

IMPORT_C TStringMatch MatchSelect ( const TDesC & aSelection )

Tests if the character at the current position matches any character in a specified string.

Parameters

const TDesC & aSelection String specifying one or more characters, any of which will result in a successful match

ReplaceMarkedAndSkipL(HBufC *)

IMPORT_C void ReplaceMarkedAndSkipL ( HBufC * aString )

Replaces the string contents to the head mark with a specified string, and then advances the current index position to the next sub-string.

Parameters

HBufC * aString Replacment string

ReplaceMarkedL(HBufC *)

IMPORT_C void ReplaceMarkedL ( HBufC * aString )

Replaces the string contents to the head mark with a specified string.

Parameters

HBufC * aString Replacment string

Reset()

IMPORT_C void Reset ( )

Resets the string.

This resets and destroys the HBufC array, and clears all indexes and marks.

ResetToMark()

IMPORT_C void ResetToMark ( )

Moves the current index position to the head mark.

StartMatch()

void StartMatch ( ) [protected]

StringL()

IMPORT_C HBufC * StringL ( ) const

Gets a string containing all sub-strings after the current position in a newly-allocated buffer.

It is the caller's responsibility to clean up the returned string.

StringL(TInt, TInt, TInt, TInt, const TDesC *)

HBufC * StringL ( TInt aStartIndex,
TInt aStartCharacter,
TInt aEndIndex,
TInt aEndCharacter,
const TDesC * aInitialText = NULL
) const [protected]

Parameters

TInt aStartIndex
TInt aStartCharacter
TInt aEndIndex
TInt aEndCharacter
const TDesC * aInitialText = NULL

Member Enumerations Documentation

Enum TStringMatch

Defines possible results of a string matching operation for this class.

Enumerators

ENoMatch

There was no match.

EMatch

There was a complete match.

EInsufficientData

String contained insufficient data to perform the match operation.

This can mean that the start of the target string was matched, but the string being searched ended before a complete match was found.

Member Type Definitions Documentation

Typedef CMarkStack

typedef CStack < TStringMark , ETrue > CMarkStack [protected]

A stack of string position marks.

Member Data Documentation

TInt iCurrentCharacter

TInt iCurrentCharacter [protected]

Current character position within the current sub-string.

TInt iCurrentIndex

TInt iCurrentIndex [protected]

Array index of the current sub-string.

CMarkStack iMarkStack

CMarkStack iMarkStack [protected]

Stack of marks in the string.

Mark() pushes a mark on the stack; DeleteMark() pops one off.

TStringMatch iMatched

TStringMatch iMatched [protected]

Result of the last match operation.

TInt iMatchedToCharacter

TInt iMatchedToCharacter [protected]

Current character position within the iMatchedToIndex sub-string found in the last match operation.

TInt iMatchedToIndex

TInt iMatchedToIndex [protected]

Array index of the sub-string found in the last match operation.