/*

* Copyright (c) 2005 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:  Container of one attribute list item.

*

*/

// INCLUDE FILES

#include "CPEngAttributeListItem.h"

#include "PEngListLibraryPanics.h"

#include <e32std.h>

#include <s32strm.h>

//Default granurality for attribute list element members

const TInt KAttributeListElementGranurality = 3;

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

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::CPEngAttributeListItem

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CPEngAttributeListItem::CPEngAttributeListItem()

        : iCurrentlyDefault( EFalse ),

        iNewDefault( EFalse ),

        iListOfAttributes( KAttributeListElementGranurality ),

        iListOfContactLists( KAttributeListElementGranurality ),

        iListOfNewContactLists( KAttributeListElementGranurality ),

        iListOfContactIDs( KAttributeListElementGranurality ),

        iListOfNewContactIDs( KAttributeListElementGranurality ),

        // calculated initial size for store, 8*4

        iSizeOfEntry( 32 )

    {

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::ConstructL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::ConstructL( const RArray<TUint32>& aAttributes )

    {

    // copy attributes

    TInt count ( aAttributes.Count() );

    for ( TInt x ( 0 ) ; x < count ; x++ )

        {

        // we can use append since passed array is already in order

        iListOfAttributes.AppendL( aAttributes[x] );

        }

    iSizeOfEntry += count * 4; // 4 bytes for each attribute ID

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::ConstructL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::ConstructL(

    const CPEngAttributeListItem& aAttributeList  )

    {

    iCurrentlyDefault = aAttributeList.CurrentlyDefault();

    iNewDefault = aAttributeList.NewDefault();

    CopyTIntArrayL( iListOfAttributes, aAttributeList.PresenceAttributes() );

    CopyDesArrayL( iListOfContactLists, aAttributeList.ArrayOfContacts( ECurrentContactLists ) );

    CopyDesArrayL( iListOfNewContactLists, aAttributeList.ArrayOfContacts( ENewContactLists ) );

    CopyDesArrayL( iListOfContactIDs, aAttributeList.ArrayOfContacts( ECurrentContactIDs ) );

    CopyDesArrayL( iListOfNewContactIDs, aAttributeList.ArrayOfContacts( ENewContactIDs ) );

    iSizeOfEntry = aAttributeList.SizeOfEntry();

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::NewL()

// -----------------------------------------------------------------------------

//

CPEngAttributeListItem* CPEngAttributeListItem::NewL( RReadStream& aStream )

    {

    CPEngAttributeListItem* self = NewLC( aStream );

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::NewLC()

// -----------------------------------------------------------------------------

//

CPEngAttributeListItem* CPEngAttributeListItem::NewLC(

    RReadStream& aStream )

    {

    CPEngAttributeListItem* self = new( ELeave ) CPEngAttributeListItem;

    CleanupStack::PushL( self );

    self->InternalizeL( aStream );

    return self;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::NewL()

// -----------------------------------------------------------------------------

//

CPEngAttributeListItem* CPEngAttributeListItem::NewL(

    const RArray<TUint32>& aAttributes )

    {

    CPEngAttributeListItem* self = NewLC( aAttributes );

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::NewLC()

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CPEngAttributeListItem* CPEngAttributeListItem::NewLC(

    const RArray<TUint32>& aAttributes )

    {

    CPEngAttributeListItem* self = new( ELeave ) CPEngAttributeListItem;

    CleanupStack::PushL( self );

    self->ConstructL( aAttributes );

    return self;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::NewL()

// -----------------------------------------------------------------------------

//

CPEngAttributeListItem* CPEngAttributeListItem::NewL(

    const CPEngAttributeListItem& aAttributeList )

    {

    CPEngAttributeListItem* self = new( ELeave ) CPEngAttributeListItem;

    CleanupStack::PushL( self );

    self->ConstructL( aAttributeList );

    CleanupStack::Pop();

    return self;

    }

//   Destructor

CPEngAttributeListItem::~CPEngAttributeListItem()

    {

    iListOfAttributes.Reset();

    iListOfContactLists.Reset();

    iListOfNewContactLists.Reset();

    iListOfContactIDs.Reset();

    iListOfNewContactIDs.Reset();

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::AddContactToListL()

// -----------------------------------------------------------------------------

//

TInt CPEngAttributeListItem::AddContactToListL( const TDesC& aContact,

                                                TPEngAttrListItemArrays aArray )

    {

    CDesCArray& array = Array( aArray );

    TInt err( array.InsertIsqL( aContact, ECmpFolded ) );

    iSizeOfEntry += aContact.Size();

    return err;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::DeleteContactFromList()

// -----------------------------------------------------------------------------

//

TInt CPEngAttributeListItem::DeleteContactFromList( const TDesC& aContact,

                                                    TPEngAttrListItemArrays aArray )

    {

    CDesCArray& array = Array( aArray );

    TInt err ( DeleteItemFromArray( array, aContact ) );

    if ( err != KErrNone )

        {

        return err;

        }

    return ContactsCount();

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::ArrayOfContacts()

// -----------------------------------------------------------------------------

//

const CDesCArray& CPEngAttributeListItem::ArrayOfContacts(

    TPEngAttrListItemArrays aArray ) const

    {

    // this cast is here to reuse defined function,

    //it will return anyway const reference

    return  const_cast<CPEngAttributeListItem*>( this )->Array( aArray );

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::PresenceAttributes()

// -----------------------------------------------------------------------------

//

const RArray<TUint32>& CPEngAttributeListItem::PresenceAttributes() const

    {

    return iListOfAttributes;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::UpdatePresenceAttributesL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::UpdatePresenceAttributesL(

    const RArray<TUint32>& aNewPresenceAttributes )

    {

    // 4 bytes each attribute

    iSizeOfEntry -= 4 * iListOfAttributes.Count();

    iListOfAttributes.Reset();

    TInt count( aNewPresenceAttributes.Count() );

    for ( TInt x( 0 ) ; x < count ; x++ )

        {

        User::LeaveIfError( iListOfAttributes.InsertInSignedKeyOrder( aNewPresenceAttributes[ x ] ) );

        }

    // 4 bytes each attribute

    iSizeOfEntry += 4 * iListOfAttributes.Count();

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::CommitContactListL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::CommitContactListL( const TDesC& aContact )

    {

    CommitContactL( iListOfContactLists, iListOfNewContactLists, aContact );

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::CommitContactIdL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::CommitContactIdL( const TDesC& aContact )

    {

    CommitContactL( iListOfContactIDs, iListOfNewContactIDs, aContact );

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::CurrentlyDefault()

// -----------------------------------------------------------------------------

//

TBool CPEngAttributeListItem::CurrentlyDefault() const

    {

    return iCurrentlyDefault;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::NewDefault()

// -----------------------------------------------------------------------------

//

TBool CPEngAttributeListItem::NewDefault() const

    {

    return iNewDefault;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::SetNewDefault()

// -----------------------------------------------------------------------------

//

TInt CPEngAttributeListItem::SetNewDefault( TBool aNewDefault )

    {

    iNewDefault = aNewDefault;

    return ContactsCount();

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::CommitDefault()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::CommitDefault()

    {

    // was it suppose to be new default

    iCurrentlyDefault = iNewDefault;

    iNewDefault =  EFalse;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::Synchronized()

// -----------------------------------------------------------------------------

//

TBool CPEngAttributeListItem::Synchronized() const

    {

    return iSynchronized;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::SetSynchronization()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::SetSynchronization( TBool aSync )

    {

    iSynchronized = aSync;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::ExternalizeL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::ExternalizeL( RWriteStream& aStream )

    {

    aStream.WriteInt32L( iCurrentlyDefault );

    aStream.WriteInt32L( iNewDefault );

    aStream.WriteInt32L( iSynchronized );

    TInt count ( iListOfAttributes.Count() );

    aStream.WriteInt32L( count );

    for ( TInt x ( 0 ) ; x < count ; x++ )

        {

        aStream.WriteInt32L( iListOfAttributes[x] );

        }

    ExternalizeDesArrayToStreamL( iListOfContactLists, aStream );

    ExternalizeDesArrayToStreamL( iListOfContactIDs, aStream );

    ExternalizeDesArrayToStreamL( iListOfNewContactLists, aStream );

    ExternalizeDesArrayToStreamL( iListOfNewContactIDs, aStream );

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::InternalizeL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::InternalizeL( RReadStream& aStream )

    {

    iCurrentlyDefault = aStream.ReadInt32L();

    iNewDefault = aStream.ReadInt32L();

    iSynchronized = aStream.ReadInt32L();

    iSizeOfEntry = 12; // already those 3 flags readed before

    TInt count ( aStream.ReadInt32L() );

    for ( TInt x ( 0 ) ; x < count ; x++ )

        {

        iListOfAttributes.AppendL( aStream.ReadInt32L() );

        }

    iSizeOfEntry += 4 * ( 1 + count );

    iSizeOfEntry += InternalizeDesArrayFromStreamL( iListOfContactLists,

                                                    aStream );

    iSizeOfEntry += InternalizeDesArrayFromStreamL( iListOfContactIDs,

                                                    aStream );

    iSizeOfEntry += InternalizeDesArrayFromStreamL( iListOfNewContactLists,

                                                    aStream );

    iSizeOfEntry += InternalizeDesArrayFromStreamL( iListOfNewContactIDs,

                                                    aStream );

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::SizeOfEntry()

// -----------------------------------------------------------------------------

//

TInt CPEngAttributeListItem::SizeOfEntry() const

    {

    return iSizeOfEntry;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::ContactsCount()

// -----------------------------------------------------------------------------

//

TInt CPEngAttributeListItem::ContactsCount() const

    {

    // Returns number of contact which are attached to the attribute list

    // If attribute list is set as default, it is considered like another

    // contact would be attached to the attribute list

    TInt count = iListOfContactLists.Count() +

                 iListOfNewContactLists.Count() +

                 iListOfContactIDs.Count() +

                 iListOfNewContactIDs.Count() +

                 iCurrentlyDefault +

                 iNewDefault;

    return count;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::Array()

// -----------------------------------------------------------------------------

//

CDesCArray& CPEngAttributeListItem::Array( TPEngAttrListItemArrays aArray )

    {

    switch ( aArray )

        {

        case ENewContactLists:

            {

            return iListOfNewContactLists;

            }

        case ENewContactIDs:

            {

            return iListOfNewContactIDs;

            }

        case ECurrentContactLists:

            {

            return iListOfContactLists;

            }

        case ECurrentContactIDs:

            {

            return iListOfContactIDs;

            }

        default:

            {

            // by default work with list of new contact lists

            return iListOfNewContactLists;

            }

        }

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::CommitContactL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::CommitContactL( CDesCArray& aCurrentArray,

                                             CDesCArray& aNewArray,

                                             const TDesC& aContact )

    {

    // Try to find item from New list, if it is find update Current

    // contact list

    TInt position( 0 );

    if ( KErrNone == aNewArray.FindIsq( aContact, position, ECmpFolded ) )

        {

        // it was found in new, add it to the current one

        // trap, since it can leave it is already in list

        TRAPD( err, aCurrentArray.InsertIsqL( aContact, ECmpFolded ) );

        if ( err == KErrNoMemory ) // if it was no memory leave again

            {

            User::Leave( KErrNoMemory );

            }

        // now remove it from the new contacts

        aNewArray.Delete( position );

        // size does not change here since it was added and removed

        return;

        }

    // it was not found in the new contacts, so try to delete it from current

    // if it does not exist, just then it is just fine, ignore it

    DeleteItemFromArray( aCurrentArray, aContact );

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::DeleteItemFromArray()

// -----------------------------------------------------------------------------

//

TInt CPEngAttributeListItem::DeleteItemFromArray( CDesCArray& aArray,

                                                  const TDesC& aItem )

    {

    TInt posToDelete( 0 );

    if ( KErrNone == aArray.FindIsq( aItem, posToDelete, ECmpFolded ) )

        {

        aArray.Delete( posToDelete );

        iSizeOfEntry -= aItem.Size();

        return KErrNone;

        }

    return KErrNotFound;

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::CopyDesArrayL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::CopyDesArrayL( CDesCArray& aArrayTarget,

                                            const CDesCArray& aArraySource )

    {

    TInt count ( aArraySource.Count() );

    for ( TInt x ( 0 ) ; x < count ; x++ )

        {

        aArrayTarget.AppendL( aArraySource.MdcaPoint( x ) );

        }

    }

// -----------------------------------------------------------------------------

// CPEngAttributeListItem::CopyTIntArrayL()

// -----------------------------------------------------------------------------

//

void CPEngAttributeListItem::CopyTIntArrayL( RArray<TUint32>& aArrayTarget,