--- a/predictivesearch/PcsAlgorithm/Algorithm2/src/CPcsCache.cpp Wed Sep 15 11:56:55 2010 +0300
+++ b/predictivesearch/PcsAlgorithm/Algorithm2/src/CPcsCache.cpp Wed Oct 13 14:15:33 2010 +0300
@@ -22,7 +22,6 @@
// INCLUDE FILES
#include <MVPbkContactLink.h>
-#include <vpbkeng.rsg>
#include "FindUtilChineseECE.h"
#include "CPsData.h"
@@ -38,7 +37,7 @@
// CPcsCache::NewL
// Two Phase Construction
// ----------------------------------------------------------------------------
-CPcsCache* CPcsCache::NewL(CPcsAlgorithm2* aAlgorithm, const TDesC& aURI,
+CPcsCache* CPcsCache::NewL(CPcsAlgorithm2* aAlgorithm, TDesC& aURI,
CPcsKeyMap& aKeyMap, TUint8 aUriId)
{
PRINT ( _L("Enter CPcsCache::NewL") );
@@ -70,7 +69,7 @@
// CPcsCache::ConstructL
// 2nd Phase Constructor
// ----------------------------------------------------------------------------
-void CPcsCache::ConstructL(CPcsAlgorithm2* aAlgorithm, const TDesC& aURI,
+void CPcsCache::ConstructL(CPcsAlgorithm2* aAlgorithm, TDesC& aURI,
CPcsKeyMap& aKeyMap, TUint8 aUriId)
{
PRINT ( _L("Enter CPcsCache::ConstructL") );
@@ -81,14 +80,13 @@
//Update the caching status for this cache
iCacheStatus = ECachingNotStarted;
- iKeyMap = &aKeyMap;
+ keyMap = &aKeyMap;
- // Populate iKeyArr
- const TInt keyMapPoolcount = aKeyMap.PoolCount();
- for (TInt i = 0; i < keyMapPoolcount; i++)
+ // Populate keyArr
+ for (TInt i = 0; i < aKeyMap.PoolCount(); i++)
{
- RPointerArray<CPcsPoolElement>* keyMap = new (ELeave) RPointerArray<CPcsPoolElement> (1);
- iKeyArr.InsertL(keyMap, i);
+ RPointerArray<CPcsPoolElement> *keyMap = new (ELeave) RPointerArray<CPcsPoolElement> (1);
+ keyArr.InsertL(keyMap, i);
}
PRINT ( _L("End CPcsCache::ConstructL") );
@@ -102,15 +100,86 @@
{
PRINT ( _L("Enter CPcsCache::~CPcsCache") );
- delete iURI;
+ if (iURI)
+ {
+ delete iURI;
+ }
+
+ // Loop thru cache info and free and the data elements
+ THashMapIter<TInt, TInt> iter(cacheInfo);
+
+ do
+ {
+ TInt* id = const_cast<TInt*> (iter.NextKey());
+
+ if (id == NULL)
+ break;
+
+ TInt* poolMap = iter.CurrentValue();
+
+ if (poolMap == NULL)
+ {
+ continue;
+ }
+
+ CPsData *data = NULL;
+ for (int keyIndex = 0; keyIndex <= keyArr.Count(); keyIndex++)
+ {
+ TBool present = GetPoolMap(*poolMap, keyIndex);
+
+ if (!present)
+ {
+ continue;
+ }
- RemoveAllFromCache(); // cleans up iMasterPool and iCacheInfo
-
- iKeyArr.ResetAndDestroy();
+ RPointerArray<CPcsPoolElement> tmpKeyMap = *(keyArr[keyIndex]);
+ for (int arrayIndex = 0; arrayIndex < tmpKeyMap.Count(); arrayIndex++)
+ {
+ CPcsPoolElement *element = tmpKeyMap[arrayIndex];
+ TInt localId = element->GetPsData()->Id();
+ if (*id == localId)
+ {
+ data = element->GetPsData();
+ delete element;
+ keyArr[keyIndex]->Remove(arrayIndex);
+ }
+ }
+ };
+
+ // Remove this element from master pool
+ for (int arrayIndex = 0; arrayIndex < masterPool.Count(); arrayIndex++)
+ {
+ CPsData *dataElement = masterPool[arrayIndex];
+ TInt localId = dataElement->Id();
+ if (*id == localId)
+ {
+ masterPool.Remove(arrayIndex);
+ }
+ }
+
+ if (data)
+ {
+ delete data;
+ }
+
+ }
+ while (1);
+
+ for (TInt i = 0; i < keyArr.Count(); i++)
+ {
+ keyArr[i]->ResetAndDestroy();
+ delete keyArr[i];
+ keyArr[i] = NULL;
+ }
+
+ masterPool.ResetAndDestroy();
+
+ cacheInfo.Close();
+
+ keyArr.Reset();
iDataFields.Reset();
iSortOrder.Reset();
iIndexOrder.Reset();
- iMasterPoolBackup.Close();
PRINT ( _L("End CPcsCache::~CPcsCache") );
}
@@ -122,18 +191,15 @@
void CPcsCache::GetContactsForKeyL(TInt aKeyId, RPointerArray<CPcsPoolElement>& aData)
{
PRINT ( _L("Enter CPcsCache::GetContactsForKeyL") );
-
- if ( aKeyId >= 0 && aKeyId < iKeyArr.Count() )
+ CleanupClosePushL( aData );
+ RPointerArray<CPcsPoolElement> arr = *keyArr[aKeyId];
+ for (int i = 0; i < arr.Count(); i++)
{
- const RPointerArray<CPcsPoolElement>& arr = *iKeyArr[aKeyId];
- const TInt arrCount = arr.Count();
- for (TInt i = 0; i < arrCount; i++)
- {
- CPcsPoolElement* value = arr[i];
- aData.AppendL(value);
- }
+ CPcsPoolElement* value = arr[i];
+ aData.AppendL(value);
}
+ CleanupStack::Pop();
PRINT ( _L("End CPcsCache::GetContactsForKeyL") );
}
@@ -144,14 +210,13 @@
void CPcsCache::GetAllContentsL(RPointerArray<CPsData>& aData)
{
PRINT ( _L("Enter CPcsCache::GetAllContentsL") );
-
- const TInt masterPoolCount = iMasterPool.Count();
- for (TInt i = 0; i < masterPoolCount; i++)
+ CleanupClosePushL( aData );
+ for (int i = 0; i < masterPool.Count(); i++)
{
- CPsData* value = iMasterPool[i];
+ CPsData* value = masterPool[i];
aData.AppendL(value);
}
-
+ CleanupStack::Pop();
PRINT ( _L("End CPcsCache::GetAllContentsL") );
}
@@ -159,7 +224,7 @@
// CPcsCache::AddToPool
// Adds a contact to cache
// ----------------------------------------------------------------------------
-void CPcsCache::AddToPoolL(TUint64& aPoolMap, CPsData& aData)
+void CPcsCache::AddToPoolL(TInt& aPoolMap, CPsData& aData)
{
// Temp hash to remember the location of pool elements
// First TInt = Pool
@@ -167,43 +232,68 @@
// Required for memory optimization so that more than one pool
// element doesn't get added for the same data
RHashMap<TInt, TInt> elementHash;
- CleanupClosePushL( elementHash );
- TLinearOrder<CPcsPoolElement> rule(CPcsPoolElement::CompareByDataL);
+ TLinearOrder<CPcsPoolElement> rule(CPcsPoolElement::CompareByData);
- // Parse thru each data element
- const TInt dataElementCount = aData.DataElementCount();
- for (TInt dataIndex = 0; dataIndex < dataElementCount; dataIndex++)
+ // Parse thru each data element
+ for (int dataIndex = 0; dataIndex < aData.DataElementCount(); dataIndex++)
{
// Stores first key for each word
- RArray<TChar> firstCharArr;
- CleanupClosePushL( firstCharArr );
+ RArray<TChar> firstKey;
// Recover the first character
- if ( aData.Data(dataIndex) )
+ if (aData.Data(dataIndex) && aData.Data(dataIndex)->Length() != 0)
{
- GetFirstCharsForDataL( *aData.Data(dataIndex), firstCharArr );
+ // Split the data into words
+ CWords* words = CWords::NewLC(*aData.Data(dataIndex));
+
+ // Store the first numeric key for each word
+ for (int i = 0; i < words->MdcaCount(); i++)
+ {
+ TChar firstChar;
+ for (int j = 0; j < words->MdcaPoint(i).Length(); j++)
+ {
+ firstChar = (words->MdcaPoint(i))[j];
+ TBuf<20> word;
+ word.Append(firstChar);
+ if (iAlgorithm->FindUtilECE()->IsChineseWord(word))
+ {
+ RPointerArray<HBufC> spellList;
+ if (iAlgorithm->FindUtilECE()->T9ChineseTranslationL(firstChar, spellList))
+ {
+ for (int j = 0; j < spellList.Count(); j++)
+ {
+ firstKey.Append(keyMap->KeyForCharacter(*(spellList[j]->Ptr())));
+ }
+ }
+ else
+ {
+ firstKey.Append( keyMap->KeyForCharacter(firstChar));
+ }
+ spellList.ResetAndDestroy();
+ }
+ else
+ {
+ firstKey.Append(keyMap->KeyForCharacter(firstChar));
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(words);
}
-
- // Get the corresponding Pool IDs
- RArray<TInt> poolIdArr;
- CleanupClosePushL( poolIdArr );
- GetPoolIdsForCharsL( firstCharArr, poolIdArr );
- const TInt poolIdArrCount = poolIdArr.Count();
- for (TInt poolArrIndex = 0; poolArrIndex < poolIdArrCount ; poolArrIndex++)
+ for (TInt wordIndex = 0; wordIndex < firstKey.Count(); wordIndex++)
{
-
- TInt poolId = poolIdArr[poolArrIndex];
+ TInt arrayIndex = keyMap->PoolIdForCharacter(firstKey[wordIndex]);
CPcsPoolElement* element = NULL;
// Check if an element already exists in the pool for this data
TInt* loc = NULL;
- loc = elementHash.Find(poolId);
+ loc = elementHash.Find(arrayIndex);
if (loc != NULL)
{
// Exists. Then recover ...
- RPointerArray<CPcsPoolElement> tmpKeyMap = *(iKeyArr[poolId]);
+ RPointerArray<CPcsPoolElement> tmpKeyMap = *(keyArr[arrayIndex]);
element = tmpKeyMap[*loc];
}
@@ -214,31 +304,30 @@
element->SetDataMatch(dataIndex);
// Insert to pool
- iKeyArr[poolId]->InsertInOrderAllowRepeatsL(element, rule);
- TInt index = iKeyArr[poolId]->FindInOrderL(element, rule);
+ keyArr[arrayIndex]->InsertInOrderAllowRepeatsL(element, rule);
+ TInt index = keyArr[arrayIndex]->FindInOrderL(element, rule);
- // Set the bit for this pool
- SetPoolMap(aPoolMap, poolId);
+ // Set the bit for this pool
+ SetPoolMap(aPoolMap, arrayIndex);
// Store the array index in the temp hash
- elementHash.InsertL(poolId, index);
+ elementHash.InsertL(arrayIndex, index);
}
else // Pool element exists. Just alter the data match attribute
{
element->SetDataMatch(dataIndex);
- // Set the bit for this pool
- SetPoolMap(aPoolMap, poolId);
+ // Set the bit for this pool
+ SetPoolMap(aPoolMap, arrayIndex);
}
} // for 2 loop
- CleanupStack::PopAndDestroy( &poolIdArr ); // Close
- CleanupStack::PopAndDestroy( &firstCharArr ); // Close
+ firstKey.Reset();
} // for 1 loop
- CleanupStack::PopAndDestroy( &elementHash ); // Close
+ elementHash.Close();
}
// ---------------------------------------------------------------------
@@ -248,19 +337,19 @@
void CPcsCache::AddToCacheL(CPsData& aData)
{
// Protect against duplicate items getting added
- if (iCacheInfo.Find(aData.Id()) != NULL)
+ if (cacheInfo.Find(aData.Id()) != NULL)
{
return;
}
// Include this element in the pool
- TUint64 poolMap = 0;
+ TInt poolMap = 0;
AddToPoolL(poolMap, aData);
- iCacheInfo.InsertL(aData.Id(), poolMap);
+ cacheInfo.InsertL(aData.Id(), poolMap);
// Include this element in master pool
- TLinearOrder<CPsData> rule(CPcsAlgorithm2Utils::CompareDataBySortOrderL);
- iMasterPool.InsertInOrderAllowRepeatsL(&aData, rule);
+ TLinearOrder<CPsData> rule(CPcsAlgorithm2Utils::CompareDataBySortOrder);
+ masterPool.InsertInOrderAllowRepeatsL(&aData, rule);
}
// ---------------------------------------------------------------------
@@ -271,7 +360,7 @@
{
CPsData *data = NULL;
- TUint64* poolMap = iCacheInfo.Find(aItemId);
+ TInt* poolMap = cacheInfo.Find(aItemId);
if (poolMap == NULL)
{
@@ -279,8 +368,7 @@
}
// Remove this element from pools
- const TInt keyArrCount = iKeyArr.Count();
- for (TInt keyIndex = 0; keyIndex < keyArrCount; keyIndex++)
+ for (int keyIndex = 0; keyIndex <= keyArr.Count(); keyIndex++)
{
TBool present = GetPoolMap(*poolMap, keyIndex);
@@ -289,9 +377,8 @@
continue;
}
- const RPointerArray<CPcsPoolElement>& tmpKeyMap = *(iKeyArr[keyIndex]);
-
- for (TInt arrayIndex = 0; arrayIndex < tmpKeyMap.Count(); arrayIndex++)
+ RPointerArray<CPcsPoolElement> tmpKeyMap = *(keyArr[keyIndex]);
+ for (int arrayIndex = 0; arrayIndex < tmpKeyMap.Count(); arrayIndex++)
{
CPcsPoolElement *element = tmpKeyMap[arrayIndex];
TInt id = element->GetPsData()->Id();
@@ -299,19 +386,19 @@
{
data = element->GetPsData();
delete element;
- iKeyArr[keyIndex]->Remove(arrayIndex);
+ keyArr[keyIndex]->Remove(arrayIndex);
}
}
}
// Remove this element from master pool
- for (TInt arrayIndex = 0; arrayIndex < iMasterPool.Count(); arrayIndex++)
+ for (int arrayIndex = 0; arrayIndex < masterPool.Count(); arrayIndex++)
{
- CPsData *dataElement = iMasterPool[arrayIndex];
+ CPsData *dataElement = masterPool[arrayIndex];
TInt id = dataElement->Id();
if (id == aItemId)
{
- iMasterPool.Remove(arrayIndex);
+ masterPool.Remove(arrayIndex);
}
}
@@ -323,178 +410,51 @@
}
// Clear up cache information
- iCacheInfo.Remove(aItemId);
+ cacheInfo.Remove(aItemId);
}
// ---------------------------------------------------------------------
// CPcsCache::RemoveAllFromCacheL
//
// ---------------------------------------------------------------------
-void CPcsCache::RemoveAllFromCache()
+void CPcsCache::RemoveAllFromCacheL()
{
- PRINT ( _L("Enter CPcsCache::RemoveAllFromCache") );
+ PRINT ( _L("Enter CPcsCache::RemoveAllFromCacheL") );
- const TInt keyArrCount = iKeyArr.Count();
- for ( TInt i = 0 ; i < keyArrCount ; i++ )
+ for (TInt i = 0; i < keyArr.Count(); i++)
{
- iKeyArr[i]->ResetAndDestroy();
+ keyArr[i]->ResetAndDestroy();
+
}
- iMasterPool.ResetAndDestroy();
- iCacheInfo.Close();
+ masterPool.ResetAndDestroy();
+ cacheInfo.Close();
- PRINT ( _L("End CPcsCache::RemoveAllFromCache") );
+ PRINT ( _L("End CPcsCache::RemoveAllFromCacheL") );
}
// ---------------------------------------------------------------------
// CPcsCache::SetPoolMap
//
// ---------------------------------------------------------------------
-void CPcsCache::SetPoolMap(TUint64& aPoolMap, TInt aArrayIndex)
+void CPcsCache::SetPoolMap(TInt& aPoolMap, TInt arrayIndex)
{
- __ASSERT_DEBUG( aArrayIndex < 64, User::Panic(_L("CPcsCache"), KErrOverflow ) );
+ TReal val;
+ Math::Pow(val, 2, arrayIndex);
- /* Some platforms do not support 64 bits shift operations.
- * Split to two 32 bits operations.
- */
-
- TUint32 poolMapH = I64HIGH(aPoolMap);
- TUint32 poolMapL = I64LOW(aPoolMap);
-
- TUint32 valH = 0;
- TUint32 valL = 0;
- if (aArrayIndex < 32)
- {
- valL = 1 << aArrayIndex;
- }
- else
- {
- valH = 1 << (aArrayIndex-32);
- }
-
- poolMapH |= valH;
- poolMapL |= valL;
-
- aPoolMap = MAKE_TUINT64(poolMapH, poolMapL);
+ aPoolMap |= (TInt) val;
}
// ---------------------------------------------------------------------
// CPcsCache::GetPoolMap
//
// ---------------------------------------------------------------------
-TBool CPcsCache::GetPoolMap(TUint64& aPoolMap, TInt aArrayIndex)
+TBool CPcsCache::GetPoolMap(TInt& aPoolMap, TInt arrayIndex)
{
- __ASSERT_DEBUG( aArrayIndex < 64, User::Panic(_L("CPcsCache"), KErrOverflow ) );
-
- /* Some platforms do not support 64 bits shift operations.
- * Split to two 32 bits operations.
- */
-
- TUint32 poolMapH = I64HIGH(aPoolMap);
- TUint32 poolMapL = I64LOW(aPoolMap);
-
- TUint32 valH = 0;
- TUint32 valL = 0;
- if (aArrayIndex < 32)
- {
- valL = 1 << aArrayIndex;
- }
- else
- {
- valH = 1 << (aArrayIndex-32);
- }
-
- TBool ret = (poolMapH & valH) || (poolMapL & valL);
-
- return (ret);
- }
-
-// ---------------------------------------------------------------------
-// CPcsCache::GetFirstCharsForDataL
-//
-// ---------------------------------------------------------------------
-void CPcsCache::GetFirstCharsForDataL( const TDesC& aData, RArray<TChar>& aFirstChars ) const
- {
- // Split the data into words
- CWords* words = CWords::NewLC(aData);
+ TReal val;
+ Math::Pow(val, 2, arrayIndex);
- // Find indexing characters for each word
- for (TInt i = 0; i < words->MdcaCount(); i++)
- {
- TPtrC16 word = words->MdcaPoint(i);
- TBool lastCharIsChinese = EFalse;
-
- // If the word contains any Chinese characters, then it is
- // stored to cache according all the available spellings of
- // all the Chinese characters
- if ( iAlgorithm->FindUtilECE()->IsChineseWordIncluded(word) )
- {
- const TInt wordLength = word.Length();
- for (TInt j = 0; j < wordLength; j++)
- {
- TText curChar = word[j];
- RPointerArray<HBufC> spellList;
- CleanupResetAndDestroyPushL( spellList );
- if ( iAlgorithm->FindUtilECE()->DoTranslationL(curChar, spellList) )
- {
- lastCharIsChinese = ETrue;
- // Append first char of each spelling
- const TInt spellListCount = spellList.Count();
- for (TInt k = 0; k < spellListCount; k++)
- {
- const HBufC* spelling = spellList[k];
- aFirstChars.AppendL( (*spelling)[0] );
- }
- }
- else
- {
- if ( lastCharIsChinese )
- {
- aFirstChars.AppendL( word[j] );
- lastCharIsChinese = EFalse;
- }
- }
- CleanupStack::PopAndDestroy( &spellList ); // ResetAndDestroy
- }
- }
-
- // If the first charcter of the word is non-Chinese, then it's stored to the
- // cache according this first character. Other characters of the word may or
- // may not be Chinese.
- if ( !iAlgorithm->FindUtilECE()->IsChineseWordIncluded( word.Left(1) ) )
- {
- aFirstChars.AppendL( word[0] );
- }
- }
- CleanupStack::PopAndDestroy(words);
- }
-
-// ---------------------------------------------------------------------
-// CPcsCache::GetPoolIdsForCharsL
-//
-// ---------------------------------------------------------------------
-void CPcsCache::GetPoolIdsForCharsL( const RArray<TChar>& aChars, RArray<TInt>& aPoolIds ) const
- {
- // There can potentially be two pool IDs for each character.
- // Reserve memory for this upfront to prevent unnecessary reallocations.
- aPoolIds.ReserveL( aChars.Count() * 2 );
-
- const TInt charsCount = aChars.Count() ;
- for ( TInt i = 0 ; i < charsCount ; ++i )
- {
- TChar character = aChars[i];
- TInt itutPoolId = iKeyMap->PoolIdForCharacter( character, EPredictiveItuT );
- if ( itutPoolId != KErrNotFound )
- {
- aPoolIds.AppendL( itutPoolId );
- }
-
- TInt qwertyPoolId = iKeyMap->PoolIdForCharacter( character, EPredictiveQwerty );
- if ( qwertyPoolId != KErrNotFound )
- {
- aPoolIds.AppendL( qwertyPoolId );
- }
- }
+ return (aPoolMap & (TInt) val);
}
// ---------------------------------------------------------------------
@@ -512,8 +472,7 @@
// ---------------------------------------------------------------------
void CPcsCache::SetDataFields(RArray<TInt>& aDataFields)
{
- const TInt dataFieldsCount = aDataFields.Count();
- for (TInt i(0); i < dataFieldsCount; i++)
+ for (TInt i(0); i < aDataFields.Count(); i++)
{
iDataFields.Append(aDataFields[i]);
}
@@ -525,8 +484,7 @@
// ---------------------------------------------------------------------
void CPcsCache::GetDataFields(RArray<TInt>& aDataFields)
{
- const TInt dataFieldsCount = iDataFields.Count();
- for (TInt i(0); i < dataFieldsCount; i++)
+ for (TInt i(0); i < iDataFields.Count(); i++)
{
aDataFields.Append(iDataFields[i]);
}
@@ -577,8 +535,8 @@
PRINT ( _L("Enter CPcsCache::SetSortOrder") );
iSortOrder.Reset();
- const TInt sortOrderCount = aSortOrder.Count();
- for (TInt i(0); i < sortOrderCount; i++)
+
+ for (TInt i(0); i < aSortOrder.Count(); i++)
{
iSortOrder.Append(aSortOrder[i]);
}
@@ -595,8 +553,8 @@
void CPcsCache::GetSortOrder(RArray<TInt>& aSortOrder)
{
aSortOrder.Reset();
- const TInt sortOrderCount = iSortOrder.Count();
- for (TInt i(0); i < sortOrderCount; i++)
+
+ for (TInt i(0); i < iSortOrder.Count(); i++)
{
aSortOrder.Append(iSortOrder[i]);
}
@@ -609,8 +567,8 @@
void CPcsCache::GetIndexOrder(RArray<TInt>& aIndexOrder)
{
aIndexOrder.Reset();
- const TInt indexOrderCount = iIndexOrder.Count();
- for (TInt i(0); i < indexOrderCount; i++)
+
+ for (TInt i(0); i < iIndexOrder.Count(); i++)
{
aIndexOrder.Append(iIndexOrder[i]);
}
@@ -624,11 +582,9 @@
{
iIndexOrder.Reset();
- const TInt sortOrderCount = iSortOrder.Count();
- const TInt dataFieldsCount = iDataFields.Count();
- for (TInt i = 0; i < sortOrderCount; i++)
+ for (int i = 0; i < iSortOrder.Count(); i++)
{
- for (TInt j = 0; j <dataFieldsCount; j++)
+ for (int j = 0; j < iDataFields.Count(); j++)
{
if (iSortOrder[i] == iDataFields[j])
{
@@ -645,64 +601,24 @@
// ---------------------------------------------------------------------
void CPcsCache::ResortdataInPoolsL()
{
- // copy iMasterPool data into iMasterPoolBackup
- const TInt masterPoolCount = iMasterPool.Count();
- for (TInt i = 0; i < masterPoolCount; i++ )
+ // copy masterPool data into masterPoolBackup
+ for (TInt i = 0; i < masterPool.Count(); i++ )
{
- iMasterPoolBackup.Append( iMasterPool[i] );
+ masterPoolBackup.Append( masterPool[i] );
}
//Now reset the key array
- const TInt keyArrCount = iKeyArr.Count();
- for (TInt i = 0; i <keyArrCount; i++ )
+ for (TInt i = 0; i < keyArr.Count(); i++ )
{
- iKeyArr[i]->ResetAndDestroy();
+ keyArr[i]->ResetAndDestroy();
}
- iMasterPool.Reset();
- iCacheInfo.Close();
- //now add data again from the iMasterPoolBackup
- const TInt masterPoolBackupCount = iMasterPoolBackup.Count();
- for (TInt i = 0; i < masterPoolBackupCount; i++ )
+ masterPool.Reset();
+ cacheInfo.Close();
+ //now add data again from the masterPoolBackup
+ for (TInt i = 0; i < masterPoolBackup.Count(); i++ )
{
- CPsData* temp = iMasterPoolBackup[i];
+ CPsData* temp = static_cast<CPsData*>(masterPoolBackup[i]);
AddToCacheL( *temp );
}
- iMasterPoolBackup.Reset();
- }
-
-// ---------------------------------------------------------------------
-// CPcsCache::GetFirstNameIndex
-//
-// ---------------------------------------------------------------------
-TInt CPcsCache::GetFirstNameIndex() const
- {
- TInt fnIndex = KErrNotFound;
- const TInt dataFieldsCount = iDataFields.Count();
- for ( TInt i = 0 ; i < dataFieldsCount && fnIndex == KErrNotFound ; ++i )
- {
- if ( iDataFields[i] == R_VPBK_FIELD_TYPE_FIRSTNAME )
- {
- fnIndex = i;
- }
- }
- return fnIndex;
- }
-
-// ---------------------------------------------------------------------
-// CPcsCache::GetLastNameIndex
-//
-// ---------------------------------------------------------------------
-TInt CPcsCache::GetLastNameIndex() const
- {
- TInt lnIndex = KErrNotFound;
- const TInt dataFieldsCount = iDataFields.Count();
- for ( TInt i = 0 ; i < dataFieldsCount && lnIndex == KErrNotFound ; ++i )
- {
- if ( iDataFields[i] == R_VPBK_FIELD_TYPE_LASTNAME )
- {
- lnIndex = i;
- }
- }
- return lnIndex;
- }
-
+ masterPoolBackup.Reset();
+ }
// End of file