/*

* Copyright (c) 2002 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: 

*    vCard data field <-> UID mapping class.

*

*/

// INCLUDE FILES

#include "CBCardFieldUidMapping.h"

#include <barsread.h>

// MODULE DATA STRUCTURES

struct CBCardFieldUidMapping::TMappingImpl

    {

    // Data

    const TDesC8* iName;

    TInt iFieldIndex;

    TUid iUid;

    /// Default constructor

    TMappingImpl();

    /// Conversion constructor from TVcardField

    TMappingImpl(const TVcardField& aVcardField);

    /**

     * Converts this object to a CBCardFieldUidMapping::TMapping.

     */

    operator CBCardFieldUidMapping::TMapping() const;

    // Array operations

    static TInt CompareName(const TMappingImpl& aLhs, const TMappingImpl& aRhs);

    static TInt CompareIndex(const TMappingImpl& aLhs, const TMappingImpl& aRhs);

    static TInt CompareNameAndIndex(const TMappingImpl& aLhs, const TMappingImpl& aRhs);

    };

// ==================== MEMBER FUNCTIONS ====================

inline CBCardFieldUidMapping::TMappingImpl::TMappingImpl()

    {

    // No need to init anything

    }

inline CBCardFieldUidMapping::TMappingImpl::TMappingImpl

        (const TVcardField& aVcardField) :

    iName(&aVcardField.iName), 

    iFieldIndex(aVcardField.iFieldIndex)

    {

    }

inline CBCardFieldUidMapping::TMappingImpl::operator CBCardFieldUidMapping::TMapping() const

    {

    TMapping result;

    result.iVcardField.iName.Set(*iName);

    result.iVcardField.iFieldIndex = iFieldIndex;

    result.iUid = iUid;

    return result;

    }

inline TInt CBCardFieldUidMapping::TMappingImpl::CompareName

        (const TMappingImpl& aLhs, const TMappingImpl& aRhs)

    {

    return (aLhs.iName->CompareF(*aRhs.iName));

    }

inline TInt CBCardFieldUidMapping::TMappingImpl::CompareIndex

        (const TMappingImpl& aLhs, const TMappingImpl& aRhs)

    {

    return (aLhs.iFieldIndex - aRhs.iFieldIndex);

    }

TInt CBCardFieldUidMapping::TMappingImpl::CompareNameAndIndex

        (const TMappingImpl& aLhs, const TMappingImpl& aRhs)

    {

    TInt result = CompareName(aLhs,aRhs);

    if (result == 0)

        {

        // If names are equal compare indexes

        result = CompareIndex(aLhs,aRhs);

        }

    return result;

    }

inline CBCardFieldUidMapping::CBCardFieldUidMapping()

    {

    }

inline void CBCardFieldUidMapping::ConstructL

        (TResourceReader& aReader)

    {

    // Read the array

    TInt count = aReader.ReadInt16();

    while (--count >= 0)

        {

        HBufC* name16 = aReader.ReadHBufCL();

        CleanupStack::PushL(name16);

        HBufC8* name = HBufC8::NewLC(name16->Length());

        TPtr8 namePtr = name->Des();

        namePtr.Copy(*name16);

        TMappingImpl newMapping;

        newMapping.iName  = name;

        newMapping.iFieldIndex = aReader.ReadInt32();

        newMapping.iUid   = TUid::Uid(aReader.ReadInt32());

        User::LeaveIfError(iMappings.Append(newMapping));

        CleanupStack::Pop(name);

        CleanupStack::PopAndDestroy(name16);

        }

    // Sort the array by (name,index)

    iMappings.Sort(TLinearOrder<TMappingImpl>(TMappingImpl::CompareNameAndIndex));

    }

CBCardFieldUidMapping* CBCardFieldUidMapping::NewL(TResourceReader& aReader)

    {

    CBCardFieldUidMapping* self = new(ELeave) CBCardFieldUidMapping;

    CleanupStack::PushL(self);

    self->ConstructL(aReader);

    CleanupStack::Pop(self);

    return self;

    }

CBCardFieldUidMapping::~CBCardFieldUidMapping()

    {

    for (TInt i=iMappings.Count()-1; i >= 0; --i)

        {

        // The cast below is safe, see ConstructL()

        delete ((HBufC8*)(iMappings[i].iName));

        }

    iMappings.Close();

    }

TInt CBCardFieldUidMapping::Count() const

    {

    return iMappings.Count();

    }

CBCardFieldUidMapping::TMapping CBCardFieldUidMapping::operator[]

        (TInt aIndex) const

    {

    return iMappings[aIndex];

    }

TInt CBCardFieldUidMapping::Find

        (const TVcardField& aVcardField) const

    {

    TMappingImpl fieldToFind(aVcardField);

    return iMappings.FindInOrder

        (fieldToFind, 

        TLinearOrder<TMappingImpl>(TMappingImpl::CompareNameAndIndex));

    }

TInt CBCardFieldUidMapping::Find

        (const TUid& aUid) const

    {

    // Inline find loop instead of RArray::Find for speed

    const TInt count = iMappings.Count();

    for (TInt i=0; i < count; ++i)

        {

        if (iMappings[i].iUid == aUid)

            {

            return i;

            }

        }

    return KErrNotFound;

    }

TPtrC8 CBCardFieldUidMapping::FindName

        (const TUid& aUid) const

    {

    TPtrC8 result;

    const TInt index = Find(aUid);

    if (index != KErrNotFound)

        {

        result.Set(*iMappings[index].iName);

        }

    return result;

    }

TInt CBCardFieldUidMapping::FindIndex

        (const TUid& aUid) const

    {

    TInt index = Find(aUid);

    if (index == KErrNotFound)

        {

        return KErrNotFound;

        }

    else

        {

        return iMappings[index].iFieldIndex;

        }

    }

// End of File