// Compare functions

TBool Compare2(const HBufC& aFirst, const HBufC& aSecond)

    {

    TPtrC t1(aFirst);

    TPtrC t2(aSecond);

    return (t1.Length() > t2.Length());

    }

TBool Compare3(const TDesC& aFirst, const TDesC& aSecond)

    {

    return aFirst == aSecond;

    }

TBool Compare4(const CPsQuery& aFirst, const CPsQuery& aSecond)

    {

    CPsQuery& first = const_cast<CPsQuery&> (aFirst);

    CPsQuery& second = const_cast<CPsQuery&> (aSecond);

    return (first.Count() > second.Count());

    }

    keyMap = iAlgorithm->GetKeyMap();

// CPcsAlgorithm2MultiSearchHelper::CPcsAlgorithm2MultiSearchHelper

                                                   TBool isSearchInGroup, 

                                                   RArray<TInt>& aContactsInGroup, 

                                                   RPointerArray<CPsData>& searchResults,

                                                   RPointerArray<CPsPattern>& searchSeqs,

                                                   TInt keyboardMode)

    __LATENCY_MARK ( _L("CPcsAlgorithm2MultiSearchHelper::SearchMultiL") );

    RPointerArray<TDesC> aDataStores;

    aSettings.SearchUrisL(aDataStores);

    // Search from cache based on first character

    TInt numValue  = keyMap->PoolIdForCharacter( firstCharItem.Character() );

    for (int dsIndex = 0; dsIndex < aDataStores.Count(); dsIndex++)

        TInt arrayIndex = iAlgorithm->GetCacheIndex(*(aDataStores[dsIndex]));

        cache->GetContactsForKeyL(numValue, elements);

        // Get the filtered data fields for this data store    		

        TUint8 filteredDataMatch = FilterDataFieldsL(requiredDataFields, supportedDataFields);

        FilterResultsMultiL(filterHelper, elements, aPsQuery, filteredDataMatch, 

                            isSearchInGroup, aContactsInGroup, keyboardMode);

        // If alphabetical sorting, get the results for this datastore               

        supportedDataFields.Reset();

    aDataStores.ResetAndDestroy();

    requiredDataFields.Reset();

        CPcsAlgorithm2Utils::FormCompleteSearchResultsL(iMultiSearchResultsArr, searchResults);

        filterHelper->GetResults(searchResults);

    filterHelper->GetPatternsL(searchSeqs);

    PRINT1 ( _L("Number of search results = %d"), searchResults.Count() );

    // Cleanup             

    delete filterHelper;

    __LATENCY_MARKEND ( _L("CPcsAlgorithm2MultiSearchHelper::SearchMultiL") );

// CPcsAlgorithm2MultiSearchHelper::SearchInputMultiL

// Function to search match sequences for multi query

void CPcsAlgorithm2MultiSearchHelper::SearchMatchSeqMultiL(RPointerArray<CPsQuery>& aPsQuery, 

                                                           TDesC& aData, 

                                                           RPointerArray<TDesC>& aMatchSet,

                                                           RArray<TPsMatchLocation>& aMatchLocation)

    CleanupResetAndDestroyPushL( aMatchSet );

    CleanupClosePushL( aMatchLocation );

    RPointerArray<HBufC> queryList;

    ConvertQueryToListL(aPsQuery, queryList);

    RPointerArray<HBufC> tempqueryList;

    // Remember a temporary copy of query list

    // since we sort the queries

    for (TInt i = 0; i < queryList.Count(); i++)

        {

        tempqueryList.Append(queryList[i]);

    TBool isMatch = ETrue;

    TUint32 wordMatches = 0;

    // Sort the query items before we search them

    TLinearOrder<HBufC> rule(Compare2);

    queryList.Sort(rule);

    for (TInt queryIndex = queryList.Count() - 1; queryIndex >= 0; queryIndex--)

        HBufC* tmpQuery = queryList[queryIndex];

        // Get the original query mode corresponding to this query

        TInt modeIndex = tempqueryList.Find(tmpQuery);

        TLex lex(aData);

        TInt beg = lex.Offset() - tmpData.Length(); // start index of match sequence

        TInt wordIndex = -1;

        while ((tmpData.Length() != 0) && (!queryMatch))

            TPtr ptr = tmpQuery->Des();

            // 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 = EFalse;

            TReal val;

            Math::Pow(val, 2, wordIndex);

            isWordMatch = wordMatches & (TUint) val;

            if (!isWordMatch)

                // Check if no word is matched till now for this query

                if (!queryMatch)

                    queryMatch = ETrue;

                    //set the word match bit

                    TReal val;

                    Math::Pow(val, 2, wordIndex);

                    wordMatches |= (TUint) val;

                    }

                TPsMatchLocation tempLocation;

                // check for directionality of the text

                TBool found(EFalse);

                TBidiText::TDirectionality dir = TBidiText::TextDirectionality(tmpData, &found);

                tempLocation.index = beg;

                tempLocation.length = 0;

                tempLocation.direction = dir;

                // Add the match location to the data structure array

                aMatchLocation.Append(tempLocation);

            }

        // Next word

        tmpData.Set(lex.NextToken());

        beg = lex.Offset() - tmpData.Length(); // start index of next word  

        if (queryMatch == EFalse)

    // Count the number of bits set

    TInt matchCount = 0;

    matchCount = BitsSet32(wordMatches);

    // Before adding to the result set, check if there is atleast one match per query

    // Number of bits set in word matches is atleast equal to total number of queries.

    if ((isMatch) && (matchCount >= queryList.Count()))

        // Include the match sequences in the final results

        for (int i = 0; i < tmpMatchSet.Count(); i++)

            TIdentityRelation<TDesC> rule(Compare3);

            CleanupStack::PushL(tmpMatchSet[i]);

            if (aMatchSet.Find(tmpMatchSet[i], rule) == KErrNotFound)

                {

                aMatchSet.Append(tmpMatchSet[i]);

                CleanupStack::Pop();

                }

            else

                {

                CleanupStack::PopAndDestroy();

                }

        // Reset tmp match set

        tmpMatchSet.Reset();

        }

    else

        {

        tmpMatchSet.ResetAndDestroy();

    // Free the query list

    queryList.ResetAndDestroy();

    tempqueryList.Reset();

    CleanupStack::Pop();

    CleanupStack::Pop( &aMatchSet );

    PRINT ( _L("End CPcsAlgorithm2MultiSearchHelper::SearchMatchSeqMultiL") );

    }

// ----------------------------------------------------------------------------

// CPcsAlgorithm2MultiSearchHelper::ConvertQueryToList

// Converts the multiple search queries to a list

// ----------------------------------------------------------------------------

void CPcsAlgorithm2MultiSearchHelper::ConvertQueryToListL(RPointerArray<CPsQuery>& aSearchQuery, 

                                                          RPointerArray<HBufC>& aQueryList)

    {

    for (int queryIndex = 0; queryIndex < aSearchQuery.Count(); queryIndex++)

        {

        CPsQuery* query = aSearchQuery[queryIndex];

        HBufC* tmpSearchQuery = HBufC::NewL(KPsQueryMaxLen);

        TPtr ptr = tmpSearchQuery->Des();

        if (query->KeyboardModeL() == EItut) // ITU

            {

            keyMap->GetNumericKeyString(query->QueryAsStringLC(), ptr);

            CleanupStack::PopAndDestroy();

            }

        else if (query->KeyboardModeL() == EQwerty) // QWERTY

            {

            ptr = query->QueryAsStringLC();

            ptr.LowerCase();

            CleanupStack::PopAndDestroy();

            }

        else // UNDEFINED

            {

            ExtractQueryL(*query, ptr);

            ptr.LowerCase();

            }

        aQueryList.Append(tmpSearchQuery);

        }

    }

// ----------------------------------------------------------------------------

// CPcsAlgorithm2MultiSearchHelper::ConvertdDataToKeyBoardModeL

// Converts the input data to the key board mode specified by the query

// ----------------------------------------------------------------------------

void CPcsAlgorithm2MultiSearchHelper::ConvertdDataToKeyBoardModeL(CPsQuery* aQuery, 

                                                                  TPtrC aInputData, 

                                                                  TBuf<KPsQueryMaxLen>& aOutputData)

    {

    if (aQuery->KeyboardModeL() == EItut)

        {

        keyMap->GetNumericKeyString(aInputData, aOutputData);

        }

    else if (aQuery->KeyboardModeL() == EQwerty)

        {

        aOutputData = aInputData;

        aOutputData.LowerCase();

        }

    else

        {

        ExtractQueryL(aInputData, *aQuery, aOutputData);

        aOutputData.LowerCase();

        }

                                                          RPointerArray<CPcsPoolElement>& searchSet,

                                                          RPointerArray<CPsQuery>& searchQuery, 

                                                          TBool isSearchInGroup, 

                                                          RArray<TInt>& aContactsInGroup,

                                                          TInt keyboardMode)

    for (TInt i=0; i<searchQuery.Count(); i++)

        iAlgorithm->FindUtilECE()->GetPartOfQueryL(*(searchQuery[i]), 0, 

                                                   searchQuery[i]->Count()-1, *tempQuery);

        mySearchQuery.Append(tempQuery);

    TLinearOrder<CPsQuery> rule(Compare4);

    // Parse thru each search set elements and filter the results    

    for (int index = 0; index < searchSet.Count(); index++)

        CPcsPoolElement* poolElement = static_cast<CPcsPoolElement*> (searchSet[index]);

        TUint8 wordMatches = 0;

        for (TInt queryIndex = mySearchQuery.Count() - 1; queryIndex >= 0; queryIndex--)            

            for (TInt dataIndex = 0; dataIndex < psData->DataElementCount(); dataIndex++)

                TReal bitIndex;

                Math::Pow(bitIndex, 2, dataIndex);

                TUint8 filter = (TUint8) bitIndex & aFilteredDataMatch;

                if (filter == 0x0)

                    TPtrC queryPtr = tmpPsQuery->QueryAsStringLC();

                    TBool matched = EFalse;