--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/predictivesearch/PcsAlgorithm/Algorithm2/src/CPcsAlgorithm2Utils.cpp Wed Sep 01 12:29:52 2010 +0100
@@ -0,0 +1,346 @@
+/*
+* 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 "CPcsAlgorithm2Utils.h"
+#include "CPsData.h"
+#include "CPsQuery.h"
+#include "CPcsDefs.h"
+#include "CPcsCache.h"
+#include <collate.h>
+// CONSTANTS
+_LIT(KSpace, ' ');
+// Search contacts in a group URI template
+_LIT(KGroupIdUri, "cntdb://c:contacts.gdb?id=");
+
+// ============================== MEMBER FUNCTIONS ============================
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2Utils::FormCompleteSearchResultsL()
+// Merges all the respective data store result sets to single set in sorted order.
+// ----------------------------------------------------------------------------
+void CPcsAlgorithm2Utils::FormCompleteSearchResultsL(RPointerArray<CPSDATA_R_PTR_ARRAY>& aSearchResultsArr,
+ RPointerArray<CPsData>& aSearchResults)
+ {
+ TInt maxIndex = 0;
+ TInt maxValue = aSearchResultsArr[maxIndex]->Count();
+ TLinearOrder<CPsData> rule(CPcsAlgorithm2Utils::CompareDataBySortOrder);
+
+ // Find the largest array in aSearchResultsArr
+ const TInt searchResultsArrCount = aSearchResultsArr.Count();
+ for (TInt i = 1; i < searchResultsArrCount; i++)
+ {
+ if (aSearchResultsArr[i]->Count() > maxValue)
+ {
+ maxIndex = i;
+ maxValue = aSearchResultsArr[i]->Count();
+ }
+ }
+
+ // Assign the largets array to searchresults
+ const TInt cnt = aSearchResultsArr[maxIndex]->Count();
+ for (TInt i = 0; i < cnt; i++)
+ {
+ aSearchResults.Append((*(aSearchResultsArr[maxIndex]))[i]);
+ }
+
+ // Merge the remaining result arrays to the largest array in sequential order
+
+ for (TInt i = 0; i < searchResultsArrCount; 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++)
+ {
+ aSearchResults.InsertInOrderAllowRepeatsL((*(aSearchResultsArr[i]))[j], rule);
+ }
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2Utils::MyCompareC()
+// Lang specific MyCompareC
+// ----------------------------------------------------------------------------
+TInt CPcsAlgorithm2Utils::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 3 is used
+ TInt comparison(aLeft.CompareC(aRight, 3, &meth));
+ return comparison;
+ }
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2Utils::CompareDataBySortOrder()
+// TLinearOrder rule for comparison of data objects
+// ----------------------------------------------------------------------------
+TInt CPcsAlgorithm2Utils::CompareDataBySortOrder(const CPsData& aObject1,
+ const CPsData& aObject2)
+ {
+ _LIT(KSpace, " ");
+
+ // Fetch the cache list stored in TLS to recover the sort order
+ typedef RPointerArray<CPcsCache> PTR;
+ PTR* pcsCache = static_cast<PTR*> (Dll::Tls());
+
+ // Data1
+ TBuf<255> data1(KNullDesC);
+ TInt uriId1 = aObject1.UriId();
+ CPcsCache* cache = (*pcsCache)[uriId1];
+
+ RArray<TInt> indexOrder;
+
+ // Get the index order based on sort order from the cache
+ cache->GetIndexOrder(indexOrder);
+
+ // Append sort order elements first
+ const TInt indexOrderCount1 = indexOrder.Count();
+ for (int i = 0; i < indexOrderCount1; i++)
+ {
+ TInt index = indexOrder[i];
+ if (index < aObject1.DataElementCount() && aObject1.Data(index))
+ {
+ // Trim the unnecessary white spaces/special chars before we compare
+ TBuf<255> str(KNullDesC);
+
+ str = aObject1.Data(index)->Des();
+ CPcsAlgorithm2Utils::MyTrim(str);
+
+ data1 += str;
+ data1 += KSpace;
+ }
+ }
+
+ /* --- NOT SURE IF THIS BEHAVIOR IS REQUIRED ---
+ // Append remaining elements in order
+ for ( int i = 0; i < aObject1.DataElementCount(); i++ )
+ {
+ if ( indexOrder.Find(i) == KErrNone && aObject1.Data(i) )
+ {
+ data1 += aObject1.Data(i)->Des();
+ data1 += KSpace;
+ }
+ }
+ */
+
+ // Data2
+ TBuf<255> data2(KNullDesC);
+ TInt uriId2 = aObject2.UriId();
+ cache = (*pcsCache)[uriId2];
+
+ indexOrder.Reset();
+
+ // Get the index order based on sort order from the cache
+ cache->GetIndexOrder(indexOrder);
+ const TInt indexOrderCount2 = indexOrder.Count();
+
+ // Append sort order elements first
+ for (int i = 0; i < indexOrderCount2; i++)
+ {
+ TInt index = indexOrder[i];
+ if (index < aObject2.DataElementCount() && aObject2.Data(index))
+ {
+ // Trim the unnecessary white spaces/special chars before we compare
+ TBuf<255> str(KNullDesC);
+
+ str = aObject2.Data(index)->Des();
+ CPcsAlgorithm2Utils::MyTrim(str);
+
+ data2 += str;
+ data2 += KSpace;
+ }
+ }
+
+ /* --- NOT SURE IF THIS BEHAVIOR IS REQUIRED ---
+ // Append remaining elements in order
+ for ( int i = 0; i < aObject2.DataElementCount(); i++ )
+ {
+ if ( indexOrder.Find(i) == KErrNone && aObject2.Data(i) )
+ {
+ data2 += aObject2.Data(i)->Des();
+ data2 += KSpace;
+ }
+ }
+ */
+
+ indexOrder.Reset();
+ data1.TrimAll();
+ data2.TrimAll();
+ return (CPcsAlgorithm2Utils::MyCompareC(data1, data2));
+ }
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2Utils::CompareExact()
+//
+// ----------------------------------------------------------------------------
+TBool CPcsAlgorithm2Utils::CompareExact(const TDesC& aFirst, const TDesC& aSecond)
+ {
+ return aFirst == aSecond;
+ }
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2Utils::CompareLength()
+//
+// ----------------------------------------------------------------------------
+TInt CPcsAlgorithm2Utils::CompareLength(const CPsQuery& aFirst, const CPsQuery& aSecond)
+ {
+ CPsQuery& first = const_cast<CPsQuery&> (aFirst);
+ CPsQuery& second = const_cast<CPsQuery&> (aSecond);
+
+ return (first.Count() - second.Count());
+ }
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2Utils::MyTrim()
+// Trim off all white spaces and special characters
+// This behavior is required to mimic the current phonebook sort sequence
+// ----------------------------------------------------------------------------
+void CPcsAlgorithm2Utils::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();
+ }
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2Utils::IsGroupUri()
+// Check if the input URI is of contact search in a group template form
+// ----------------------------------------------------------------------------
+TBool CPcsAlgorithm2Utils::IsGroupUri(TDesC& aURI)
+ {
+ TBuf<255> uri(aURI);
+ uri.LowerCase();
+
+ TInt index = uri.FindF(KGroupIdUri);
+
+ if (index == KErrNotFound)
+ {
+ return EFalse;
+ }
+
+ return ETrue;
+ }
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm1Helper::FilterDataFieldsL()
+// Constructs a bit pattern using the required/supported data fields
+// For example, 6, 4 and 27 are supported fields <-- 00000111
+// 6 and 4 are required fields <-- 00000011
+// Bit pattern returned is 00000011.
+// ----------------------------------------------------------------------------
+TUint8 CPcsAlgorithm2Utils::FilterDataFieldsL(const RArray<TInt>& aRequiredDataFields,
+ const RArray<TInt>& aSupportedDataFields)
+{
+ TUint8 filteredMatch = 0x0;
+ const TInt supportedDataFieldsCount = aSupportedDataFields.Count();
+ const TInt requiredDataFieldsCount = aRequiredDataFields.Count();
+ for ( TInt i = 0; i < supportedDataFieldsCount; i++ )
+ {
+ for ( TInt j = 0; j < requiredDataFieldsCount; j++ )
+ {
+ if ( aSupportedDataFields[i] == aRequiredDataFields[j] )
+ {
+ TUint8 val = 1 << i;
+ filteredMatch |= val;
+ }
+ }
+ }
+
+ return filteredMatch;
+}
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2Utils::AppendMatchToSeqL
+// ----------------------------------------------------------------------------
+void CPcsAlgorithm2Utils::AppendMatchToSeqL(
+ RPointerArray<TDesC>& aMatchSeq, const TDesC& aMatch )
+ {
+ HBufC* seq = aMatch.AllocLC();
+ seq->Des().UpperCase();
+ TIdentityRelation<TDesC> rule(CompareExact);
+ if ( aMatchSeq.Find(seq, rule) == KErrNotFound )
+ {
+ aMatchSeq.AppendL(seq);
+ CleanupStack::Pop( seq );
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy( seq );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2Utils::MatchesOverlap
+// Check if two match location items have overlapping indices.
+// ----------------------------------------------------------------------------
+TBool CPcsAlgorithm2Utils::MatchesOverlap( const TPsMatchLocation& aFirst,
+ const TPsMatchLocation& aSecond )
+ {
+ TBool overlap = EFalse;
+
+ if ( aFirst.index == aSecond.index )
+ {
+ overlap = ETrue;
+ }
+ else
+ {
+ // give arguments alias names where first begins before the second
+ TInt firstPos( aFirst.index );
+ TInt firstLen( aFirst.length );
+ TInt secondPos( aSecond.index );
+ if ( firstPos > secondPos )
+ {
+ firstPos = aSecond.index;
+ firstLen = aSecond.length;
+ secondPos = aFirst.index;
+ }
+
+ // there is an overlap if the end of the first comes after
+ // beginning of the second
+ if ( firstPos + firstLen > secondPos )
+ {
+ overlap = ETrue;
+ }
+ }
+
+ return overlap;
+ }
+
+// End of File
+