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


// INCLUDE FILES
#include    "CCLFDbItemContainer.h"
#include    <mdeobject.h> 
#include    <f32file.h>
#include    "CLFPanics.h"

const TInt KCLFContainerArrayGranularity( 25 );

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

// -----------------------------------------------------------------------------
// CCLFContainerItem::CCLFContainerItem
// -----------------------------------------------------------------------------
//
CCLFContainerItem::CCLFContainerItem( const CMdEObject* aObject )
    : iReferenceCount( 0 ), iMdEObject( aObject ), iDeprecated( EFalse ),
      iItemId( aObject->Id() )
    {
    }

// -----------------------------------------------------------------------------
// CCLFContainerItem::CCLFContainerItem
// -----------------------------------------------------------------------------
//
CCLFContainerItem::CCLFContainerItem()
    : iReferenceCount( 0 ), iMdEObject( NULL ), iDeprecated( EFalse ),
      iItemId( 0 )
	{
	}

// -----------------------------------------------------------------------------
// CCLFContainerItem::NewLC
// -----------------------------------------------------------------------------
//
CCLFContainerItem* CCLFContainerItem::NewLC( const CMdEObject* aObject )
    {
    CCLFContainerItem* self = new ( ELeave ) CCLFContainerItem( aObject );
    CleanupStack::PushL( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CCLFContainerItem::~CCLFContainerItem
// Destructor
// -----------------------------------------------------------------------------
//
CCLFContainerItem::~CCLFContainerItem()
    {
    delete iMdEObject;
    }

// -----------------------------------------------------------------------------
// CCLFContainerItem::Compare
// -----------------------------------------------------------------------------
//
TInt CCLFContainerItem::Compare( const CCLFContainerItem& aFirst,
					             const CCLFContainerItem& aSecond )
	{
	return aFirst.iItemId - aSecond.iItemId;
	}

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::TFindHelper::TFindHelper
// -----------------------------------------------------------------------------
//
CCLFDbItemContainer::TFindHelper::TFindHelper()
    : iItemId( 0 ), 
      iIndex( 0 )
    {
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::TFindHelper::Reset
// -----------------------------------------------------------------------------
//
void CCLFDbItemContainer::TFindHelper::Reset()
    {
    iItemId = 0;
    iIndex = 0;
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::TFindHelper::Set
// -----------------------------------------------------------------------------
//
void CCLFDbItemContainer::TFindHelper::Set( TCLFItemId aItemId, 
                                                   TInt aIndex )
    {
    iItemId = aItemId;
    iIndex = aIndex;
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::CCLFDbItemContainer
// -----------------------------------------------------------------------------
//
CCLFDbItemContainer::CCLFDbItemContainer()
    : iItemArray( KCLFContainerArrayGranularity ),
      iArraySorter( CCLFContainerItem::Compare )
    {
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::NewL
// -----------------------------------------------------------------------------
//
CCLFDbItemContainer* CCLFDbItemContainer::NewL()
    {
    return new( ELeave ) CCLFDbItemContainer;
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::~CCLFDbItemContainer
// Destructor
// -----------------------------------------------------------------------------
//
CCLFDbItemContainer::~CCLFDbItemContainer()
    {
    iItemArray.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::ItemById
// -----------------------------------------------------------------------------
//
CCLFContainerItem* CCLFDbItemContainer::ItemById( const TCLFItemId aItemId ) const
    {
    CCLFContainerItem* item = NULL;
    TInt index( FindItem( aItemId, item ) );
    while ( index >= 0 )
        {
		if( !( item->iDeprecated ) )
			{
			return item;
			}
        index = NextItem( item );
        }
    return NULL;
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::ReleaseItem
// -----------------------------------------------------------------------------
//
void CCLFDbItemContainer::ReleaseItem( CCLFContainerItem* aItem )
    {
    const TInt index( iItemArray.Find( aItem ) );
    if ( index >= 0 )
        {
        aItem->iReferenceCount--;
        __ASSERT_DEBUG ( aItem->iReferenceCount >= 0,
                         User::Panic( KCLFPanicText, ECLFNullPointer ) );
        if ( aItem->iReferenceCount <= 0 )
            {
            iItemArray.Remove( index );
            delete aItem;
            aItem = NULL;
            }
        }
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::SetDeprecatedItems
// -----------------------------------------------------------------------------
//
void CCLFDbItemContainer::SetDeprecatedItems(
                                    const RArray<TCLFItemId>& aItemIdArray )
    {
    const TInt count( aItemIdArray.Count() );
    for ( TInt i = 0 ; i < count ; ++i )
        {
        CCLFContainerItem* item = NULL;
        TInt index( FindItem( aItemIdArray[i], item ) );
        while ( index >= 0 )
            {
            item->iDeprecated = ETrue;
            index = NextItem( item );
            }
        }
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::FindItem
// -----------------------------------------------------------------------------
//
TInt CCLFDbItemContainer::FindItem( TCLFItemId aItemId, 
                                    CCLFContainerItem*& aItem ) const
    {
    iFindHelper.Reset();
	iFindItem.SetItemId( aItemId );
    const TInt index ( iItemArray.SpecificFindInOrder( 
                                        &iFindItem, 
                                        iArraySorter, 
                                        EArrayFindMode_First ) );
	if ( index >= 0 )
		{
    	iFindHelper.Set( aItemId, index );
		aItem = iItemArray[index];
		return index;
		}
    return KErrNotFound;
    
    }

// -----------------------------------------------------------------------------
// CCLFDbItemContainer::NextItem
// -----------------------------------------------------------------------------
//
TInt CCLFDbItemContainer::NextItem( CCLFContainerItem*& aItem ) const
    {
    const TInt count( iItemArray.Count() );
    if ( iFindHelper.iIndex < count )
        {
        CCLFContainerItem* item = iItemArray[ iFindHelper.iIndex ];
        if ( iFindHelper.iItemId == item->iItemId )
            {
            iFindHelper.iIndex++;
            aItem = item;
            return iFindHelper.iIndex - 1;
            }
        }
    return KErrNotFound;
    }

//  End of File