/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Predictive Contact Search Algorithm 1 helper class
*
*/
// INCLUDES
#include "CPcsAlgorithm1.h"
#include "CPcsAlgorithm1Helper.h"
#include "CPcsAlgorithm1Utils.h"
#include "CPcsDebug.h"
#include "CPcsCache.h"
#include "CPcsKeyMap.h"
#include "CPsData.h"
#include "CWords.h"
#include "CPsQuery.h"
#include "CPsQueryItem.h"
#include "CPsDataPluginInterface.h"
#include "CPcsPoolElement.h"
// ============================== MEMBER FUNCTIONS ============================
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Helper::NewL
// Two Phase Construction
// ----------------------------------------------------------------------------
CPcsAlgorithm1Helper* CPcsAlgorithm1Helper::NewL(CPcsAlgorithm1* aAlgorithm)
{
PRINT ( _L("Enter CPcsAlgorithm1Helper::NewL") );
CPcsAlgorithm1Helper* self = new ( ELeave ) CPcsAlgorithm1Helper();
CleanupStack::PushL( self );
self->ConstructL(aAlgorithm);
CleanupStack::Pop( self );
PRINT ( _L("End CPcsAlgorithm1Helper::NewL") );
return self;
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Helper::CPcsAlgorithm1Helper
// Two Phase Construction
// ----------------------------------------------------------------------------
CPcsAlgorithm1Helper::CPcsAlgorithm1Helper()
{
PRINT ( _L("Enter CPcsAlgorithm1Helper::CPcsAlgorithm1") );
PRINT ( _L("End CPcsAlgorithm1Helper::CPcsAlgorithm1") );
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Helper::ConstructL
// Two Phase Construction
// ----------------------------------------------------------------------------
void CPcsAlgorithm1Helper::ConstructL(CPcsAlgorithm1* aAlgorithm)
{
PRINT ( _L("Enter CPcsAlgorithm1Helper::ConstructL") );
iAlgorithm = aAlgorithm;
iKeyMap = iAlgorithm->GetKeyMap();
PRINT ( _L("End CPcsAlgorithm1Helper::ConstructL") );
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Helper::CPcsAlgorithm1Helper
// Destructor
// ----------------------------------------------------------------------------
CPcsAlgorithm1Helper::~CPcsAlgorithm1Helper()
{
PRINT ( _L("Enter CPcsAlgorithm1Helper::~CPcsAlgorithm1Helper") );
iSearchResultsArr.ResetAndDestroy();
PRINT ( _L("End CPcsAlgorithm1Helper::~CPcsAlgorithm1Helper") );
}
// ----------------------------------------------------------------------------
// 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,
CPsQuery& aPsQuery,
TBool aIsSearchInGroup,
RArray<TInt>& aContactsInGroup,
RPointerArray<CPsData>& aSearchResults,
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 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> dataStores;
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 ( TInt dsIndex = 0;
dsIndex < dataStores.Count();
dsIndex++ )
{
RPointerArray<CPsData> *temp = new (ELeave) RPointerArray<CPsData> ();
CleanupStack::PushL( temp );
iSearchResultsArr.AppendL( temp );
CleanupStack::Pop( temp );
// Get the contents for this data store
TInt arrayIndex = iAlgorithm->GetCacheIndex(*(dataStores[dsIndex]));
if ( arrayIndex < 0 ) continue;
CPcsCache* cache = iAlgorithm->GetCache(arrayIndex);
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 = CPcsAlgorithm1Utils::FilterDataFieldsL(requiredDataFields,
supportedDataFields);
// Perform filtering
FilterResultsSingleL(filterHelper,
elements,
aPsQuery,
filteredDataMatch,
aIsSearchInGroup,
aContactsInGroup);
// If alphabetical sorting, get the results for this datastore
if ( sortType == EAlphabetical )
{
filterHelper->GetResults(*(iSearchResultsArr[dsIndex]));
}
elements.Reset();
CleanupStack::PopAndDestroy( &supportedDataFields ); // Close
}
CleanupStack::PopAndDestroy( &elements ); // Close
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,
aSearchResults);
}
else
{
// Results are already sorted pattern based
filterHelper->GetResults(aSearchResults);
}
// Get the sorted match sequence list
filterHelper->GetPatternsL(aSearchSeqs);
PRINT1 ( _L("CPcsAlgorithm1Helper::SearchSingleL: Number of search results = %d"), aSearchResults.Count() );
// Cleanup
for ( TInt i = 0; i < iSearchResultsArr.Count(); i++ )
{
iSearchResultsArr[i]->Reset();
}
iSearchResultsArr.ResetAndDestroy();
CleanupStack::PopAndDestroy( filterHelper );
__LATENCY_MARKEND ( _L("CPcsAlgorithm1Helper::SearchSingleL") );
PRINT ( _L("End CPcsAlgorithm1Helper::SearchSingleL") );
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Helper::FilterResultsSingleL
// Subset search function
// ----------------------------------------------------------------------------
void CPcsAlgorithm1Helper::FilterResultsSingleL(CPcsAlgorithm1FilterHelper* aAlgorithmFilterHelper,
RPointerArray<CPcsPoolElement>& aSearchSet,
CPsQuery& aPsQuery,
TUint8 aFilteredDataMatch,
TBool aIsSearchInGroup,
RArray<TInt>& aContactsInGroup)
{
PRINT ( _L("Enter CPcsAlgorithm1Helper::FilterResultsSingleL") );
__LATENCY_MARK ( _L("CPcsAlgorithm1Helper::FilterResultsSingleL") );
// Convert the search query to char-and-key string
TBuf<KPsQueryMaxLen> queryAsDes;
iKeyMap->GetMixedKeyStringForQueryL( aPsQuery, queryAsDes );
PRINTQUERY ( _L("CPcsAlgorithm1Helper::FilterResultsSingleL: "), aPsQuery );
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 < aSearchSet.Count(); index++ )
{
CPcsPoolElement* poolElement = static_cast<CPcsPoolElement*>(aSearchSet[index]);
CPsData* psData = poolElement->GetPsData();
psData->ClearDataMatches();
// Skip this contact if performing group search and this contact doesn't
// belong to the group
if ( aIsSearchInGroup && aContactsInGroup.Find(psData->Id()) == KErrNotFound )
{
continue;
}
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
TUint8 bitIndex = 1 << dataIndex;
TUint8 filter = bitIndex & aFilteredDataMatch;
if ( filter == 0x0 )
{
// Move to next data
continue;
}
if ( poolElement->IsDataMatch(dataIndex) )
{
TLex lex( *psData->Data(dataIndex) );
// First word
TPtrC token = lex.NextToken();
// Search thru multiple words
while ( token.Length() != 0 )
{
// Convert the data to char-and-key string
TBuf<KPsQueryMaxLen> dataWithKeys;
iKeyMap->GetMixedKeyStringForDataL( aPsQuery, token, dataWithKeys );
if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(dataWithKeys, queryAsDes, aPsQuery) )
{
psData->SetDataMatch(dataIndex);
isAdded = ETrue;
// Extract matched character sequence
TInt len = queryAsDes.Length();
TPtrC seq = token.Left(len);
CPcsAlgorithm1Utils::AppendMatchToSeqL( tempMatchSeq, seq );
}
// Next word
token.Set(lex.NextToken());
}
}
}
// Add the result
if ( isAdded )
{
aAlgorithmFilterHelper->AddL(psData,tempMatchSeq);
}
// Cleanup the match sequence array as
// they are stored in pattern details structure
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,
const TDesC& aData,
RPointerArray<TDesC>& aMatchSet,
RArray<TPsMatchLocation>& aMatchLocation )
{
PRINT ( _L("Enter CPcsAlgorithm1Helper::SearchMatchSeqL") );
HBufC* queryAsDes = HBufC::NewLC(aPsQuery.Count());
TPtr queryAsDesPtr(queryAsDes->Des());
iKeyMap->GetMixedKeyStringForQueryL( aPsQuery, queryAsDesPtr );
// Convert the data into words
TLex lex(aData);
// First word
TPtrC token = lex.NextToken();
TInt beg = lex.Offset() - token.Length(); // start index of match sequence
// Search thru multiple words
while ( token.Length() != 0 )
{
HBufC* data = HBufC::NewLC(token.Length());
TPtr dataPtr(data->Des());
iKeyMap->GetMixedKeyStringForDataL( aPsQuery, token, dataPtr );
if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(dataPtr, *queryAsDes, aPsQuery) )
{
TInt len = queryAsDes->Length();
TPsMatchLocation tempLocation;
// check for directionality of the text
TBool found(EFalse);
TBidiText::TDirectionality dir = TBidiText::TextDirectionality(token, &found);
tempLocation.index = beg;
tempLocation.length = len;
tempLocation.direction = dir;
// Add the match location to the data structure array
aMatchLocation.Append(tempLocation);
// Add the sequence to the match sequence
TPtrC seq = token.Left(len);
CPcsAlgorithm1Utils::AppendMatchToSeqL( aMatchSet, seq );
}
// Next word
token.Set(lex.NextToken());
beg = lex.Offset() - token.Length(); // start index of next word
CleanupStack::PopAndDestroy(); //data
}
CleanupStack::PopAndDestroy( queryAsDes );
PRINT ( _L("End CPcsAlgorithm1Helper::SearchMatchSeqL") );
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Helper::SortSearchSeqsL()
//
// ----------------------------------------------------------------------------
void CPcsAlgorithm1Helper::SortSearchSeqsL(RPointerArray<TDesC>& aSearchSeqs)
{
// Sort the search seqs
TLinearOrder<TDesC> rule( CPcsAlgorithm1Utils::CompareCollate );
aSearchSeqs.Sort(rule);
}
// End of file