MCL/sf/app/contacts: comparison predictivesearch/PcsAlgorithm/Algorithm1/src/CPcsAlgorithm1MultiSearchHelper.cpp

equal deleted inserted replaced

-:81f8547efd4f
+:e8e3147d53eb
 #include "CPcsAlgorithm1Utils.h"
 #include "CPcsDefs.h"
 #include <collate.h>
 #include <biditext.h>
+#ifdef _DEBUG
+_LIT( KPanicMultiSearchHelper, "CPcsAlgorithm1MultiSearchHelper" );
+static void Panic( TInt aReason )
+{
+User::Panic( KPanicMultiSearchHelper, aReason );
+}
+#endif
 // ============================== MEMBER FUNCTIONS ============================
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1MultiSearchHelper::NewL
 // Two Phase Construction
 //     data element has not matched for multiple queries.
 // (9) Now include the element in the result.
 // ----------------------------------------------------------------------------
 void  CPcsAlgorithm1MultiSearchHelper::SearchMultiL(const CPsSettings& aSettings,
 	                                     RPointerArray<CPsQuery>& aPsQuery,
-	                                     TBool isSearchInGroup,
+	                                     TBool aIsSearchInGroup,
 	                                     RArray<TInt>& aContactsInGroup,
-	                                     RPointerArray<CPsData>& searchResults,
+	                                     RPointerArray<CPsData>& aSearchResults,
-	                                     RPointerArray<CPsPattern>& searchSeqs )
+	                                     RPointerArray<CPsPattern>& aSearchSeqs )
 {
 PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::SearchMultiL") );
 __LATENCY_MARK ( _L("CPcsAlgorithm1MultiSearchHelper::SearchMultiL") );
 PRINTQUERYLIST ( _L("CPcsAlgorithm1MultiSearchHelper::SearchMultiL: "), aPsQuery );
 // Create CPcsAlgorithm1FilterHelper object to be used for filtering the results
 	TSortType sortType = aSettings.GetSortType();
 CPcsAlgorithm1FilterHelper* filterHelper = CPcsAlgorithm1FilterHelper::NewL(sortType);
+CleanupStack::PushL( filterHelper );
 RPointerArray<CPcsPoolElement> elements;
+CleanupClosePushL( elements );
-iMultiSearchResultsArr.ResetAndDestroy();
+iMultiSearchResultsArr.ResetAndDestroy();
 // Get the data stores
-RPointerArray<TDesC> aDataStores;
+RPointerArray<TDesC> dataStores;
-aSettings.SearchUrisL(aDataStores);
+CleanupResetAndDestroyPushL( dataStores );
+aSettings.SearchUrisL(dataStores);
 // Get the required display fields from the client
 RArray<TInt> requiredDataFields;
+CleanupClosePushL( requiredDataFields );
 aSettings.DisplayFieldsL(requiredDataFields);
-// Search based on first character of 1st item in query list
+// Search from cache based on first character of 1st item in query list
-TInt numValue = iKeyMap->PoolIdForCharacter(aPsQuery[0]->GetItemAtL(0).Character());
+const CPsQueryItem& firstCharItem = aPsQuery[0]->GetItemAtL(0);
+TInt cachePoolId = iKeyMap->PoolIdForCharacter( firstCharItem.Character(), firstCharItem.Mode() );
 // Get the elements from all the databases
-for ( int dsIndex = 0;
+for ( TInt dsIndex = 0;
-			dsIndex < aDataStores.Count();
+			dsIndex < dataStores.Count();
 			dsIndex++ )
 	{
 	    RPointerArray<CPsData> *temp = new (ELeave) RPointerArray<CPsData> ();
 	    iMultiSearchResultsArr.Append(temp);
 	    // Get the contents for this data store
-	    TInt arrayIndex = iAlgorithm->GetCacheIndex(*(aDataStores[dsIndex]));
+	    TInt arrayIndex = iAlgorithm->GetCacheIndex(*(dataStores[dsIndex]));
 		if ( arrayIndex < 0 ) continue;
 		CPcsCache* cache = iAlgorithm->GetCache(arrayIndex);
-	    cache->GetContactsForKeyL(numValue,elements);
+	    cache->GetContactsForKeyL(cachePoolId, elements);
 	    // Get the supported data fields for this data store
 RArray<TInt> supportedDataFields;
+CleanupClosePushL( supportedDataFields );
 		cache->GetDataFields(supportedDataFields);
 		// Get the filtered data fields for this data store
 		TUint8 filteredDataMatch = FilterDataFieldsL(requiredDataFields,
 		                                             supportedDataFields);
 	    // Filter the results now
 	    FilterResultsMultiL(filterHelper,
-elements,
+	    			   elements,
-aPsQuery,
+		               aPsQuery,
-filteredDataMatch,
+		               filteredDataMatch,
-isSearchInGroup,
+		               aIsSearchInGroup,
-aContactsInGroup);
+		               aContactsInGroup);
 		// If alphabetical sorting, get the results for this datastore
 		if ( sortType == EAlphabetical )
 		{
 			filterHelper->GetResults(*(iMultiSearchResultsArr[dsIndex]));
 		}
 	    elements.Reset();
-	    supportedDataFields.Reset();
+	    CleanupStack::PopAndDestroy( &supportedDataFields ); // Close
 	}
-	aDataStores.ResetAndDestroy();
+CleanupStack::PopAndDestroy( &requiredDataFields ); // Close
-requiredDataFields.Reset();
+CleanupStack::PopAndDestroy( &dataStores );         // ResetAndDestroy
 	// If alphabetical sorting, merge the result sets of all datastores
 	if ( sortType == EAlphabetical )
 	{
 		// Form the complete searchResults array
 	CPcsAlgorithm1Utils::FormCompleteSearchResultsL(iMultiSearchResultsArr,
-											   	    searchResults);
+											   	    aSearchResults);
 	}
 	else
 	{
 		// Results are already sorted patternbased
-		filterHelper->GetResults(searchResults);
+		filterHelper->GetResults(aSearchResults);
 	}
 	// Get the sorted match sequence list
-	filterHelper->GetPatternsL(searchSeqs);
+	filterHelper->GetPatternsL(aSearchSeqs);
-	PRINT1 ( _L("CPcsAlgorithm1MultiSearchHelper::SearchMultiL: Number of search results = %d"), searchResults.Count() );
+	PRINT1 ( _L("CPcsAlgorithm1MultiSearchHelper::SearchMultiL: Number of search results = %d"), aSearchResults.Count() );
 	// Cleanup
 for(TInt i = 0; i < iMultiSearchResultsArr.Count(); i++)
 {
 	iMultiSearchResultsArr[i]->Reset();
 	delete iMultiSearchResultsArr[i];
 iMultiSearchResultsArr[i] = NULL;
 }
 iMultiSearchResultsArr.Reset();
-delete filterHelper;
+CleanupStack::PopAndDestroy( &elements ); // Close
+CleanupStack::PopAndDestroy( filterHelper );
 __LATENCY_MARKEND ( _L("CPcsAlgorithm1MultiSearchHelper::SearchMultiL") );
 PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::SearchMultiL") );
 }
 void  CPcsAlgorithm1MultiSearchHelper::ConvertQueryToListL(RPointerArray<CPsQuery>& aSearchQuery,
 RPointerArray<HBufC>& aQueryList)
 {
 PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::ConvertQueryToListL") );
-for ( int queryIndex = 0; queryIndex < aSearchQuery.Count(); queryIndex++ )
+for ( TInt queryIndex = 0; queryIndex < aSearchQuery.Count(); queryIndex++ )
 {
 TBuf<KPsQueryMaxLen> dataWithKeys;
 iKeyMap->GetMixedKeyStringForQueryL( *aSearchQuery[queryIndex], dataWithKeys );
-HBufC* dWKToAppend = HBufC::NewL(KPsQueryMaxLen);
+HBufC* dWKToAppend = dataWithKeys.AllocLC();
-TPtr tPtr(dWKToAppend->Des());
+aQueryList.AppendL( dWKToAppend );
-tPtr.Copy(dataWithKeys);
+CleanupStack::Pop( dWKToAppend ); // ownership transfered
-aQueryList.Append( dWKToAppend );
 }
 PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::ConvertQueryToListL") );
 }
 // CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL
 // Subset search function. Refer the above function for more description.
 // ----------------------------------------------------------------------------
 void  CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL(
 CPcsAlgorithm1FilterHelper* aAlgorithmFilterHelper,
-RPointerArray<CPcsPoolElement>& searchSet,
+RPointerArray<CPcsPoolElement>& aSearchSet,
-RPointerArray<CPsQuery>& searchQuery,
+RPointerArray<CPsQuery>& aSearchQuery,
 TUint8 aFilteredDataMatch,
-TBool isSearchInGroup,
+TBool aIsSearchInGroup,
 RArray<TInt>& aContactsInGroup)
 {
 PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL") );
 __LATENCY_MARK ( _L("CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL") );
 // Convert the individual queries to string form
 RPointerArray<HBufC> queryList;
-RPointerArray<HBufC> tempqueryList;
+CleanupResetAndDestroyPushL( queryList );
-ConvertQueryToListL(searchQuery, queryList);
+RPointerArray<HBufC> tempqueryList;
+CleanupClosePushL( tempqueryList );
+ConvertQueryToListL(aSearchQuery, queryList);
 // Remember a temporary copy of query list
 // since we sort the queries
 	for( TInt i = 0; i < queryList.Count(); i++)
 	{
 	// Sort the query items before we search them
 	TLinearOrder<HBufC> rule( CPcsAlgorithm1Utils::CompareByLength );
 	queryList.Sort(rule);
 // To hold the match results
 RPointerArray<TDesC> tmpMatchSet;
+CleanupResetAndDestroyPushL( tmpMatchSet );
 // Parse thru each search set elements and filter the results
-	for ( int index = 0; index < searchSet.Count(); index++ )
+	for ( TInt index = 0; index < aSearchSet.Count(); index++ )
 	{
-	    CPcsPoolElement* poolElement = static_cast<CPcsPoolElement*>(searchSet[index]);
+	    CPcsPoolElement* poolElement = static_cast<CPcsPoolElement*>(aSearchSet[index]);
 		CPsData* psData = poolElement->GetPsData();
 		psData->ClearDataMatches();
 		TBool isMatch = ETrue;
-		TUint8 wordMatches = 0;
+		TInt wordMatches = 0;
 		// Reset iWordMatches to zero
 		ClearWordMatches();
 		// Check for each query atleast one data element matches
 		    TBool queryMatch = EFalse;
 		    HBufC* tmpQuery = queryList[queryIndex];
 		    // Get the original query mode corresponding to this query
 		    TInt modeIndex = tempqueryList.Find(tmpQuery);
-		    for ( TInt dataIndex = 0; dataIndex < psData->DataElementCount(); dataIndex++ )
+		    TInt dataCount = psData->DataElementCount();
+		    __ASSERT_DEBUG( dataCount < MAX_DATA_FIELDS, Panic(KErrOverflow) );
+		    for ( TInt dataIndex = 0; dataIndex < dataCount; dataIndex++ )
 		    {
 		        // Filter off data fields not required in search
-		        TReal bitIndex;
+TUint8 bitIndex = 1 << dataIndex;
-		        Math::Pow(bitIndex, 2, dataIndex);
+TUint8 filter = bitIndex & aFilteredDataMatch;
-TUint8 filter = (TUint8)bitIndex & aFilteredDataMatch;
 		        if ( filter == 0x0 )
 		        {
 		            // Move to next data
 		        	continue;
 		        }
 		        TInt wordIndex = -1;
 			    TLex lex(psData->Data(dataIndex)->Des());
 			    // First word
 			    TPtrC tmpData = lex.NextToken();
 			    // Search thru multiple words
 			    while ( tmpData.Length() != 0 )
 			    {
 			        wordIndex++;
 			     	TBuf<KPsQueryMaxLen> data;
 	                // Convert the data to required form (mode specific)
-	                iKeyMap->GetMixedKeyStringForDataL(*searchQuery[modeIndex], tmpData, data);
+	                iKeyMap->GetMixedKeyStringForDataL(*aSearchQuery[modeIndex], tmpData, data);
 				    // Compare the data against query
-if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(data, *tmpQuery, *searchQuery[modeIndex]) )
+if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(data, *tmpQuery, *aSearchQuery[modeIndex]) )
 				    {
 				        psData->SetDataMatch(dataIndex);
 				        // Perform two checks.
 				        // 1. Ensure that the word is not matched against any previous query
 				        // 2. If it is the first match to the query
 				        TBool isWordMatch = IsWordMatch(dataIndex, wordIndex);
 				        // Check if the current word is not matched to any query
 		                if( !isWordMatch )
 		                {
 		                	// Check if no word is matched for this query till now
 	                 			SetWordMap(dataIndex, wordIndex);
 							}
 					        // Extract matched character sequence and fill in temp array
 							TInt len = tmpQuery->Length();
-							HBufC* seq = HBufC::NewL(len);
+							HBufC* seq = tmpData.Left(len).AllocLC();
-							*seq = tmpData.Mid(0, len);
 							seq->Des().UpperCase();
 							TIdentityRelation<TDesC> searchRule(CPcsAlgorithm1Utils::CompareExact);
 							if ( tmpMatchSet.Find(seq, searchRule) == KErrNotFound )
 							{
-tmpMatchSet.Append(seq);
+tmpMatchSet.AppendL(seq);
+CleanupStack::Pop(seq);
 							}
 							else
 							{
-delete seq;
+CleanupStack::PopAndDestroy(seq);
 								seq = NULL;
 							}
 						}
 				    }
 				    // Next word
 				    tmpData.Set(lex.NextToken());
 			    }
 		    }
 		    // No data element matches the query. Ignore this result.
 		    if ( queryMatch == EFalse )
 		    {
 		    }
 		}
 		// If match add the element to the result set
 		//  And before adding to the result set, check if there is atleast one match per query
-		if (( isMatch ) && ( wordMatches >= queryList.Count()))
+		if ( isMatch && wordMatches >= queryList.Count() )
 		{
-			if ( isSearchInGroup )
+			if ( aIsSearchInGroup )
 			{
 				if ( aContactsInGroup.Find(psData->Id()) != KErrNotFound )
 				{
 					aAlgorithmFilterHelper->AddL(psData,tmpMatchSet);
 				}
 			}
 	    }
 	    // Cleanup the match sequence array as
 		// they are stored in pattern details structure
 		tmpMatchSet.ResetAndDestroy();
 	}
 	// Free the query list
-	queryList.ResetAndDestroy();
+	CleanupStack::PopAndDestroy( &tmpMatchSet );   // ResetAndDestroy
-	tempqueryList.Reset();
+CleanupStack::PopAndDestroy( &tempqueryList ); // Close
+	CleanupStack::PopAndDestroy( &queryList );     // ResetAndDestroy
 	__LATENCY_MARKEND ( _L("CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL") );
 	PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1MultiSearchHelper::SetWordMap()
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm1MultiSearchHelper::SetWordMap( TInt aIndex, TInt aPosition)
+void CPcsAlgorithm1MultiSearchHelper::SetWordMap(TInt aIndex, TInt aPosition)
 {
-TReal val;
+TUint8 val = 1 << aPosition;
-	Math::Pow(val, 2, aPosition);
+iWordMatches[aIndex] |= val;
-	iWordMatches[aIndex] |= (TUint8)val;
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1MultiSearchHelper::IsWordMatch()
 // ----------------------------------------------------------------------------
 TBool CPcsAlgorithm1MultiSearchHelper::IsWordMatch(TInt aDataIndex, TInt aWordIndex)
 {
-TReal val;
+TUint8 val = 1 << aWordIndex;
-	Math::Pow(val, 2, aWordIndex);
+return (iWordMatches[aDataIndex] & val);
-	return(iWordMatches[aDataIndex] & (TUint8)val);
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1MultiSearchHelper::ClearWordMatches
 // Function to reset the iWordMatches
 // ----------------------------------------------------------------------------
 TInt CPcsAlgorithm1MultiSearchHelper::CountMultiQueryWordsL(CPsQuery& aQuery)
 {
 TInt wordCount = 0;
-TBool newWord = true;
+TBool newWord = ETrue;
 for (TInt i = 0; i < aQuery.Count(); i++ )
 {
 if ( aQuery.GetItemAtL(i).Character().IsSpace() )
 {
-newWord = true;
+newWord = ETrue;
 }
 else
 {
 if ( newWord )
 {
 wordCount++;
-newWord = false;
+newWord = EFalse;
 }
 }
 }
 PRINT1 ( _L("CPcsAlgorithm1MultiSearchHelper::CountMultiQueryWords: Number of words in search query: %d"), wordCount );
 	const TInt textLength = aQuery.Count();
 for (TInt beg = 0; beg < textLength; beg++)
 {
 // Skip separators before next word
 if ( !aQuery.GetItemAtL(beg).Character().IsSpace() )
 {
 // Scan the end of the word
 TInt end = beg+1;
 while (end < textLength &&
 !aQuery.GetItemAtL(end).Character().IsSpace())
 {
 end++;
 }
 for (TInt i = beg; i < end; i++)
 {
 CPsQueryItem* item = CPsQueryItem::NewL();
 item->SetCharacter(aQuery.GetItemAtL(i).Character());
 item->SetMode(aQuery.GetItemAtL(i).Mode());
-	newQuery->AppendL(*item);
+newQuery->AppendL(*item);
 }
 query.Append(newQuery);
 // Scan for next word
 beg = end;
 TUint8 CPcsAlgorithm1MultiSearchHelper::FilterDataFieldsL(RArray<TInt>& aRequiredDataFields,
 RArray<TInt>& aSupportedDataFields)
 {
 TUint8 filteredMatch = 0x0;
-	for ( int i = 0; i < aSupportedDataFields.Count(); i++ )
+	for ( TInt i = 0; i < aSupportedDataFields.Count(); i++ )
 	{
-		for ( int j = 0; j < aRequiredDataFields.Count(); j++ )
+		for ( TInt j = 0; j < aRequiredDataFields.Count(); j++ )
 		{
 			if ( aSupportedDataFields[i] == aRequiredDataFields[j] )
 			{
-				TReal val;
+TUint8 val = 1 << i;
-			    Math::Pow(val, 2, i);
+			    filteredMatch |= val;
-			    filteredMatch |= (TUint8)val;
 			}
 		}
 	}
 	return filteredMatch;

branch	RCL_3
changeset 6	e8e3147d53eb
parent 3	04ab22b956c2
child 7	b3431bff8c19