/*
* Copyright (c) 2002-2008 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 "NumberGrouping.h"
#include "RegularExpression.h"
#include "cleanuputil.h"
#include <barsread.h>
#include <eikenv.h>
#include <centralrepository.h>
#include <NumberGroupingCRKeys.h>
const TText KNumberGroupingWildcard('n');
const TText KNumberGroupingOneOrMoreCharactersToken('~');
// This constant represents all the valid whitespace that we can handle. Several
// APIs give whitespace special significance as a formatting character, especially
// those methods used to obtain text for formatting into fixed-width UI elements
// where spaces are not to be rendered at the margins.
const TText KNumberGroupingSpace(' ');
const TInt KMinimumLengthToGroup = 1; // No grouping occurs if fewer than this in unformatted buffer
#include <numbergrouping.rsg>
GLDEF_C void Panic(TNumberGroupingPanic aPanic)
{
_LIT(KPanicCat,"Number Grouping");
User::Panic(KPanicCat, aPanic);
}
// Valid phone number characters apart from IsDigit() characters are listed here
const TText KAdditionalPhoneNumberCharacters[] = {'+','#','*','p','w'};
NONSHARABLE_CLASS(CPNGNumberGroupingExtension): public CBase
{
public:
CPNGNumberGroupingExtension();
~CPNGNumberGroupingExtension();
public:
TInt iMaxExtraCharacters;
TInt iNumberGroupingCRValue;
};
CPNGNumberGroupingExtension::CPNGNumberGroupingExtension()
{
}
CPNGNumberGroupingExtension::~CPNGNumberGroupingExtension()
{
}
CPNGNumberGrouping::TPNGSeparator::TPNGSeparator()
: iPosition(-1), iSeparatorCharacter(KNumberGroupingSpace)
{
}
CPNGNumberGrouping::TPNGSeparator::TPNGSeparator( TInt aPosition, TText aSeparatorCharacter )
: iPosition(aPosition), iSeparatorCharacter(aSeparatorCharacter)
{
}
CPNGNumberGrouping::TPNGGroupingInfo::TPNGGroupingInfo()
{
}
// CPNGNumberGrouping - grouping engine class
CPNGNumberGrouping::CPNGNumberGrouping(TInt aMaxLength /* = 0 */, TBool aReversed /* = EFalse */) :
iForceLanguage(ELangTest),
iUnformattedNumberPtr(KNullDesC),
iFormattedNumberPtr(KNullDesC),
iReverseFormattedNumberPtr(KNullDesC),
iSelectionPtr(KNullDesC),
iLanguage(ELangTest),
iMaxUnformattedLength(aMaxLength),
iReversed(aReversed),
iMatchedPatternIndex(ENoMatchedPattern)
{
}
EXPORT_C CPNGNumberGrouping* CPNGNumberGrouping::NewL( TInt aMaxLength, TBool aReserved)
{
CPNGNumberGrouping* s = NewLC(aMaxLength, aReserved);
CleanupStack::Pop();
return s;
}
EXPORT_C CPNGNumberGrouping* CPNGNumberGrouping::NewLC( TInt aMaxLength, TBool aReserved)
{
CPNGNumberGrouping* s = new(ELeave)CPNGNumberGrouping( aMaxLength, aReserved);
CleanupStack::PushL(s);
s->ConstructL();
return s;
}
void CPNGNumberGrouping::ConstructL()
{
iExtension = new (ELeave) CPNGNumberGroupingExtension();
CRepository* repository = NULL;
iExtension->iNumberGroupingCRValue = 0;
TRAPD(ret, repository = CRepository::NewL(KCRUidNumberGrouping));
if (ret == KErrNone)
{
ret = repository->Get(KNumberGrouping, iExtension->iNumberGroupingCRValue);
}
delete repository;
// Read from resource first in order to obtain a value for iExtension->iMaxExtraCharacters
iLanguage = doReadLanguageFromSharedData();
doReadFormatInfoFromResourceFileL(); // This sets iExtension->iMaxExtraCharacters
// Allocation of buffers. Note that iMaxUnformattedLength must be retained as member
// data because HBufCs may come back with more storage available than asked for.
// The uncertainty in the actual length provided by the HBufCs means that although
// they are asked to be different by iExtension->iMaxExtraCharacters, the difference between the
// actual MaxLengths may be less than iMaxExtraCharcaters.
// The approach decided upon is to retain iMaxUnformattedLength as member data and
// use IT everywhere throughout this class's implementation, NEVER using
// iUnformattedNumber->Des().MaxLength()
iUnformattedNumber = HBufC::NewL(iMaxUnformattedLength);
iFormattedNumber = HBufC::NewL(iMaxUnformattedLength + iExtension->iMaxExtraCharacters);
// Create revesed buffer only if requested
if ( iReversed )
iReverseFormattedNumber = HBufC::NewL(iMaxUnformattedLength + iExtension->iMaxExtraCharacters);
}
EXPORT_C CPNGNumberGrouping::~CPNGNumberGrouping()
{
doClearGroupingItemsList();
delete iUnformattedNumber;
delete iFormattedNumber;
delete iReverseFormattedNumber;
delete iRegExp;
delete iExtension;
}
EXPORT_C TInt CPNGNumberGrouping::Insert(TInt aIndex, TText aChar)
{
if( aIndex >= 0 && aIndex <= iUnformattedNumber->Length())
{
if(iUnformattedNumber->Length() >= iMaxUnformattedLength)
return KErrOverflow;
TBuf<1> bufChar(1);
bufChar[0] = aChar;
TPtr ptrModifyable(iUnformattedNumber->Des());
ptrModifyable.Insert(aIndex, bufChar);
doClearFormattedNumbers();
return KErrNone;
}
return KErrIndexOutOfRange;
}
EXPORT_C TInt CPNGNumberGrouping::Delete(TInt aIndex)
{
if(aIndex >= 0 && aIndex < iUnformattedNumber->Length())
{
TPtr ptrModifyable(iUnformattedNumber->Des());
ptrModifyable.Delete(aIndex, KSingleCharacter);
doClearFormattedNumbers();
return KErrNone;
}
return KErrIndexOutOfRange;
}
EXPORT_C TInt CPNGNumberGrouping::Append(TText aChar)
{
if(iUnformattedNumber->Length() >= iMaxUnformattedLength)
return KErrOverflow;
TBuf<1> bufChar(1);
bufChar[0] = aChar;
TPtr ptrModifyable(iUnformattedNumber->Des());
ptrModifyable.Append(bufChar);
doClearFormattedNumbers();
return KErrNone;
}
EXPORT_C TInt CPNGNumberGrouping::Set(const TDesC& aNumber)
{
if( aNumber.Length() > iMaxUnformattedLength )
return KErrOverflow;
TPtr ptrModifyable( iUnformattedNumber->Des() );
ptrModifyable.Copy( aNumber );
doClearFormattedNumbers();
return KErrNone;
}
EXPORT_C TInt CPNGNumberGrouping::Length() const
{
if(!iFormattedNumber->Length()) // This test is used as the trigger to reformat
FormattedNumber();
return iFormattedNumber->Length();
}
EXPORT_C TInt CPNGNumberGrouping::UnFormattedLength() const
{
return iUnformattedNumber->Length();
}
EXPORT_C TInt CPNGNumberGrouping::MaxDisplayLength() const
{
// Despite its name, this method returns the max length of the UNFORMATTED buffer
// This must not be implemented to return the actual length available in
// iUnformattedBuffer.
return iMaxUnformattedLength;
}
EXPORT_C TBool CPNGNumberGrouping::IsSpace(TInt aPos) const
{
// Very tricky semantics for this. Must be a space inserted by the formatting
if ( iFormattedNumber->Length() > aPos &&
iFormattedNumber->operator[](aPos) == KNumberGroupingSpace &&
// Check also that is is less than the length to group + inserted characters
aPos < ( LengthToGroup() + (iFormattedNumber->Length() - iUnformattedNumber->Length()) ) )
return ETrue;
else
return EFalse;
}
EXPORT_C const TDesC& CPNGNumberGrouping::FormattedNumber(TInt aFrom, TInt aTo) const
{
if(iUnformattedNumber->Length() != 0 &&
aFrom >= 0 &&
aFrom <= aTo )
{
FormattedNumber();
iFormattedNumberPtr.Set(KNullDesC);
TInt length = iFormattedNumber->Length();
if(aTo < length + 1)
{
TInt length = iFormattedNumber->Length();
if ( iExtension->iNumberGroupingCRValue )
{
// Advance to the next non-space
while( (aFrom < length ) && (*iFormattedNumber)[aFrom] == KNumberGroupingSpace )
{
++aFrom;
}
// Retreat to the last non-space
while( (aTo > 0) && (*iFormattedNumber)[aTo] == KNumberGroupingSpace )
{
--aTo;
}
}
// Does fetching the descriptor still make sense?
if ( (0 <= aFrom) && (aFrom <= aTo) && (aTo < length) )
iFormattedNumberPtr.Set( iFormattedNumber->Mid( aFrom, aTo-aFrom+1 ) );
}
}
else
{
if(iFormattedNumber->Length())
{
CPNGNumberGrouping* pThis = const_cast<CPNGNumberGrouping*>(this);
pThis->doClearFormattedNumbers();
}
iFormattedNumberPtr.Set(KNullDesC);
}
return iFormattedNumberPtr;
}
EXPORT_C const TDesC& CPNGNumberGrouping::FormattedNumber() const
{
if( !iFormattedNumber->Length() )
{
TInt err = KErrNone;
CPNGNumberGrouping* pThis = const_cast<CPNGNumberGrouping*>(this);
if( LengthToGroup() < KMinimumLengthToGroup || !iExtension->iNumberGroupingCRValue )
{
// This is now just a short cut, as doNumberGroupingL handles premature truncation of
// formatting. But this avoids all the language checking
doNumberSquashing(); // copies the unformatted number straight into the formatted number
}
else
{
TLanguage eLanguage;
if(iForceLanguage != ELangTest)
eLanguage = iForceLanguage;
else
eLanguage = doReadLanguageFromSharedData();
if(eLanguage != iLanguage)
{
iLanguage = eLanguage;
TRAP(err, pThis->doReadFormatInfoFromResourceFileL());
if(err != KErrNone)
{
iFormattedNumberPtr.Set(KNullDesC);
return iFormattedNumberPtr;
}
}
TRAP(err, doNumberGroupingL());
}
if(err != KErrNone)
pThis->doClearFormattedNumbers();
else
iFormattedNumberPtr.Set(iFormattedNumber->Ptr(), iFormattedNumber->Length());
}
return iFormattedNumberPtr;
}
EXPORT_C const TDesC& CPNGNumberGrouping::ReverseFormattedNumber(TInt aFrom, TInt aTo) const
{
if ( iReversed )
{
if(iUnformattedNumber->Length() != 0 &&
aFrom >= 0 &&
aFrom <= aTo)
{
ReverseFormattedNumber();
iReverseFormattedNumberPtr.Set(KNullDesC);
TInt length = iReverseFormattedNumber->Length();
if( aTo < length + 1 )
{
// Advance to the next non-space
if( iExtension->iNumberGroupingCRValue )
{
while( (aFrom < length ) && (*iReverseFormattedNumber)[aFrom] == KNumberGroupingSpace )
{
++aFrom;
}
// Retreat to the last non-space
while( (aTo > 0) && (*iReverseFormattedNumber)[aTo] == KNumberGroupingSpace )
{
--aTo;
}
}
// Does fetching the descriptor still make sense?
if ( (0 <= aFrom) && (aFrom <= aTo) && (aTo < length) )
iReverseFormattedNumberPtr.Set(
iReverseFormattedNumber->Mid( aFrom, aTo-aFrom+1) );
}
}
else
iReverseFormattedNumberPtr.Set(KNullDesC);
}
return iReverseFormattedNumberPtr; // Zero initialized at construction
}
EXPORT_C const TDesC& CPNGNumberGrouping::ReverseFormattedNumber() const
{
if( iReverseFormattedNumber && !iReverseFormattedNumber->Length())
{
if(!iFormattedNumber->Length())
FormattedNumber();
TInt nLength = iFormattedNumber->Length();
TPtr ptrModifyable(iReverseFormattedNumber->Des());
TBuf<1> bufChar(1);
for(TInt i = nLength; i > 0; --i)
{
TText cChar = (*iFormattedNumber)[i-1];
bufChar[0] = cChar;
ptrModifyable.Insert(nLength - i, bufChar);
}
iReverseFormattedNumberPtr.Set(iReverseFormattedNumber->Ptr(), nLength);
}
return iReverseFormattedNumberPtr;
}
EXPORT_C const TDesC& CPNGNumberGrouping::Selection(TInt aFrom, TInt aTo) const
{
if(aFrom < iUnformattedNumber->Length())
{
TPtr ptrUnformatted = iUnformattedNumber->Des();
iSelectionPtr.Set(&(ptrUnformatted[aFrom]), aTo - aFrom);
}
else
iSelectionPtr.Set(KNullDesC);
return iSelectionPtr;
}
EXPORT_C const TDesC& CPNGNumberGrouping::UnFormattedNumber(TInt aFrom, TInt aTo) const
{
if (iUnformattedNumber && aFrom >= 0 && aFrom <= aTo && aTo < iUnformattedNumber->Length())
{
iUnformattedNumberPtr.Set(&((*iUnformattedNumber)[aFrom]), aTo - aFrom + 1);
}
else
{
iUnformattedNumberPtr.Set(KNullDesC);
}
return iUnformattedNumberPtr;
}
EXPORT_C const TDesC& CPNGNumberGrouping::UnFormattedNumber() const
{
return UnFormattedNumber(0, iUnformattedNumber->Length() - 1);
}
TLanguage CPNGNumberGrouping::doReadLanguageFromSharedData() const
{
if (iExtension->iNumberGroupingCRValue)
{
return ELangAmerican;
}
else
{
return ELangTest;
}
}
void CPNGNumberGrouping::doClearFormattedNumbers()
{
TPtr ptrModifyable( iUnformattedNumber->Des() );
for (TInt index = 0; index < ptrModifyable.Length(); index++)
{
TChar ch = TChar(ptrModifyable[index]);
ch.Fold( TChar::EFoldDigits | TChar::EFoldSpaces);
}
iFormattedNumber->Des().Zero();
iFormattedNumberPtr.Set(KNullDesC);
if ( iReverseFormattedNumber )
iReverseFormattedNumber->Des().Zero();
iReverseFormattedNumberPtr.Set(KNullDesC);
iMatchedPatternIndex = ENoMatchedPattern;
}
void CPNGNumberGrouping::doReadFormatInfoFromResourceFileL()
{
doClearGroupingItemsList();
delete iRegExp;
iRegExp = NULL;
RPointerArray<TDesC> parrGroupingPatternsList;
CleanupResetAndDestroyPushL(parrGroupingPatternsList);
TInt maxExtraCharacters(0);
RFs fs;
CleanupClosePushL(fs);
if(fs.Connect() == KErrNone)
{
RResourceFile resourceFile;
CleanupClosePushL(resourceFile);
resourceFile.OpenL(fs, _L("z:\\resource\\numbergrouping.rsc"));
HBufC8* bufResource = resourceFile.AllocReadL(R_GROUPING_MAPPING);
TResourceReader resourceReader;
resourceReader.SetBuffer(bufResource);
TInt nLanguageCount = resourceReader.ReadInt8();
TBool bLanguageMatches = EFalse;
while(nLanguageCount-- || !bLanguageMatches)
{
TBool bLanguageMatches = (resourceReader.ReadInt8() == iLanguage);
if(bLanguageMatches || ((nLanguageCount == -1) && !bLanguageMatches))
{
TInt nGroupingSchemeCount = resourceReader.ReadInt8();
while(nGroupingSchemeCount--)
{
TInt thisMaxExtraCharacters(0);
ReadGroupingSchemeL(
resourceReader, parrGroupingPatternsList, thisMaxExtraCharacters );
// take this new max extra characters if bigger
maxExtraCharacters = Max( maxExtraCharacters, thisMaxExtraCharacters );
}
break; // This breaks out because we take the first language that matches
} // End of if on language/locale test
else // skip other locales
{
TInt nGroupingSchemeCount = resourceReader.ReadInt8();
while(nGroupingSchemeCount--)
{
SkipGroupingSchemeL( resourceReader );
}
}
}
delete bufResource;
resourceFile.Close();
CleanupStack::Pop(); // resource file
}
fs.Close();
CleanupStack::Pop(); // file system
iExtension->iMaxExtraCharacters = maxExtraCharacters; // Latch the high water mark of extra characters
iRegExp = CRegularExpression::NewL(&parrGroupingPatternsList);
CleanupStack::PopAndDestroy(&parrGroupingPatternsList); // patterns list
}
void CPNGNumberGrouping::doNumberGroupingL() const
{
TInt lengthToGroup = LengthToGroup();
if ( lengthToGroup >= KMinimumLengthToGroup )
{
TInt matchedPattern = KErrNotFound;
TInt newMatchedPattern = KErrNotFound;
// Search for matches in the RegExp object. It returns the next matching pattern
// However, even if there is a match, lengthToGroup may not be in the deployment
// length range between minDigits and MaxDigits, inclusive
do {
// Check for another matching pattern
newMatchedPattern = iRegExp->SearchFrom( newMatchedPattern+1, *iUnformattedNumber);
if( newMatchedPattern != KErrNotFound) // Found a match, but it is OK?
{
TInt minDigits = iGroupingItemsList[newMatchedPattern]->iMinNumberOfDigits;
TInt maxDigits = iGroupingItemsList[newMatchedPattern]->iMaxNumberOfDigits;
// Fill in sensible values for min and max if not present
if(minDigits == -1)
minDigits = 0;
if(maxDigits == -1)
maxDigits = lengthToGroup;
if ( minDigits <= lengthToGroup && lengthToGroup <= maxDigits )
{
matchedPattern = newMatchedPattern; // accept this new pattern
break;
}
}
} while ( newMatchedPattern != KErrNotFound );
// Actually go and do the grouping
if ( matchedPattern != KErrNotFound )
{
doNumberGroupingForPatternL( matchedPattern, lengthToGroup );
return;
}
}
// if we get to here, either the string was not matched to any of the patterns or the
// unformatted string is exactly the display length. In either case we call
// doNumberSquashing() which simply leaves the string as it is...
doNumberSquashing();
}
void CPNGNumberGrouping::doNumberGroupingForPatternL( TInt aMatchingPattern, TInt aLengthToGroup ) const
{
iMatchedPatternIndex = aMatchingPattern;
TInt nLowPos = 0;
TInt nHighPos = 0;
TPtr desUnformattedNumber = iUnformattedNumber->Des();
TInt unformattedLength = iUnformattedNumber->Length();
__ASSERT_ALWAYS( aLengthToGroup <= unformattedLength , Panic(ENumberGroupingBadLengthToGroup) );
TPNGGroupingInfo* matchedPattern = iGroupingItemsList[iMatchedPatternIndex];
TInt nAfterCount = matchedPattern->iAfterPositions.Count();
TBool bBeforePosition = (matchedPattern->iBeforePosition.iPosition == -1)?0:1;
// Test to see if the beforePosition can be used with the current text length.
// The following does not allow the before position to be used if it would result in an
// insertion right next to one from the AfterPositions.
// That is, tildas in the formatting string represent 1 or more characters.
// e.g. if the last afterPosition is 4 and the before position is 3, then a 7 digit
// number will not be able to have the before position used.
if( nAfterCount &&
(unformattedLength - matchedPattern->iBeforePosition.iPosition) <=
matchedPattern->iAfterPositions[nAfterCount - 1].iPosition)
{
bBeforePosition = EFalse;
}
TPtr ptrModifyable(iFormattedNumber->Des());
for(TInt i = 0; i < nAfterCount && nHighPos < aLengthToGroup ; ++i)
{
nHighPos = matchedPattern->iAfterPositions[i].iPosition;
if ( nHighPos >= aLengthToGroup )
break;
if(nHighPos < unformattedLength)
{
ptrModifyable.Append( desUnformattedNumber.Mid( nLowPos, nHighPos - nLowPos) );
ptrModifyable.Append(matchedPattern->iAfterPositions[i].iSeparatorCharacter);
nLowPos = nHighPos;
}
}
// Do not do "before end" formatting at all if there is any truncation
if ( aLengthToGroup < unformattedLength )
{
TInt nBeforePosition = matchedPattern->iBeforePosition.iPosition;
if(bBeforePosition && nBeforePosition < unformattedLength)
{
nHighPos = unformattedLength - nBeforePosition;
ptrModifyable.Append( desUnformattedNumber.Mid( nLowPos, nHighPos - nLowPos) );
ptrModifyable.Append( matchedPattern->iBeforePosition.iSeparatorCharacter );
nLowPos = nHighPos;
}
}
nHighPos = unformattedLength;
ptrModifyable.Append( desUnformattedNumber.Mid( nLowPos, nHighPos - nLowPos) );
}
void CPNGNumberGrouping::doNumberSquashing() const
{
__ASSERT_ALWAYS( !iFormattedNumber->Length(), Panic(ENumberGroupingFormattedNumberAlreadyExists) );
// just copy from one t'other...
TPtr ptrModifyable(iFormattedNumber->Des());
ptrModifyable.Copy(*iUnformattedNumber);
iMatchedPatternIndex = ENoMatchedPattern;
}
void CPNGNumberGrouping::doClearGroupingItemsList()
{
TInt nCount = iGroupingItemsList.Count();
for(TInt i = 0; i < nCount; ++i)
{
iGroupingItemsList[i]->iAfterPositions.Close();
delete iGroupingItemsList[i];
iGroupingItemsList[i] = NULL;
}
iGroupingItemsList.Close();
}
void CPNGNumberGrouping::ReadGroupingSchemeL(
TResourceReader& aResourceReader,
RPointerArray<TDesC>& aGroupingPatternsList,
TInt& aMaxExtraCharacters )
{
CleanupResetAndDestroyPushL(aGroupingPatternsList);
TPNGGroupingInfo* groupingInfo = new (ELeave) TPNGGroupingInfo;
CleanupStack::PushL( groupingInfo );
// Read in all resource for this grouping scheme, perform checking and then analyze it
HBufC* initialDigits = aResourceReader.ReadHBufCL();
__ASSERT_ALWAYS( initialDigits, Panic( ENumberGroupingNoInitialDigitsInResource ) );
CleanupStack::PushL( initialDigits );
groupingInfo->iMinNumberOfDigits = aResourceReader.ReadInt8();
groupingInfo->iMaxNumberOfDigits = aResourceReader.ReadInt8();
__ASSERT_DEBUG(
( groupingInfo->iMaxNumberOfDigits == -1) ||
( groupingInfo->iMinNumberOfDigits <= groupingInfo->iMaxNumberOfDigits ),
Panic( ENumberGroupingBadMinMaxDigitRangeInResource ) );
// Read in formatting Pattern
HBufC* formatPattern = aResourceReader.ReadHBufCL();
if ( formatPattern ) // Does not have to be there
{
CleanupStack::PushL( formatPattern );
TInt formatLength = formatPattern->Length();
if ( formatLength > 0 )
{
// Obtain a wildcard version of the matching pattern in initialDigits.
// This is used to check the supplied formatPattern for comformance to initialDigits
HBufC* wildcardedMatchBuf = HBufC::NewLC( formatLength ); // Will not be longer than the search pattern
TPtr wildcardedMatchPtr( wildcardedMatchBuf->Des() );
// Get the example number using the latest search pattern only
GetWildcardVersionOfMatchStringL( *initialDigits, KNumberGroupingWildcard, wildcardedMatchPtr );
// Now parse the descriptor
TBool trailingPossible(EFalse);
ParseForAfterPositions(
*formatPattern, groupingInfo, wildcardedMatchPtr, aMaxExtraCharacters, trailingPossible );
// Now parse the descriptor from the end if needed
if ( trailingPossible )
ParseForBeforePosition( *formatPattern, groupingInfo, aMaxExtraCharacters );
CleanupStack::PopAndDestroy( wildcardedMatchBuf );
}
CleanupStack::PopAndDestroy( formatPattern );
} // End of if on formatPattern.Length
User::LeaveIfError( aGroupingPatternsList.Append( initialDigits ) );
CleanupStack::Pop( initialDigits );
// Do not leave if the next one fails, but remove the last from the patterns list and then leave
// This is done in case someone TRAPs. Otherwise neither of these lists would be used and their
// mismatch would not be a problem
if ( TInt err = iGroupingItemsList.Append(groupingInfo) != KErrNone )
{
// return value of Count will be at least 1, because we have just successfully gone through an Append
aGroupingPatternsList.Remove( aGroupingPatternsList.Count() - 1 );
// ownership is now mine again...
delete initialDigits;
// Need to delete groupingInfo, and make sure it is no longer on the cleanupstack
CleanupStack::PopAndDestroy( groupingInfo );
User::Leave(err);
}
else
{
CleanupStack::Pop( groupingInfo ); // Success. This object now not owned by the cleanupstack
}
CleanupStack::Pop(&aGroupingPatternsList);
}
void CPNGNumberGrouping::ParseForAfterPositions(
const TDesC& aFormatPattern,
TPNGGroupingInfo* aGroupingInfo,
const TDesC& aWildcardedMatchingPattern,
TInt& aMaxExtraCharacters,
TBool& trailingPossible ) const
{
TInt pos(0); // Keeps track of the position with which the next separator will be stored
TInt formatLength = aFormatPattern.Length();
for (TInt index = 0; index < formatLength; index++ )
{
// The format pattern is compared with the matching pattern. The matching pattern may be
// shorter than the format pattern, so by default a wildcard character is used.
TText ch = aFormatPattern[index];
TText matchingChar(KNumberGroupingWildcard); // default to expect is the wildcard character
if ( pos < aWildcardedMatchingPattern.Length() ) // if still within the matching pattern
matchingChar = aWildcardedMatchingPattern[pos];
if ( ch == matchingChar )
pos++; // not a separator. index where the next "after" marker goes
else if ( ch == KNumberGroupingOneOrMoreCharactersToken )
{
// finish looking for "afterPositions". But there may be a "before" position in the
// remainder, so set the flag
trailingPossible = ETrue;
break;
}
else
{
// Explicit prevention of any separator characters being valid phone numbers
#ifdef _DEBUG
if ( IsValidPhoneNumberCharacter( ch ) || ch == KNumberGroupingWildcard )
{
RDebug::Print(
_L("NumberGrouping: Illegal character or format mismatch in resource: initialDigits pattern= <%S> formatPattern=<%S>"),
&aWildcardedMatchingPattern, &aFormatPattern );
}
#endif
__ASSERT_DEBUG( !IsValidPhoneNumberCharacter( ch ), Panic( ENumberGroupingInvalidSeparatorCharacterInFormat ) );
__ASSERT_DEBUG( ch != KNumberGroupingWildcard, Panic( ENumberGroupingMatchingPatternVersusFormatPatternMismatch ) );
TPNGSeparator separator( pos, aFormatPattern[index]);
aGroupingInfo->iAfterPositions.Append(separator);
aMaxExtraCharacters++;
}
}
}
void CPNGNumberGrouping::ParseForBeforePosition(
const TDesC& aFormatPattern,
TPNGGroupingInfo* aGroupingInfo,
TInt& aMaxExtraCharacters ) const
{
TInt pos=0;
TInt formatLength = aFormatPattern.Length();
for (TInt index = formatLength-1; index >=0; index-- )
{
TText ch = aFormatPattern[index];
if ( ch == KNumberGroupingWildcard )
pos++;
else if ( ch == KNumberGroupingOneOrMoreCharactersToken )
break;
else
{
// Explicit prevention of any separator characters being valid phone numbers
#ifdef _DEBUG
if ( IsValidPhoneNumberCharacter( ch ) )
{
RDebug::Print(
_L("NumberGrouping: Illegal character in trailing part of format string in resource: formatPattern=<%S>"),
&aFormatPattern );
}
#endif
__ASSERT_DEBUG( !IsValidPhoneNumberCharacter( ch ),
Panic( ENumberGroupingInvalidSeparatorCharacterInFormat ) );
TPNGSeparator separator( pos, ch );
aGroupingInfo->iBeforePosition = separator;
aMaxExtraCharacters++;
break;
}
}
}
void CPNGNumberGrouping::SkipGroupingSchemeL( TResourceReader& aResourceReader ) const
{
HBufC* tempBuf;
tempBuf = aResourceReader.ReadHBufCL();
delete tempBuf;
aResourceReader.Advance(2); // min and max characters
tempBuf = aResourceReader.ReadHBufCL();
delete tempBuf;
}
void CPNGNumberGrouping::GetWildcardVersionOfMatchStringL(
const TDesC& aMatchString,
TText aWildcard,
TDes& aWildcardMatchString ) const
{
RPointerArray<TDesC> patternList;
CleanupClosePushL(patternList);
// Make a copy of the input string
HBufC* matchString = aMatchString.AllocLC();
User::LeaveIfError( patternList.Append(matchString) );// takes ownership
CleanupStack::Pop( matchString );
CRegularExpression* regExp = CRegularExpression::NewLC(&patternList);
// Only 1 pattern fed in. Access that pattern at index 0
regExp->GetWildcardVersionOfPattern( 0 , aWildcard, aWildcardMatchString );
CleanupStack::PopAndDestroy(regExp);
// Delete the patterns list
delete patternList[0];
CleanupStack::PopAndDestroy();
}
EXPORT_C TBool CPNGNumberGrouping::IsCharacterInsertedByNumberGrouping(TInt aPos) const
{
TInt insertedCharacters = Length() - UnFormattedLength();
if( insertedCharacters == 0 ) // no formatting was done
return EFalse;
else if ( aPos < ( insertedCharacters + LengthToGroup() ) )
{
return !IsValidPhoneNumberCharacter( (*iFormattedNumber)[aPos] );
}
else // aPos is pointing at or beyond index= LengthToGroup() + <chars inserted>; no formatting there
return EFalse;
}
TBool CPNGNumberGrouping::IsValidPhoneNumberCharacter( TText aCharacter ) const
{
if ( ((TChar)aCharacter).IsDigit() )
return ETrue;
// Check through the list of additional valid phone number characters
TInt numAdditionalChars = sizeof( KAdditionalPhoneNumberCharacters )/sizeof(TText);
for (TInt index = 0; index < numAdditionalChars; index++)
{
if ( aCharacter == KAdditionalPhoneNumberCharacters[index] )
return ETrue;
}
return EFalse;
}
EXPORT_C TBool CPNGNumberGrouping::IsChangedByGrouping() const
{
// The only way that grouping is effectively different is by making things longer
return ( Length() > UnFormattedLength() );
}
TInt CPNGNumberGrouping::LengthToGroup() const
{
TPtrC ptr = iUnformattedNumber->Des();
TInt lengthToGroup = ptr.Length();
// Find the first non-digit
for (TInt index = 0; index < ptr.Length(); index++)
{
TChar ch = TChar(ptr[index]);
ch.Fold(TChar::EFoldDigits);
if ( !( ch.IsDigit() ) )
{
lengthToGroup = index; // only characters BEFORE the character at index are grouped
break;
}
}
return lengthToGroup;
}
// End of File