--- a/predictivesearch/PcsAlgorithm/Algorithm2/src/CPcsAlgorithm2Utils.cpp Wed Sep 15 11:56:55 2010 +0300
+++ b/predictivesearch/PcsAlgorithm/Algorithm2/src/CPcsAlgorithm2Utils.cpp Wed Oct 13 14:15:33 2010 +0300
@@ -18,7 +18,6 @@
// INCLUDES
#include "CPcsAlgorithm2Utils.h"
#include "CPsData.h"
-#include "CPsQuery.h"
#include "CPcsDefs.h"
#include "CPcsCache.h"
#include <collate.h>
@@ -34,15 +33,16 @@
// 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)
+ RPointerArray<CPsData>& SearchResults)
{
+ CleanupClosePushL( SearchResults );
+
TInt maxIndex = 0;
TInt maxValue = aSearchResultsArr[maxIndex]->Count();
- TLinearOrder<CPsData> rule(CPcsAlgorithm2Utils::CompareDataBySortOrderL);
+ TLinearOrder<CPsData> rule(CPcsAlgorithm2Utils::CompareDataBySortOrder);
// Find the largest array in aSearchResultsArr
- const TInt searchResultsArrCount = aSearchResultsArr.Count();
- for (TInt i = 1; i < searchResultsArrCount; i++)
+ for (TInt i = 1; i < aSearchResultsArr.Count(); i++)
{
if (aSearchResultsArr[i]->Count() > maxValue)
{
@@ -52,15 +52,13 @@
}
// Assign the largets array to searchresults
- const TInt cnt = aSearchResultsArr[maxIndex]->Count();
- for (TInt i = 0; i < cnt; i++)
+ for (TInt i = 0; i < aSearchResultsArr[maxIndex]->Count(); i++)
{
- aSearchResults.Append((*(aSearchResultsArr[maxIndex]))[i]);
+ SearchResults.Append((*(aSearchResultsArr[maxIndex]))[i]);
}
// Merge the remaining result arrays to the largest array in sequential order
-
- for (TInt i = 0; i < searchResultsArrCount; i++)
+ 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))
@@ -68,10 +66,11 @@
TInt numElements = (aSearchResultsArr[i])->Count();
for (TInt j = 0; j < numElements; j++)
{
- aSearchResults.InsertInOrderAllowRepeatsL((*(aSearchResultsArr[i]))[j], rule);
+ SearchResults.InsertInOrderAllowRepeatsL((*(aSearchResultsArr[i]))[j], rule);
}
}
}
+ CleanupStack::Pop();
}
// ----------------------------------------------------------------------------
@@ -99,149 +98,100 @@
}
// ----------------------------------------------------------------------------
-// CPcsAlgorithm2Utils::CompareDataBySortOrderL()
+// CPcsAlgorithm2Utils::CompareDataBySortOrder()
// TLinearOrder rule for comparison of data objects
// ----------------------------------------------------------------------------
-TInt CPcsAlgorithm2Utils::CompareDataBySortOrderL(const CPsData& aObject1,
- const CPsData& aObject2)
+TInt CPcsAlgorithm2Utils::CompareDataBySortOrder(const CPsData& aObject1,
+ const CPsData& aObject2)
{
- TInt compareRes = 0;
-
- if( CPsData::CompareById(aObject1, aObject2) )
- {
- return compareRes;
- }
+ _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());
- User::LeaveIfNull(pcsCache);
+ PTR* pcsCache = static_cast<PTR*> (Dll::Tls());
- CPcsCache* cache1 = (*pcsCache)[aObject1.UriId()];
- CPcsCache* cache2 = (*pcsCache)[aObject2.UriId()];
- RArray<TInt> indexOrder1;
- RArray<TInt> indexOrder2;
+ // 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
- cache1->GetIndexOrder(indexOrder1);
- CleanupClosePushL(indexOrder1);
- cache2->GetIndexOrder(indexOrder2);
- CleanupClosePushL(indexOrder2);
+ cache->GetIndexOrder(indexOrder);
- // Check if Sort Order is identical (it must be for same cache)
- TBool sameIndexOrder = ETrue;
- if ( indexOrder1.Count() != indexOrder2.Count() )
+ // Append sort order elements first
+ for (int i = 0; i < indexOrder.Count(); i++)
{
- sameIndexOrder = EFalse;
- }
- else
- {
- for ( TInt i = 0; i < indexOrder1.Count(); i++ )
+ TInt index = indexOrder[i];
+ if (index < aObject1.DataElementCount() && aObject1.Data(index))
{
- if (indexOrder1[i] != indexOrder2[i])
- {
- sameIndexOrder = EFalse;
- break;
- }
+ // 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;
}
}
- // Sort Orders among diffent caches should be the same, anyway
- // if caches and SO are different we compare by cache URI index
- if (!sameIndexOrder)
- {
- compareRes = aObject1.UriId() - aObject2.UriId();
-
- CleanupStack::PopAndDestroy(&indexOrder2);
- CleanupStack::PopAndDestroy(&indexOrder1);
- return compareRes;
- }
+ /* --- 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;
+ }
+ }
+ */
- // The comparison between contacts data is done for the sort order
- // fields skipping the ones that are empty
- TInt indexCount = indexOrder1.Count();
- TInt idx1 = 0;
- TInt idx2 = 0;
- while ( compareRes == 0 && idx1 < indexCount && idx2 < indexCount )
+ // 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);
+
+ // Append sort order elements first
+ for (int i = 0; i < indexOrder.Count(); i++)
{
- // Get contact field of 1st contact
- TInt object1Idx = indexOrder1[idx1];
- HBufC* strCompare1 = aObject1.Data(object1Idx)->Des().AllocLC();
- TPtr strCompare1Ptr( strCompare1->Des() );
- CPcsAlgorithm2Utils::MyTrim( strCompare1Ptr );
-
- // Get contact field of 2nd contact
- TInt object2Idx = indexOrder2[idx2];
- HBufC* strCompare2 = aObject2.Data(object2Idx)->Des().AllocLC();
- TPtr strCompare2Ptr( strCompare2->Des() );
- CPcsAlgorithm2Utils::MyTrim( strCompare2Ptr );
-
- if ( strCompare1->Length() > 0 && strCompare2->Length() > 0 )
+ TInt index = indexOrder[i];
+ if (index < aObject2.DataElementCount() && aObject2.Data(index))
{
- compareRes = CPcsAlgorithm2Utils::MyCompareC(*strCompare1, *strCompare2);
- idx1++;
- idx2++;
- }
- else // Increment only the index of the contact with empty field
- {
- if ( strCompare1->Length() == 0 )
- idx1++;
- if ( strCompare2->Length() == 0 )
- idx2++;
- }
-
- CleanupStack::PopAndDestroy(strCompare2);
- CleanupStack::PopAndDestroy(strCompare1);
- }
+ // Trim the unnecessary white spaces/special chars before we compare
+ TBuf<255> str(KNullDesC);
- // We do not return that contacts are equal by SO
- if ( compareRes == 0 )
- {
- if ( idx1 != idx2 )
- {
- // Compare by index position
- // If idx1 > idx2 and SO is "FN LN" it means for instance that:
- // Contact1=[FN:"", LN:"Smith"], idx1=2
- // Contact2=[FN:"Smith", LN:"Donald"], idx2=1
- // Therefore Contact1="Smith" is < than Contact2="Smith Donald"
- // and the return value of this method has to be < 0 (idx2-idx1)
+ str = aObject2.Data(index)->Des();
+ CPcsAlgorithm2Utils::MyTrim(str);
- compareRes = idx2 - idx1;
- }
- else
- {
- // Compare by URI ID as 1st choice and Contact ID as 2nd choice
-
- compareRes == ( aObject1.UriId() != aObject2.UriId() ) ?
- aObject1.UriId() - aObject2.UriId() : aObject1.Id() - aObject2.Id();
+ data2 += str;
+ data2 += KSpace;
}
}
- CleanupStack::PopAndDestroy(&indexOrder2);
- CleanupStack::PopAndDestroy(&indexOrder1);
-
- return compareRes;
- }
+ /* --- 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;
+ }
+ }
+ */
-// ----------------------------------------------------------------------------
-// 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());
+ indexOrder.Reset();
+ data1.TrimAll();
+ data2.TrimAll();
+ return (CPcsAlgorithm2Utils::MyCompareC(data1, data2));
}
// ----------------------------------------------------------------------------
@@ -283,90 +233,5 @@
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