/*
* 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: Supports initial search feature.
*
*/
// INCLUDES
#include "CPcsAlgorithm1Utils.h"
#include "CPsData.h"
#include "CPcsDefs.h"
#include "CPcsCache.h"
#include "CPsQueryItem.h"
#include <collate.h>
// CONSTANTS
_LIT(KSpace, ' ');
// Search contacts in a group URI template
_LIT(KGroupIdUri, "cntdb://c:contacts.gdb?id=");
// ============================== MEMBER FUNCTIONS ============================
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Utils::FormCompleteSearchResultsL()
// Merges all the respective data store result sets to single set in sorted order.
// ----------------------------------------------------------------------------
void CPcsAlgorithm1Utils::FormCompleteSearchResultsL(RPointerArray<CPSDATA_R_PTR_ARRAY>& aSearchResultsArr,
RPointerArray<CPsData>& SearchResults)
{
TInt maxIndex = 0;
TInt maxValue = aSearchResultsArr[maxIndex]->Count();
TLinearOrder<CPsData> rule( CPcsAlgorithm1Utils::CompareDataBySortOrderL );
// Find the largest array in aSearchResultsArr
for(TInt i = 1; i < aSearchResultsArr.Count(); i++)
{
if(aSearchResultsArr[i]->Count() > maxValue)
{
maxIndex = i;
maxValue =aSearchResultsArr[i]->Count();
}
}
// Assign the largets array to searchresults
for(TInt i = 0; i < aSearchResultsArr[maxIndex]->Count(); i++)
{
SearchResults.Append((*(aSearchResultsArr[maxIndex]))[i]);
}
// Merge the remaining result arrays to the largest array in sequential order
for(TInt i = 0; i < aSearchResultsArr.Count(); i++)
{
// Check if we are not copying again the largest array
if(( i != maxIndex) && ((aSearchResultsArr[i])->Count() != 0))
{
TInt numElements = (aSearchResultsArr[i])->Count();
for( TInt j = 0; j < numElements; j++)
{
SearchResults.InsertInOrderAllowRepeatsL((*(aSearchResultsArr[i]))[j], rule);
}
}
}
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Utils::MyCompareK()
// Case sensitive compare for keys of first 2 input params.
// ----------------------------------------------------------------------------
TBool CPcsAlgorithm1Utils::MyCompareK(const TDesC& aLeft, const TDesC& aRight, CPsQuery& aPsQuery)
{
TBool comparison = ETrue;
if ( (aLeft.Length() < aPsQuery.Count()) || (aRight.Length() < aPsQuery.Count()) )
{
comparison = EFalse;
}
else
{
for ( TInt i = 0; i < aPsQuery.Count(); i++ )
{
CPsQueryItem& currentItem = aPsQuery.GetItemAtL(i);
if ( (currentItem.Mode() == EItut) && (aLeft[i] != aRight[i]) )
{
comparison = EFalse;
break;
}
}
}
return comparison;
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Utils::MyCompareC()
// Lang specific MyCompareC
// ----------------------------------------------------------------------------
TInt CPcsAlgorithm1Utils::MyCompareC(const TDesC& aLeft, const TDesC& aRight)
{
// Get the current language
TLanguage lang = User::Language();
// Get the standard method
TCollationMethod meth = *Mem::CollationMethodByIndex( 0 );
meth.iFlags |= TCollationMethod::EIgnoreNone;
meth.iFlags |= TCollationMethod::EFoldCase;
if ( lang == ELangHindi || lang == ELangMarathi )
{
meth.iFlags |= TCollationMethod::EIgnoreCombining;
}
// Collation level 0 is used
TInt comparison(aLeft.CompareC( aRight, 0, &meth ));
return comparison;
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Utils::CompareDataBySortOrderL()
// TLinearOrder rule for comparison of data objects
// ----------------------------------------------------------------------------
TInt CPcsAlgorithm1Utils::CompareDataBySortOrderL(const CPsData& aObject1,
const CPsData& aObject2)
{
TInt compareRes(0);
if( CPsData::CompareById(aObject1, aObject2) )
{
return compareRes;
}
// Fetch the cache list stored in TLS to recover the sort order
typedef RPointerArray<CPcsCache> PTR;
PTR* pcsCache = static_cast<PTR*>(Dll::Tls());
User::LeaveIfNull(pcsCache);
CPcsCache* cache1 = (*pcsCache)[aObject1.UriId()];
CPcsCache* cache2 = (*pcsCache)[aObject2.UriId()];
RArray<TInt> indexOrder1;
RArray<TInt> indexOrder2;
// Get the index order based on sort order from the cache
cache1->GetIndexOrder(indexOrder1);
CleanupClosePushL(indexOrder1);
cache2->GetIndexOrder(indexOrder2);
CleanupClosePushL(indexOrder2);
TInt idx2 = 0;
for(TInt idx1 = 0;
idx1 < indexOrder1.Count() && idx2 < indexOrder2.Count() && compareRes == 0;
idx1++)
{
TInt object1Idx = indexOrder1[idx1];
HBufC* strCompare1 = aObject1.Data(object1Idx)->Des().AllocLC();
if ( object1Idx < aObject1.DataElementCount()
&& aObject1.Data(object1Idx)
&& strCompare1->Length() )
{
strCompare1->Des().TrimAll();
for(; idx2 < indexOrder2.Count(); idx2++)
{
TInt object2Idx = indexOrder2[idx2];
HBufC* strCompare2 = aObject2.Data(object2Idx)->Des().AllocLC();
if( strCompare2->Length() )
{
strCompare2->Des().TrimAll();
compareRes = CPcsAlgorithm1Utils::MyCompareC(*strCompare1, *strCompare2);
CleanupStack::PopAndDestroy(strCompare2);
if( compareRes == 0 )
{
idx2++;
}
break;
}
CleanupStack::PopAndDestroy(strCompare2);
}
}
CleanupStack::PopAndDestroy(strCompare1);
}
CleanupStack::PopAndDestroy(&indexOrder2);
CleanupStack::PopAndDestroy(&indexOrder1);
return compareRes;
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Utils::MyTrim()
// Trim off all white spaces and special characters
// This behavior is required to mimic the current phonebook sort sequence
// ----------------------------------------------------------------------------
void CPcsAlgorithm1Utils::MyTrim(TDes& aString)
{
for ( TInt i = aString.Length(); --i >= 0; )
{
TChar c = (TChar) aString[i];
if ( ! c.IsAlphaDigit() )
{
aString.Replace( i, 1, KSpace );
}
}
aString.TrimAll();
}
// ----------------------------------------------------------------------------
// CPcsAlgorithm1Utils::IsGroupUri()
// Check if the input URI is of contact search in a group template form
// ----------------------------------------------------------------------------
TBool CPcsAlgorithm1Utils::IsGroupUri(TDesC& aURI)
{
TBuf<255> uri(aURI);
uri.LowerCase();
TInt index = uri.FindF(KGroupIdUri);
if ( index == KErrNotFound )
{
return EFalse;
}
return ETrue;
}
// End of File