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

equal deleted inserted replaced

-:81f8547efd4f
+:e8e3147d53eb
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1Helper::SearchSingleL
 // Search function for query in ITU-T mode, QWERTY mode, or Mixed (ITU-T and QWERTY) mode.
 // ----------------------------------------------------------------------------
-void  CPcsAlgorithm1Helper::SearchSingleL(const CPsSettings& aSettings,
+void  CPcsAlgorithm1Helper::SearchSingleL( const CPsSettings& aSettings,
 CPsQuery& aPsQuery,
-TBool isSearchInGroup,
+TBool aIsSearchInGroup,
 RArray<TInt>& aContactsInGroup,
-RPointerArray<CPsData>& searchResults,
+RPointerArray<CPsData>& aSearchResults,
-RPointerArray<CPsPattern>& searchSeqs )
+RPointerArray<CPsPattern>& aSearchSeqs )
 {
 PRINT ( _L("Enter CPcsAlgorithm1Helper::SearchSingleL") );
 __LATENCY_MARK ( _L("CPcsAlgorithm1Helper::SearchSingleL") );
 // Create filtering helper for the required sort type
 TSortType sortType = aSettings.GetSortType();
 CPcsAlgorithm1FilterHelper* filterHelper = CPcsAlgorithm1FilterHelper::NewL(sortType);
+CleanupStack::PushL( filterHelper );
-// Search based on first character
-TInt numValue = iKeyMap->PoolIdForCharacter(aPsQuery.GetItemAtL(0).Character());
+// Search from cache based on first character
+const CPsQueryItem& firstCharItem = aPsQuery.GetItemAtL(0);
+TInt cachePoolId = iKeyMap->PoolIdForCharacter( firstCharItem.Character(), firstCharItem.Mode() );
 // Reset the result set array for new search
 iSearchResultsArr.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);
 // Perform search for each required data store
 RPointerArray<CPcsPoolElement> elements;
+CleanupClosePushL( elements );
-for ( int dsIndex = 0;
-dsIndex < aDataStores.Count();
+for ( TInt dsIndex = 0;
+dsIndex < dataStores.Count();
 dsIndex++ )
 {
 RPointerArray<CPsData> *temp = new (ELeave) RPointerArray<CPsData> ();
 iSearchResultsArr.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);
 // Perform filtering
 FilterResultsSingleL(filterHelper,
 elements,
 aPsQuery,
 filteredDataMatch,
-isSearchInGroup,
+aIsSearchInGroup,
 aContactsInGroup);
 // If alphabetical sorting, get the results for this datastore
 if ( sortType == EAlphabetical )
 {
 filterHelper->GetResults(*(iSearchResultsArr[dsIndex]));
 }
 elements.Reset();
-supportedDataFields.Reset();
+CleanupStack::PopAndDestroy( &supportedDataFields ); // Close
 }
-aDataStores.ResetAndDestroy();
+CleanupStack::PopAndDestroy( &elements );           // Close
-requiredDataFields.Reset();
+CleanupStack::PopAndDestroy( &requiredDataFields ); // Close
+CleanupStack::PopAndDestroy( &dataStores );         // ResetAndDestroy
 // If alphabetical sorting, merge the result sets of all datastores
 if ( sortType == EAlphabetical )
 {
 // Merge the result sets of individual datastores alphabetically
 CPcsAlgorithm1Utils::FormCompleteSearchResultsL(iSearchResultsArr,
-searchResults);
+aSearchResults);
 }
 else
 {
 // Results are already sorted pattern based
-filterHelper->GetResults(searchResults);
+filterHelper->GetResults(aSearchResults);
 }
 // Get the sorted match sequence list
-filterHelper->GetPatternsL(searchSeqs);
+filterHelper->GetPatternsL(aSearchSeqs);
-PRINT1 ( _L("CPcsAlgorithm1Helper::SearchSingleL: Number of search results = %d"), searchResults.Count() );
+PRINT1 ( _L("CPcsAlgorithm1Helper::SearchSingleL: Number of search results = %d"), aSearchResults.Count() );
 // Cleanup
 for ( TInt i = 0; i < iSearchResultsArr.Count(); i++ )
 {
 iSearchResultsArr[i]->Reset();
-delete iSearchResultsArr[i];
+}
-iSearchResultsArr[i] = NULL;
+iSearchResultsArr.ResetAndDestroy();
-}
-iSearchResultsArr.Reset();
+CleanupStack::PopAndDestroy( filterHelper );
-delete filterHelper;
 __LATENCY_MARKEND ( _L("CPcsAlgorithm1Helper::SearchSingleL") );
 PRINT ( _L("End CPcsAlgorithm1Helper::SearchSingleL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1Helper::FilterResultsSingleL
 // Subset search function
 // ----------------------------------------------------------------------------
 void  CPcsAlgorithm1Helper::FilterResultsSingleL(CPcsAlgorithm1FilterHelper* aAlgorithmFilterHelper,
-RPointerArray<CPcsPoolElement>& searchSet,
+RPointerArray<CPcsPoolElement>& aSearchSet,
 CPsQuery& aPsQuery,
 TUint8 aFilteredDataMatch,
-TBool isSearchInGroup,
+TBool aIsSearchInGroup,
 RArray<TInt>& aContactsInGroup)
 {
 PRINT ( _L("Enter CPcsAlgorithm1Helper::FilterResultsSingleL") );
 __LATENCY_MARK ( _L("CPcsAlgorithm1Helper::FilterResultsSingleL") );
 PRINT1 ( _L("CPcsAlgorithm1Helper::FilterResultsSingleL: char-and-key string for the query is \"%S\""),
 &queryAsDes );
 // Parse thru each search set elements and filter the results
-for ( TInt 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();
 RPointerArray<TDesC> tempMatchSeq;
+CleanupResetAndDestroyPushL( tempMatchSeq );
 TBool isAdded = EFalse;
 // Parse thru each data and filter the results
 for ( TInt dataIndex = 0; dataIndex < psData->DataElementCount(); 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;
 }
 if ( poolElement->IsDataMatch(dataIndex) )
 {
-TLex lex(psData->Data(dataIndex)->Des());
+TLex lex( *psData->Data(dataIndex) );
 // First word
 TPtrC token = lex.NextToken();
 // Search thru multiple words
 TIdentityRelation<TDesC> rule(CPcsAlgorithm1Utils::CompareExact);
 if ( tempMatchSeq.Find(seq, rule) == KErrNotFound )
 {
 tempMatchSeq.Append(seq);
-CleanupStack::Pop();
+CleanupStack::Pop(seq);
 }
 else
 {
-CleanupStack::PopAndDestroy();
+CleanupStack::PopAndDestroy(seq);
 }
 }
 // Next word
 token.Set(lex.NextToken());
 }
 }
 // Add the result
 if ( isAdded )
 {
-if ( isSearchInGroup )
+if ( aIsSearchInGroup )
 {
 if ( aContactsInGroup.Find(psData->Id()) != KErrNotFound )
 {
 aAlgorithmFilterHelper->AddL(psData,tempMatchSeq);
 }
 }
 }
 // Cleanup the match sequence array as
 // they are stored in pattern details structure
-tempMatchSeq.ResetAndDestroy();
+CleanupStack::PopAndDestroy( &tempMatchSeq ); // ResetAndDestroy
 }
 __LATENCY_MARKEND ( _L("CPcsAlgorithm1Helper::FilterResultsSingleL") );
 PRINT ( _L("End CPcsAlgorithm1Helper::FilterResultsSingleL") );
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1Helper::SearchMatchSeqL
 // Funciton to search matching sequences in the input text
 // ----------------------------------------------------------------------------
 void  CPcsAlgorithm1Helper::SearchMatchSeqL(CPsQuery& aPsQuery,
-TDesC& aData,
+const TDesC& aData,
 RPointerArray<TDesC>& aMatchSet,
 RArray<TPsMatchLocation>& aMatchLocation )
 {
 PRINT ( _L("Enter CPcsAlgorithm1Helper::SearchMatchSeqL") );
 TUint8 CPcsAlgorithm1Helper::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