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

equal deleted inserted replaced

-:e686773b3f54
+:04ab22b956c2
 #include "CPcsAlgorithm1Utils.h"
 #include "CPcsDefs.h"
 #include <collate.h>
 #include <biditext.h>
-// Compare functions
-TBool CompareByLength ( const HBufC& aFirst, const HBufC& aSecond )
-{
-return ( aFirst.Length() > aSecond.Length() );
-}
-TBool Compare3 ( const TDesC& aFirst, const TDesC& aSecond )
-{
-	return aFirst == aSecond;
-}
 // ============================== MEMBER FUNCTIONS ============================
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1MultiSearchHelper::NewL
 // Two Phase Construction
 {
 PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::SearchMatchSeqMultiL") );
 RPointerArray<HBufC> descriptorsQueryList;
 ConvertQueryToListL(aPsQuery, descriptorsQueryList);
 TLex lex(aData);
-while ( !lex.Eos() )                                    // Search thru all words
+while ( !lex.Eos() ) // Search thru all words
 {
-TPtrC currentWord = lex.NextToken();                // next word
+TPtrC currentWord = lex.NextToken(); // next word
 TPsMatchLocation newLocation = { lex.Offset() - currentWord.Length(), //start index
-0,
+0, TBidiText::TextDirectionality(currentWord) };
-TBidiText::TextDirectionality(currentWord) };
 for ( TInt queryIndex = 0; queryIndex < aPsQuery.Count(); ++queryIndex )
 {
 HBufC* currentQuery = descriptorsQueryList[queryIndex];
 TBuf<KPsQueryMaxLen> convertedWord;
 // Convert the data to required form (mode specific)
 iKeyMap->GetMixedKeyStringForDataL(*aPsQuery[queryIndex], currentWord, convertedWord);
-if ( CPcsAlgorithm1Utils::MyCompareC(convertedWord.Left(currentQuery->Length()), *currentQuery) == 0 )
+if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(convertedWord, *currentQuery, *aPsQuery[queryIndex]) )
 {
 newLocation.length = currentQuery->Length();
 aMatchLocation.AppendL( newLocation );
 AppendMatchToSeqL( aMatchSeq, currentWord.Left(newLocation.length) );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1MultiSearchHelper::AppendMatchToSeqL
 // ----------------------------------------------------------------------------
 void CPcsAlgorithm1MultiSearchHelper::AppendMatchToSeqL(
 RPointerArray<TDesC>& aMatchSeq, const TDesC& aMatch  )
 {
 HBufC* seq = aMatch.AllocLC();
 seq->Des().UpperCase();
-TIdentityRelation<TDesC> rule(Compare3);
+TIdentityRelation<TDesC> rule(CPcsAlgorithm1Utils::CompareExact);
 if ( aMatchSeq.Find(seq, rule) == KErrNotFound )
 {
 aMatchSeq.Append(seq);
 CleanupStack::Pop( seq );
 }
 else
 {
 CleanupStack::PopAndDestroy( seq );
 }
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1MultiSearchHelper::LookupMatchL
 // ----------------------------------------------------------------------------
 void CPcsAlgorithm1MultiSearchHelper::LookupMatchL( CPsQuery& aSearchQuery,
 const TDesC& aData,
 TDes& aMatchedData )
 {
 RPointerArray<CPsQuery> queryList = MultiQueryL(aSearchQuery);
 TBuf<KPsQueryMaxLen> queryAsString = aSearchQuery.QueryAsStringLC();
 TBuf<KPsQueryMaxLen> convertedQuery;
 iKeyMap->GetMixedKeyStringForDataL( aSearchQuery, queryAsString, convertedQuery );
 RArray<TInt> dataWordIndexes;
 RArray<TInt> dataWordLengths;
 TLex lex( aData );
 while ( !lex.Eos() )
 {
 TPtrC currentWord = lex.NextToken();
 PRINT2( _L("idx len: %d %d"), lex.Offset() - currentWord.Length(), currentWord.Length() );
 dataWordIndexes.AppendL( lex.Offset() -  currentWord.Length() );
 dataWordLengths.AppendL( currentWord.Length() );
 }
 RArray<TInt> queryIndexes;
 RArray<TPtrC> convertedQueriesAsDes;
 lex.Assign( queryAsString );
 while ( !lex.Eos() )
 {
 TPtrC currentWord = lex.NextToken();
 convertedQueriesAsDes.AppendL(
 convertedQuery.Mid( lex.Offset() - currentWord.Length(), currentWord.Length()) );
 queryIndexes.AppendL( lex.Offset() - currentWord.Length() );
 }
 RPointerArray< RArray<TBool> > possibleMatches;
 for ( TInt i(0); i < queryList.Count(); ++i )
 {
 RArray<TBool>* matchesForCurrentQuery = new (ELeave) RArray<TBool>;
 possibleMatches.AppendL( matchesForCurrentQuery );
 CPsQuery* currentQuery = queryList[i];
 for ( TInt j(0); j < dataWordIndexes.Count(); j++ )
 {
 TPtrC currentDataWord = aData.Mid( dataWordIndexes[j], dataWordLengths[j] );
 RBuf convertedDataWord;
 convertedDataWord.CreateL( currentDataWord.Length() );
 CleanupClosePushL( convertedDataWord );
 iKeyMap->GetMixedKeyStringForDataL( *currentQuery, currentDataWord.Left(currentQuery->Count()), convertedDataWord );
-if ( CPcsAlgorithm1Utils::MyCompareC( convertedQueriesAsDes[i], convertedDataWord ) == 0 )
-{
+if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(convertedQueriesAsDes[i], convertedDataWord, *currentQuery) )
+{
 matchesForCurrentQuery->AppendL( ETrue );
 }
 else
 {
 matchesForCurrentQuery->AppendL( EFalse );
 }
 PRINT3( _L("CPcsAlgorithm1MultiSearchHelper::LookupMatchL: possibleMatches[%d][%d]=%d"),i,j, (*(possibleMatches[i]))[j] )
 CleanupStack::PopAndDestroy( &convertedDataWord );
-}
 }
+}
 const TInt KUnapplied(-1);
 RArray<TInt> appliedMatches;
 appliedMatches.ReserveL( queryList.Count() );
 for ( TInt i(0); i < queryList.Count(); ++i )
 {
 appliedMatches.AppendL( KUnapplied );
 }
 //backtrack algorithm starts here to find fully applied match
 TInt currentQueryIndex(0);
-while ( currentQueryIndex < queryList.Count()
+while ( currentQueryIndex < queryList.Count() && currentQueryIndex >= 0 )
-&& currentQueryIndex >= 0 )
+{
-{
 TInt currentDataIndex = appliedMatches[ currentQueryIndex ] + 1;
 appliedMatches[ currentQueryIndex ] = KUnapplied;
 RArray<TBool>& matchesForCurrentQuery = *(possibleMatches[currentQueryIndex]);
 TBool doBacktrack( ETrue );
 while ( currentDataIndex < dataWordIndexes.Count() )
 {
 PRINT2(_L("CPcsAlgorithm1MultiSearchHelper::LookupMatchL: matchesForCurrentQuery[%d] = %d"),
 currentDataIndex, matchesForCurrentQuery[ currentDataIndex ] );
 if ( matchesForCurrentQuery[ currentDataIndex ]
 && (appliedMatches.Find( currentDataIndex ) == KErrNotFound) )
 {
 appliedMatches[ currentQueryIndex ] = currentDataIndex;
 doBacktrack = EFalse;
 break;
 }
 ++currentDataIndex;
 }
 if ( doBacktrack )
 {
 --currentQueryIndex;
 }
 else
 {
 ++currentQueryIndex;
-}
 }
+}
 if ( currentQueryIndex >= 0 ) //found
 {
 aMatchedData = queryAsString;
 for ( TInt i(0); i < appliedMatches.Count(); ++i )
 {
 TInt matchedDataIndex = appliedMatches[i];
 TPtr resultFragment = aMatchedData.MidTPtr(
 queryIndexes[ i ],
 convertedQueriesAsDes[i].Length() );
 resultFragment = aData.Mid(
 dataWordIndexes[ matchedDataIndex ],
 convertedQueriesAsDes[i].Length() );
 }
 }
 else
 {
 aMatchedData.Zero();
 }
 for ( TInt i(0); i < possibleMatches.Count(); ++i )
 {
 RArray<TBool>* pointerToDelete = possibleMatches[i];
 pointerToDelete->Close();
 delete pointerToDelete;
 }
 possibleMatches.Close();
 dataWordIndexes.Close();
 dataWordLengths.Close();
 queryIndexes.Close();
 convertedQueriesAsDes.Close();
 queryList.Close();
 appliedMatches.Close();
 CleanupStack::PopAndDestroy();  //result of queryAsStringLC
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1MultiSearchHelper::ConvertQueryToList
 // Converts the multiple search queries to a list
 // ----------------------------------------------------------------------------
 	{
 		tempqueryList.Append(queryList[i]);
 	}
 	// Sort the query items before we search them
-	TLinearOrder<HBufC> rule( CompareByLength );
+	TLinearOrder<HBufC> rule( CPcsAlgorithm1Utils::CompareByLength );
 	queryList.Sort(rule);
 // To hold the match results
 RPointerArray<TDesC> tmpMatchSet;
 		// Check for each query atleast one data element matches
 		// Loop from the last query so that longest match is seen first
 		for ( TInt queryIndex = queryList.Count() - 1; queryIndex >= 0; queryIndex-- )
 		{
-		     TBool queryMatch = EFalse;
+		    TBool queryMatch = EFalse;
-		     HBufC* tmpQuery = queryList[queryIndex];
+		    HBufC* tmpQuery = queryList[queryIndex];
-		     // Get the original query mode corresponding to this query
+		    // Get the original query mode corresponding to this query
-		     TInt modeIndex = tempqueryList.Find(tmpQuery);
+		    TInt modeIndex = tempqueryList.Find(tmpQuery);
-		     for ( TInt dataIndex = 0; dataIndex < psData->DataElementCount(); dataIndex++ )
+		    for ( TInt dataIndex = 0; dataIndex < psData->DataElementCount(); dataIndex++ )
-		     {
+		    {
-		         // Filter off data fields not required in search
+		        // Filter off data fields not required in search
-		         TReal bitIndex;
+		        TReal bitIndex;
-		         Math::Pow(bitIndex, 2, dataIndex);
+		        Math::Pow(bitIndex, 2, dataIndex);
 TUint8 filter = (TUint8)bitIndex & aFilteredDataMatch;
-		         if ( filter == 0x0 )
+		        if ( filter == 0x0 )
-		         {
+		        {
 		            // Move to next data
-		         	continue;
+		        	continue;
-		         }
+		        }
-		         TInt wordIndex = -1;
+		        TInt wordIndex = -1;
-			     TLex lex(psData->Data(dataIndex)->Des());
+			    TLex lex(psData->Data(dataIndex)->Des());
-			     // First word
+			    // First word
-			     TPtrC tmpData = lex.NextToken();
+			    TPtrC tmpData = lex.NextToken();
-			     // Search thru multiple words
+			    // Search thru multiple words
-			     while ( tmpData.Length() != 0 )
+			    while ( tmpData.Length() != 0 )
-			     {
+			    {
-			         wordIndex++;
+			        wordIndex++;
-			     	 TBuf<KPsQueryMaxLen> data;
+			     	TBuf<KPsQueryMaxLen> data;
-			         // Convert the data to required form (mode specific)
+	                // Convert the data to required form (mode specific)
-				     iKeyMap->GetMixedKeyStringForDataL(*searchQuery[modeIndex], tmpData, data);
+	                iKeyMap->GetMixedKeyStringForDataL(*searchQuery[modeIndex], tmpData, data);
-				     // Compare the data against query
+				    // Compare the data against query
-if ( CPcsAlgorithm1Utils::MyCompareC(data.Left(tmpQuery->Length()),
+if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(data, *tmpQuery, *searchQuery[modeIndex]) )
-*tmpQuery) == 0 )
+				    {
-				     {
 				        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
 							if ( !queryMatch )
 							{
 								wordMatches++;
 	                 			queryMatch = ETrue;
 	                 			SetWordMap(dataIndex, wordIndex);
 							}
 					        // Extract matched character sequence and fill in temp array
 							TInt len = tmpQuery->Length();
 							HBufC* seq = HBufC::NewL(len);
 							*seq = tmpData.Mid(0, len);
 							seq->Des().UpperCase();
-							TIdentityRelation<TDesC> searchRule(Compare3);
+							TIdentityRelation<TDesC> searchRule(CPcsAlgorithm1Utils::CompareExact);
 							if ( tmpMatchSet.Find(seq, searchRule) == KErrNotFound )
 							{
-							tmpMatchSet.Append(seq);
+tmpMatchSet.Append(seq);
 							}
 							else
-							    {
+							{
-								  delete seq;
+delete seq;
-								  seq = NULL;
+								seq = NULL;
-							    }
+							}
 						}
-				     }
+				    }
-				     // Next word
+				    // Next word
-				     tmpData.Set(lex.NextToken());
+				    tmpData.Set(lex.NextToken());
-			     }
+			    }
-		     }
+		    }
-		     // No data element matches the query. Ignore this result.
+		    // No data element matches the query. Ignore this result.
-		     if ( queryMatch == EFalse )
+		    if ( queryMatch == EFalse )
-		     {
+		    {
 		        isMatch = EFalse;
 		     	break;
-		     }
+		    }
 		}
 		// 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()))
 	return filteredMatch;
 }
 // End of file

branch	RCL_3
changeset 3	04ab22b956c2
parent 0	e686773b3f54
child 6	e8e3147d53eb