/*

* 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