FCL/sf/app/contacts: comparison predictivesearch/PcsAlgorithm/Algorithm1/src/CPcsCache.cpp

equal deleted inserted replaced

-:e8e3147d53eb
+:b3431bff8c19
 // 2nd Phase Constructor
 // ----------------------------------------------------------------------------
 void CPcsCache::ConstructL(const TDesC& aURI, CPcsKeyMap& aKeyMap, TUint8 aUriId)
 {
 PRINT ( _L("Enter CPcsCache::ConstructL") );
+PRINT2 ( _L("CPcsCache::ConstructL: aURI=%S, aUriId=%d"), &aURI, aUriId);
 iURI = aURI.AllocL();
 iUriId = aUriId;
 //Update the caching status for this cache
 iCacheStatus = ECachingNotStarted;
 iIndexOrder.Reset();
 iMasterPoolBackup.Close();
 PRINT ( _L("End CPcsCache::~CPcsCache") );
 }
 // ----------------------------------------------------------------------------
 // CPcsCache::GetContactsForKeyL
 // Get list of pool elements specific to a pool
 // ----------------------------------------------------------------------------
 void CPcsCache::GetContactsForKeyL(TInt aKeyId, RPointerArray<CPcsPoolElement>& aData)
 {
 PRINT ( _L("Enter CPcsCache::GetContactsForKeyL") );
-	const RPointerArray<CPcsPoolElement>& arr = *iKeyArr[aKeyId];
+if ( aKeyId >= 0 && aKeyId < iKeyArr.Count() )
-	for ( TInt i = 0; i < arr.Count(); i++ )
+{
-	{
+const RPointerArray<CPcsPoolElement>& arr = *iKeyArr[aKeyId];
-		CPcsPoolElement* value = arr[i];
+for ( TInt i = 0; i < arr.Count(); i++ )
-aData.AppendL(value);
+{
-	}
+aData.AppendL(arr[i]);
+}
-	PRINT ( _L("End CPcsCache::GetContactsForKeyL") );
+}
-}
+PRINT ( _L("End CPcsCache::GetContactsForKeyL") );
+}
 // ----------------------------------------------------------------------------
 // CPcsCache::GetAllContentsL
 // Get all data elements in this cache
 // ----------------------------------------------------------------------------
 {
 PRINT ( _L("Enter CPcsCache::GetAllContentsL") );
 	for ( TInt i = 0; i < iMasterPool.Count(); i++ )
 	{
-		CPsData* value = iMasterPool[i];
+aData.AppendL(iMasterPool[i]);
-aData.AppendL(value);
 	}
 	PRINT ( _L("End CPcsCache::GetAllContentsL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsCache::AddToPool
 // Adds a contact to cache
 // ----------------------------------------------------------------------------
 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;
 CleanupClosePushL( elementHash );
 TLinearOrder<CPcsPoolElement> rule( CPcsPoolElement::CompareByData );
 // Parse thru each data element
 for ( TInt dataIndex = 0; dataIndex < aData.DataElementCount(); dataIndex++ )
 {
-	// Find store all the pool IDs where this contact should be
+// 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
 		    CWords* words = CWords::NewLC(*aData.Data(dataIndex));
 		    // Store the first numeric key for each word
 		    for ( TInt i = 0; i < words->MdcaCount(); i++ )
 		    {
 		    	TChar firstChar = (words->MdcaPoint(i))[0];
 		    	// Pool ID according to ITU-T mappings
-		    	TInt itutPoolId = iKeyMap->PoolIdForCharacter(firstChar, EPredictiveItuT);
+		    	if ( iKeyMap->IsItutPredictiveAvailable() )
-		    	if ( itutPoolId != KErrNotFound )
 		    	    {
-poolIds.Append(itutPoolId);
+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 ( iKeyMap->IsQwertyPredictiveAvailable() )
-if ( qwertyPoolId != KErrNotFound )
 {
-poolIds.Append(qwertyPoolId);
+TInt qwertyPoolId = iKeyMap->PoolIdForCharacter(firstChar, EPredictiveQwerty);
+if ( qwertyPoolId != KErrNotFound )
+{
+poolIds.Append(qwertyPoolId);
+}
 }
 		    }
 		    CleanupStack::PopAndDestroy(words);
 		}
 		for ( TInt poolIdIndex = 0; poolIdIndex < poolIds.Count(); poolIdIndex++ )
 		{
-TUint poolId = poolIds[ 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(poolId);
 AddToPoolL(poolMap, aData);
 iCacheInfo.InsertL(aData.Id(), poolMap);
 // Include this element in master pool
 TLinearOrder<CPsData> rule( CPcsAlgorithm1Utils::CompareDataBySortOrderL );
 iMasterPool.InsertInOrderAllowRepeatsL(&aData, rule);
 }
 // ---------------------------------------------------------------------
 // CPcsCache::RemoveContactL
 //
 // ---------------------------------------------------------------------
 void CPcsCache::RemoveFromCacheL( TInt aItemId )
 {
-CPsData *data = NULL;
+CPsData* data = NULL;
 TUint64* poolMap = iCacheInfo.Find(aItemId);
 if ( poolMap == NULL )
 {
 	return;
 // Remove this element from pools
 for ( TInt keyIndex = 0; keyIndex < iKeyArr.Count(); keyIndex++ )
 {
 TBool present = GetPoolMap(*poolMap, keyIndex);
-if ( ! present )
+if ( !present )
 {
 	continue;
 }
 const RPointerArray<CPcsPoolElement>& tmpKeyMap = *(iKeyArr[keyIndex]);
 		    if ( id == aItemId )
 		    {
 		        data = element->GetPsData();
 		    	delete element;
 		    	iKeyArr[keyIndex]->Remove(arrayIndex);
 		    }
 }
-};
+}
 // Remove this element from master pool
-for ( TInt arrayIndex = 0;
+TInt arrayIndex = 0;
-arrayIndex < iMasterPool.Count();
+while ( arrayIndex < iMasterPool.Count() )
-arrayIndex++ )
 {
-	    CPsData *dataElement = iMasterPool[arrayIndex];
+if ( iMasterPool[arrayIndex]->Id() == aItemId )
-	    TInt id = dataElement->Id();
+{
-	    if ( id == aItemId )
+iMasterPool.Remove(arrayIndex);
-	    {
+}
-	    	iMasterPool.Remove(arrayIndex);
+else
-	    }
+{
-}
+arrayIndex++;
+}
+}
 // Delete data
-if ( data )
+delete data;
-{
+data = NULL;
-	delete data;
-	data = NULL;
-}
 // Clear up cache information
 iCacheInfo.Remove(aItemId);
 }
 // ---------------------------------------------------------------------
 // CPcsCache::RemoveAllFromCache
 //
 //
 // ---------------------------------------------------------------------
 void CPcsCache::SetPoolMap(TUint64& aPoolMap, TInt aArrayIndex)
 {
 __ASSERT_DEBUG( aArrayIndex < 64, User::Panic(_L("CPcsCache"), KErrOverflow ) );
-TUint64 val = 1 << aArrayIndex;
-aPoolMap |= val;
+/* 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);
 }
 // ---------------------------------------------------------------------
 // CPcsCache::GetPoolMap
 //
 // ---------------------------------------------------------------------
 TBool CPcsCache::GetPoolMap(TUint64& aPoolMap, TInt aArrayIndex)
 {
 __ASSERT_DEBUG( aArrayIndex < 64, User::Panic(_L("CPcsCache"), KErrOverflow ) );
-TUint64 val = 1 << aArrayIndex;
-return (aPoolMap & val);
+/* 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::GetURI
 //
 //
 // ---------------------------------------------------------------------
 TUint8 CPcsCache::GetUriId()
 {
 	return iUriId;
-}
-// ---------------------------------------------------------------------
-// CPcsCache::GetUri
-//
-// ---------------------------------------------------------------------
-HBufC* CPcsCache::GetUri()
-{
-	return iURI;
 }
 // ---------------------------------------------------------------------
 // CPcsCache::SetSortOrder
 //
 	for (TInt i(0); i < iSortOrder.Count(); i++)
 	{
 		aSortOrder.Append(iSortOrder[i]);
 	}
 }
 // ---------------------------------------------------------------------
 // CPcsCache::GetIndexOrder
 //
 // ---------------------------------------------------------------------
 {
 CPsData* temp = iMasterPoolBackup[i];
 AddToCacheL( *temp );
 }
 iMasterPoolBackup.Reset();
 }
 // End of file

branch	RCL_3
changeset 21	b3431bff8c19
parent 15	e8e3147d53eb
child 32	2828b4d142c0