diff -r 81f8547efd4f -r e8e3147d53eb predictivesearch/PcsAlgorithm/Algorithm1/src/CPcsCache.cpp
--- a/predictivesearch/PcsAlgorithm/Algorithm1/src/CPcsCache.cpp	Fri Mar 12 15:41:25 2010 +0200
+++ b/predictivesearch/PcsAlgorithm/Algorithm1/src/CPcsCache.cpp	Mon Mar 15 12:39:26 2010 +0200
@@ -37,7 +37,7 @@
 // CPcsCache::NewL
 // Two Phase Construction
 // ----------------------------------------------------------------------------
-CPcsCache* CPcsCache::NewL(TDesC& aURI, CPcsKeyMap& aKeyMap, TUint8 aUriId)
+CPcsCache* CPcsCache::NewL(const TDesC& aURI, CPcsKeyMap& aKeyMap, TUint8 aUriId)
 {
     PRINT ( _L("Enter CPcsCache::NewL") );
     
@@ -68,7 +68,7 @@
 // CPcsCache::ConstructL
 // 2nd Phase Constructor
 // ----------------------------------------------------------------------------
-void CPcsCache::ConstructL(TDesC& aURI, CPcsKeyMap& aKeyMap, TUint8 aUriId)
+void CPcsCache::ConstructL(const TDesC& aURI, CPcsKeyMap& aKeyMap, TUint8 aUriId)
 {
     PRINT ( _L("Enter CPcsCache::ConstructL") );
     
@@ -77,13 +77,13 @@
     //Update the caching status for this cache
     iCacheStatus = ECachingNotStarted;
     
-    keyMap = &aKeyMap;        
+    iKeyMap = &aKeyMap;        
 
-    // Populate keyArr
+    // Populate iKeyArr
     for(TInt i= 0; i <aKeyMap.PoolCount();i++ )
         {
         RPointerArray<CPcsPoolElement> *keyMap = new (ELeave) RPointerArray<CPcsPoolElement>(1);
-        keyArr.InsertL(keyMap,i);
+        iKeyArr.InsertL(keyMap,i);
         }
    
     
@@ -98,90 +98,17 @@
 {
     PRINT ( _L("Enter CPcsCache::~CPcsCache") );
 
-    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;
-	        }
+    delete iURI;
 
-	        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();
+    RemoveAllFromCache(); // cleans up iMasterPool and iCacheInfo
+   
+    iKeyArr.ResetAndDestroy();
     iDataFields.Reset();
     iSortOrder.Reset();
     iIndexOrder.Reset();
-	
-	PRINT ( _L("End CPcsCache::~CPcsCache") );
+    iMasterPoolBackup.Close();
+
+    PRINT ( _L("End CPcsCache::~CPcsCache") );
 }
  
 // ----------------------------------------------------------------------------
@@ -192,8 +119,8 @@
 {
     PRINT ( _L("Enter CPcsCache::GetContactsForKeyL") );
         	
-	RPointerArray<CPcsPoolElement> arr = *keyArr[aKeyId];
-	for ( int i = 0; i < arr.Count(); i++ )
+	const RPointerArray<CPcsPoolElement>& arr = *iKeyArr[aKeyId];
+	for ( TInt i = 0; i < arr.Count(); i++ )
 	{
 		CPcsPoolElement* value = arr[i];
         aData.AppendL(value);
@@ -210,9 +137,9 @@
 {
     PRINT ( _L("Enter CPcsCache::GetAllContentsL") );
         	
-	for ( int i = 0; i < masterPool.Count(); i++ )
+	for ( TInt i = 0; i < iMasterPool.Count(); i++ )
 	{
-		CPsData* value = masterPool[i];
+		CPsData* value = iMasterPool[i];
         aData.AppendL(value);
 	}
     
@@ -224,86 +151,101 @@
 // CPcsCache::AddToPool
 // Adds a contact to cache
 // ----------------------------------------------------------------------------
-void CPcsCache::AddToPoolL(TInt& aPoolMap, CPsData& aData)
+void CPcsCache::AddToPoolL(TUint64& aPoolMap, CPsData& aData)
 {	
      // Temp hash to remember the location of pool elements
      // First TInt  = Pool 
      // Second TInt = Location in the pool
      // Required for memory optimization so that more than one pool
      // element doesn't get added for the same data
-     RHashMap<TInt, TInt> elementHash;     
+     RHashMap<TInt, TInt> elementHash;
+     CleanupClosePushL( elementHash );
      TLinearOrder<CPcsPoolElement> rule( CPcsPoolElement::CompareByData );
               
-     // Parse thru each data element    
-     for ( int dataIndex = 0; dataIndex < aData.DataElementCount(); dataIndex++ )
+     // Parse thru each data element
+     for ( TInt dataIndex = 0; dataIndex < aData.DataElementCount(); dataIndex++ )
      {     	
-     	// Stores first key for each word
-		RArray<TUint> firstKey;
+     	// Find store all the pool IDs where this contact should be
+		RArray<TUint> poolIds;
+		CleanupClosePushL( poolIds );
 		
 		// Recover the first character
 		if ( aData.Data(dataIndex) && aData.Data(dataIndex)->Length() != 0 )
 		{
-		    // Split the data into words	
+		    // 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++ )
+		    for ( TInt i = 0; i < words->MdcaCount(); i++ )
 		    {
 		    	TChar firstChar = (words->MdcaPoint(i))[0];
-		    	firstKey.Append(firstChar);
+		    	
+		    	// Pool ID according to ITU-T mappings
+		    	TInt itutPoolId = iKeyMap->PoolIdForCharacter(firstChar, EPredictiveItuT);
+		    	if ( itutPoolId != KErrNotFound )
+		    	    {
+                    poolIds.Append(itutPoolId);
+		    	    }
+		    	
+		    	// Pool ID according to QWERTY mappings
+                TInt qwertyPoolId = iKeyMap->PoolIdForCharacter(firstChar, EPredictiveQwerty);
+                if ( qwertyPoolId != KErrNotFound )
+                    {
+                    poolIds.Append(qwertyPoolId);
+                    }
 		    }
 		    
 		    CleanupStack::PopAndDestroy(words); 
 		}
 		
-		for ( TInt wordIndex = 0; wordIndex < firstKey.Count(); wordIndex++ )
-		{		
-		    TInt arrayIndex =keyMap->PoolIdForCharacter(firstKey[wordIndex]);
-					
+		for ( TInt poolIdIndex = 0; poolIdIndex < poolIds.Count(); poolIdIndex++ )
+		{
+            TUint poolId = poolIds[ poolIdIndex ];
 		    CPcsPoolElement* element = NULL;
 		    
 		    // Check if an element already exists in the pool for this data
 		    TInt* loc = NULL;
-		    loc = elementHash.Find(arrayIndex);
+		    loc = elementHash.Find(poolId);
 		    if ( loc != NULL )
 		    {
 		        // Exists. Then recover ...
-		        RPointerArray<CPcsPoolElement> tmpKeyMap = *(keyArr[arrayIndex]);
+		        const RPointerArray<CPcsPoolElement>& tmpKeyMap = *(iKeyArr[poolId]);
 		    	element = tmpKeyMap[*loc];
 		    }
 		
 			if ( element == NULL ) // Pool element doesn't exist. Create new ...
 			{
 		        element = CPcsPoolElement::NewL(aData);
+		        CleanupStack::PushL( element );
 		    	element->ClearDataMatchAttribute();
 				element->SetDataMatch(dataIndex);
 				
 				// Insert to pool
-				keyArr[arrayIndex]->InsertInOrderAllowRepeatsL(element, rule);
-				TInt index = keyArr[arrayIndex]->FindInOrderL(element, rule);
+				iKeyArr[poolId]->InsertInOrderAllowRepeatsL(element, rule);
+				CleanupStack::Pop( element ); // ownership transferred
+				TInt index = iKeyArr[poolId]->FindInOrderL(element, rule);
 				
-				// Set the bit for this pool					
-				SetPoolMap(aPoolMap, arrayIndex);												
+				// Set the bit for this pool
+				SetPoolMap(aPoolMap, poolId);
 				
 				// Store the array index in the temp hash
-				elementHash.InsertL(arrayIndex, index  );				
-	        }		        
+				elementHash.InsertL(poolId, index);
+	        }
 	        else // Pool element exists. Just alter the data match attribute
 	        {
 	        	element->SetDataMatch(dataIndex);
 	        	
-	            // Set the bit for this pool					
-				SetPoolMap(aPoolMap, arrayIndex);	
+	            // Set the bit for this pool
+				SetPoolMap(aPoolMap, poolId);
 	        }
-
 			
 		} // for 2 loop
 		
-		firstKey.Reset();
+		CleanupStack::PopAndDestroy( &poolIds );
 		
      } // for 1 loop
      
-     elementHash.Close();
+     CleanupStack::PopAndDestroy( &elementHash );
 }
 
 // ---------------------------------------------------------------------
@@ -313,19 +255,19 @@
 void CPcsCache::AddToCacheL( CPsData& aData )
 {
     // Protect against duplicate items getting added
-    if ( cacheInfo.Find(aData.Id()) != NULL )
+    if ( iCacheInfo.Find(aData.Id()) != NULL )
     {
-    	return;
-    }   
+        return;
+    }
     
-    // Include this element in the pool     
-    TInt poolMap = 0;
-	AddToPoolL(poolMap, aData);	
-    cacheInfo.InsertL(aData.Id(), poolMap); 
-    
-    // Include this element in master pool        
+    // Include this element in the pool
+    TUint64 poolMap = 0;
+    AddToPoolL(poolMap, aData);
+    iCacheInfo.InsertL(aData.Id(), poolMap);
+
+    // Include this element in master pool
     TLinearOrder<CPsData> rule( CPcsAlgorithm1Utils::CompareDataBySortOrderL );
-    masterPool.InsertInOrderAllowRepeatsL(&aData, rule);   
+    iMasterPool.InsertInOrderAllowRepeatsL(&aData, rule);
 }
 
 // ---------------------------------------------------------------------
@@ -336,15 +278,15 @@
 {
     CPsData *data = NULL;
             
-    TInt* poolMap = cacheInfo.Find(aItemId);            
+    TUint64* poolMap = iCacheInfo.Find(aItemId);
     
-    if ( poolMap == NULL )        
+    if ( poolMap == NULL )
     {
     	return;
     }
     
     // Remove this element from pools
-    for ( int keyIndex = 0; keyIndex < keyArr.Count(); keyIndex++ )
+    for ( TInt keyIndex = 0; keyIndex < iKeyArr.Count(); keyIndex++ )
     {
         TBool present = GetPoolMap(*poolMap, keyIndex); 
         
@@ -353,8 +295,8 @@
         	continue;
         }
 
-        RPointerArray<CPcsPoolElement> tmpKeyMap = *(keyArr[keyIndex]);
-        for ( int arrayIndex = 0; 
+        const RPointerArray<CPcsPoolElement>& tmpKeyMap = *(iKeyArr[keyIndex]);
+        for ( TInt arrayIndex = 0; 
               arrayIndex < tmpKeyMap.Count();
               arrayIndex++ )
         {
@@ -364,21 +306,21 @@
 		    {
 		        data = element->GetPsData();
 		    	delete element;
-		    	keyArr[keyIndex]->Remove(arrayIndex);  
+		    	iKeyArr[keyIndex]->Remove(arrayIndex);  
 		    }  
         }      	
     };   
     
     // Remove this element from master pool
-    for ( int arrayIndex = 0; 
-              arrayIndex < masterPool.Count();
+    for ( TInt arrayIndex = 0; 
+              arrayIndex < iMasterPool.Count();
               arrayIndex++ )
     {
-	    CPsData *dataElement = masterPool[arrayIndex];
+	    CPsData *dataElement = iMasterPool[arrayIndex];
 	    TInt id = dataElement->Id();
 	    if ( id == aItemId )
 	    {
-	    	masterPool.Remove(arrayIndex);  
+	    	iMasterPool.Remove(arrayIndex);  
 	    }  
     }      	
      
@@ -390,52 +332,48 @@
     }
 
     // Clear up cache information
-    cacheInfo.Remove(aItemId);    
+    iCacheInfo.Remove(aItemId);    
 }
 
 // ---------------------------------------------------------------------
-// CPcsCache::RemoveAllFromCacheL
+// CPcsCache::RemoveAllFromCache
 // 
 // ---------------------------------------------------------------------
-void CPcsCache::RemoveAllFromCacheL()
+void CPcsCache::RemoveAllFromCache()
 {
-    PRINT ( _L("Enter CPcsCache::RemoveAllFromCacheL") );
+    PRINT ( _L("Enter CPcsCache::RemoveAllFromCache") );
     
+    for ( TInt i = 0 ; i < iKeyArr.Count() ; i++ )
+        {
+        iKeyArr[i]->ResetAndDestroy();
+        }
 	
-    for(TInt i= 0; i <keyArr.Count();i++ )
-            {
-            keyArr[i]->ResetAndDestroy();
-            
-            }
+	iMasterPool.ResetAndDestroy();
+	iCacheInfo.Close();
 	
-	masterPool.ResetAndDestroy();
-	cacheInfo.Close();
-	
-	PRINT ( _L("End CPcsCache::RemoveAllFromCacheL") );
+	PRINT ( _L("End CPcsCache::RemoveAllFromCache") );
 }
 
 // ---------------------------------------------------------------------
 // CPcsCache::SetPoolMap
 // 
 // ---------------------------------------------------------------------
-void CPcsCache::SetPoolMap(TInt& aPoolMap, TInt arrayIndex)
+void CPcsCache::SetPoolMap(TUint64& aPoolMap, TInt aArrayIndex)
 {
-	TReal val;
-	Math::Pow(val, 2, arrayIndex);
-
-	aPoolMap |= (TInt)val;	
+    __ASSERT_DEBUG( aArrayIndex < 64, User::Panic(_L("CPcsCache"), KErrOverflow ) );
+    TUint64 val = 1 << aArrayIndex;
+    aPoolMap |= val;
 }
 
 // ---------------------------------------------------------------------
 // CPcsCache::GetPoolMap
 // 
 // ---------------------------------------------------------------------
-TBool CPcsCache::GetPoolMap(TInt& aPoolMap, TInt arrayIndex)
+TBool CPcsCache::GetPoolMap(TUint64& aPoolMap, TInt aArrayIndex)
 {
-	TReal val;
-	Math::Pow(val, 2, arrayIndex);
-
-	return (aPoolMap & (TInt)val);
+    __ASSERT_DEBUG( aArrayIndex < 64, User::Panic(_L("CPcsCache"), KErrOverflow ) );
+    TUint64 val = 1 << aArrayIndex;
+    return (aPoolMap & val);
 }
 
 // ---------------------------------------------------------------------
@@ -564,9 +502,9 @@
 {   
     iIndexOrder.Reset();
     
-	for ( int i = 0; i < iSortOrder.Count(); i++ )
+	for ( TInt i = 0; i < iSortOrder.Count(); i++ )
 	{
-		for ( int j = 0; j < iDataFields.Count(); j++ )
+		for ( TInt j = 0; j < iDataFields.Count(); j++ )
 		{
 			if ( iSortOrder[i] == iDataFields[j] )
 			{
@@ -583,24 +521,24 @@
 // ---------------------------------------------------------------------
 void CPcsCache::ResortdataInPoolsL()
     {
-    // copy masterPool data into masterPoolBackup
-    for (TInt i = 0; i < masterPool.Count(); i++ )
+    // copy iMasterPool data into iMasterPoolBackup
+    for (TInt i = 0; i < iMasterPool.Count(); i++ )
         {
-        masterPoolBackup.Append( masterPool[i] );
+        iMasterPoolBackup.Append( iMasterPool[i] );
         }
     //Now reset the key array
-    for (TInt i = 0; i < keyArr.Count(); i++ )
+    for (TInt i = 0; i < iKeyArr.Count(); i++ )
         {
-        keyArr[i]->ResetAndDestroy();
+        iKeyArr[i]->ResetAndDestroy();
         }
-    masterPool.Reset();
-    cacheInfo.Close();
-    //now add data again from the masterPoolBackup
-    for (TInt i = 0; i < masterPoolBackup.Count(); i++ )
+    iMasterPool.Reset();
+    iCacheInfo.Close();
+    //now add data again from the iMasterPoolBackup
+    for (TInt i = 0; i < iMasterPoolBackup.Count(); i++ )
         {
-        CPsData* temp = static_cast<CPsData*>(masterPoolBackup[i]);
+        CPsData* temp = iMasterPoolBackup[i];
         AddToCacheL( *temp );
         }
-    masterPoolBackup.Reset();
+    iMasterPoolBackup.Reset();
     } 
 // End of file