diff -r f5050f1da672 -r 04becd199f91 javaextensions/pim/framework/src.s60/cpimitemmatcher.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javaextensions/pim/framework/src.s60/cpimitemmatcher.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,321 @@
+/*
+* Copyright (c) 2008 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:  An item matcher.
+ *
+*/
+
+
+// INCLUDE FILES
+#include  "cpimitemmatcher.h"
+#include  "mpimadaptermanager.h"
+#include  "cpimvalidator.h"
+#include  "cpimitem.h"
+#include  "pimpanics.h"
+#include "logger.h"
+
+CPIMItemMatcher::CPIMItemMatcher(const CPIMValidator& aValidator,
+                                 MPIMAdapterManager& aAdapterManager, const CPIMItem& aMatchingItem) :
+        iValidator(aValidator), // not owned
+        iAdapterManager(aAdapterManager), // not owned
+        iMatchingItem(aMatchingItem) // not owned
+{
+    JELOG2(EPim);
+}
+
+void CPIMItemMatcher::ConstructL()
+{
+    JELOG2(EPim);
+    iMatchingFields = iMatchingItem.GetFieldsL();
+}
+
+CPIMItemMatcher* CPIMItemMatcher::NewLC(const CPIMValidator& aValidator,
+                                        MPIMAdapterManager& aAdapterManager, const CPIMItem& aMatchingItem)
+{
+    JELOG2(EPim);
+    CPIMItemMatcher* self =
+        new(ELeave) CPIMItemMatcher(aValidator, aAdapterManager, aMatchingItem);
+
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    return self;
+}
+
+CPIMItemMatcher::~CPIMItemMatcher()
+{
+    JELOG2(EPim);
+    delete iMatchingFields;
+}
+
+TBool CPIMItemMatcher::MatchL(const CPIMItem& aTestedItem)
+{
+    JELOG2(EPim);
+    const TInt n = iMatchingFields->Count();
+    for (TInt i = 0; i < n; i++)
+    {
+        const TPIMField matchingField = (*iMatchingFields)[i];
+
+        if (!MatchAllMatchingValuesL(matchingField, aTestedItem))
+        {
+            return EFalse;
+        }
+    }
+
+    return ETrue;
+}
+
+TBool CPIMItemMatcher::MatchAllMatchingValuesL(TPIMField aMatchingField,
+        const CPIMItem& aTestedItem)
+{
+    JELOG2(EPim);
+    const TInt n = iMatchingItem.CountValuesL(aMatchingField);
+    for (TInt i = 0; i < n; i++)
+    {
+        if (!FindAnyTestedValueL(aMatchingField, i, // _matching_ value index
+                                 aTestedItem))
+        {
+            return EFalse;
+        }
+    }
+
+    return ETrue;
+}
+
+TBool CPIMItemMatcher::FindAnyTestedValueL(TPIMField aMatchingField,
+        TInt aMatchingValueIndex, const CPIMItem& aTestedItem)
+{
+    JELOG2(EPim);
+    const TInt n = aTestedItem.CountValuesL(aMatchingField);
+    for (TInt i = 0; i < n; i++)
+    {
+        if (MatchValueAndAttributesL(aMatchingField, aMatchingValueIndex,
+                                     aTestedItem, i))
+        {
+            return ETrue;
+        }
+    }
+
+    return EFalse;
+}
+
+TBool CPIMItemMatcher::MatchValueAndAttributesL(TPIMField aMatchingField,
+        TInt aMatchingValueIndex, const CPIMItem& aTestedItem,
+        TInt aTestedValueIndex)
+{
+    JELOG2(EPim);
+    // Check attributes first
+    if (!MatchAttributesL(aMatchingField, aMatchingValueIndex, aTestedItem,
+                          aTestedValueIndex))
+    {
+        return EFalse;
+    }
+
+    TBool valueMatches = EFalse;
+
+    TPIMFieldDataType matchingFieldDataType = iValidator.FieldDataType(
+                aMatchingField);
+
+    switch (matchingFieldDataType)
+    {
+    case EPIMFieldBoolean:
+    {
+        valueMatches = MatchBooleanL(aMatchingField, aMatchingValueIndex,
+                                     aTestedItem, aTestedValueIndex);
+        break;
+    }
+
+    case EPIMFieldDate:
+    {
+        valueMatches = MatchDateL(aMatchingField, aMatchingValueIndex,
+                                  aTestedItem, aTestedValueIndex);
+        break;
+    }
+
+    case EPIMFieldInt:
+    {
+        valueMatches = MatchIntL(aMatchingField, aMatchingValueIndex,
+                                 aTestedItem, aTestedValueIndex);
+        break;
+    }
+
+    case EPIMFieldBinary:
+    {
+        valueMatches = MatchBinaryL(aMatchingField, aMatchingValueIndex,
+                                    aTestedItem, aTestedValueIndex);
+        break;
+    }
+
+    case EPIMFieldString:
+    {
+        valueMatches = MatchStringL(aMatchingField, aMatchingValueIndex,
+                                    aTestedItem, aTestedValueIndex);
+        break;
+    }
+
+    case EPIMFieldStringArray:
+    {
+        valueMatches = MatchStringArrayL(aMatchingField, aMatchingValueIndex,
+                                         aTestedItem, aTestedValueIndex);
+        break;
+    }
+
+    default:
+    {
+        // We should never end up here
+        __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory,
+                                           EPIMPanicInvalidFieldType));
+    }
+    }
+
+    return valueMatches;
+}
+
+TBool CPIMItemMatcher::MatchAttributesL(TPIMField aMatchingField,
+                                        TInt aMatchingValueIndex, const CPIMItem& aTestedItem,
+                                        TInt aTestedValueIndex)
+{
+    JELOG2(EPim);
+    // Get the attributes for the matching value.
+    TPIMAttribute matchingAttributes = iMatchingItem.getAttributes(
+                                           aMatchingField, aMatchingValueIndex);
+
+    // Get rid of unsupported attributes.
+    matchingAttributes &= iAdapterManager. GetSupportedAttributesCombinedL(
+                              aMatchingField);
+
+    const TPIMAttribute testedAttributes = aTestedItem.getAttributes(
+                                               aMatchingField, aTestedValueIndex);
+
+    if ((testedAttributes & matchingAttributes) != matchingAttributes)
+    {
+        // Not all matching attributes were contained.
+        return EFalse;
+    }
+
+    return ETrue;
+}
+
+TBool CPIMItemMatcher::MatchBooleanL(TPIMField aMatchingField,
+                                     TInt aMatchingValueIndex, const CPIMItem& aTestedItem,
+                                     TInt aTestedValueIndex)
+{
+    JELOG2(EPim);
+    return iMatchingItem.GetBooleanL(aMatchingField, aMatchingValueIndex)
+           == aTestedItem.GetBooleanL(aMatchingField, aTestedValueIndex);
+}
+
+TBool CPIMItemMatcher::MatchDateL(TPIMField aMatchingField,
+                                  TInt aMatchingValueIndex, const CPIMItem& aTestedItem,
+                                  TInt aTestedValueIndex)
+{
+    JELOG2(EPim);
+    return iMatchingItem.GetDateL(aMatchingField, aMatchingValueIndex)
+           == aTestedItem.GetDateL(aMatchingField, aTestedValueIndex);
+}
+
+TBool CPIMItemMatcher::MatchIntL(TPIMField aMatchingField,
+                                 TInt aMatchingValueIndex, const CPIMItem& aTestedItem,
+                                 TInt aTestedValueIndex)
+{
+    JELOG2(EPim);
+    return iMatchingItem.getInt(aMatchingField, aMatchingValueIndex)
+           == aTestedItem.getInt(aMatchingField, aTestedValueIndex);
+}
+
+TBool CPIMItemMatcher::MatchBinaryL(TPIMField aMatchingField,
+                                    TInt aMatchingValueIndex, const CPIMItem& aTestedItem,
+                                    TInt aTestedValueIndex)
+{
+    JELOG2(EPim);
+    // Loop through the byte arrays
+    const CPIMByteArray& matchingByteArray = iMatchingItem.GetBinaryRawL(
+                aMatchingField, aMatchingValueIndex);
+
+    const CPIMByteArray& testedByteArray = aTestedItem.GetBinaryRawL(
+                                               aMatchingField, aTestedValueIndex);
+
+    const TInt n = matchingByteArray.Count();
+    if (testedByteArray.Count() != n)
+    {
+        return EFalse;
+    }
+
+    for (TInt i = 0; i < n; i++)
+    {
+        if (matchingByteArray[i] != testedByteArray[i])
+        {
+            return EFalse;
+        }
+    }
+
+    return ETrue;
+}
+
+TBool CPIMItemMatcher::MatchStringL(TPIMField aMatchingField,
+                                    TInt aMatchingValueIndex, const CPIMItem& aTestedItem,
+                                    TInt aTestedValueIndex)
+{
+    JELOG2(EPim);
+    // Match substring, case-insensitive
+
+    const TDesC& matchingString = iMatchingItem.GetStringL(aMatchingField,
+                                  aMatchingValueIndex);
+
+    const TDesC& testedString = aTestedItem.GetStringL(aMatchingField,
+                                aTestedValueIndex);
+
+    // Find substring, collated (case-insensitive and
+    // discarding punctuation)
+    if (testedString.FindC(matchingString) == KErrNotFound)
+    {
+        return EFalse;
+    }
+
+    return ETrue;
+}
+
+TBool CPIMItemMatcher::MatchStringArrayL(TPIMField aMatchingField,
+        TInt aMatchingValueIndex, const CPIMItem& aTestedItem,
+        TInt aTestedValueIndex)
+{
+    JELOG2(EPim);
+    // Match supported, present elements as
+    // string values
+    const CDesCArray& matchingArray = iMatchingItem.GetStringArrayL(
+                                          aMatchingField, aMatchingValueIndex);
+
+    const CDesCArray& testedArray = aTestedItem.GetStringArrayL(aMatchingField,
+                                    aTestedValueIndex);
+
+    const TInt n = matchingArray.Count();
+    for (TInt i = 0; i < n; i++)
+    {
+        const TPtrC& matchingElem = matchingArray[i];
+
+        if (matchingElem == KPIMNullArrayElement)
+        {
+            continue; // "null" element - next element
+        }
+
+        const TPtrC& testedElem = testedArray[i];
+
+        if (testedElem.FindC(matchingElem) == KErrNotFound)
+        {
+            return EFalse;
+        }
+    }
+
+    return ETrue;
+}
+
+//  End of File