/*
* Copyright (c) 2007 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:  Implementation of CCMObjectPool.
*
*/


#include "cmobjectpool.h"
#include "cmmanagerimpl.h"
#include <cmpluginbaseeng.h>
#include <cmpluginbase.h>
#include <cmconnectionmethoddef.h>

#include <e32def.h>
#include <e32std.h>


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
const TInt KDestGranularity     = 20;
const TInt KCMethodGranularity  = 20;
CCMObjectPool::CCMObjectPool(CCmManagerImpl& aCmManagerImpl) :
        iCmManagerImpl(aCmManagerImpl),    
        iDestinationArray(KDestGranularity, 
            _FOFF(TObjectPoolDestinationItem,iDestinationId)),
        iConnectionMethodArray(KCMethodGranularity, 
            _FOFF(TObjectPoolCMItem,iConnectionMethodId))
    {
    }

CCMObjectPool::~CCMObjectPool()
    {
    // The get and remove functions must be used in pairs
    // If the arrays have any element here than the client 
    // of this class made a programming error
    for (TInt index = 0; index < iDestinationArray.Count(); index++)
        {
        delete iDestinationArray[index].iDestinationItem;
        }    
    for (TInt index = 0; index < iConnectionMethodArray.Count(); index++)
        {
        delete iConnectionMethodArray[index].iConnectionMethodItem;
        }
    iDestinationArray.Close();
    iConnectionMethodArray.Close();
    }

CCMObjectPool::TObjectPoolDestinationItem::TObjectPoolDestinationItem(
                        CCmDestinationData*   aDestinationItem, 
                        TUint32               aDestinationId) : 
                            iDestinationId(aDestinationId),
                            iDestinationItem(aDestinationItem)
    {
    }
    
CCMObjectPool::TObjectPoolCMItem::TObjectPoolCMItem(
                        CCmPluginBaseEng* aConnectionMethodItem, 
                        TUint32           aConnectionMethodId) : 
                            iConnectionMethodId(aConnectionMethodId),
                            iConnectionMethodItem(aConnectionMethodItem)
    {
    }

CCmDestinationImpl* CCMObjectPool::GetDestinationL( TUint32 aDestinationId )
    {
    TUint32 destinationId( aDestinationId );
    if ( destinationId > 0 && destinationId < 255 )
        {
        destinationId += KCmDefaultDestinationAPTagId;
        }
    TObjectPoolDestinationItem findD( NULL, destinationId );
    TInt index = iDestinationArray.FindInUnsignedKeyOrder(findD);
    if (index == KErrNotFound)
        {
        // If the destinaton is not in the pool create it than return it.
        CCmDestinationImpl* dest = CCmDestinationImpl::NewL( iCmManagerImpl, 
                                                             destinationId );
        TObjectPoolDestinationItem aDest( 
            dest->GetData(),
            destinationId );
        User::LeaveIfError(
            iDestinationArray.InsertInUnsignedKeyOrder(aDest));
        dest->IncrementRefCounter();
        return dest;
        }
    else
        {
        // If the destination is allready in the pool than return it.
        CCmDestinationImpl* dest = CCmDestinationImpl::NewL( iCmManagerImpl, 
                                iDestinationArray[index].iDestinationItem );
        iDestinationArray[index].iDestinationItem->IncrementRefCounter();
        return dest;    
        }
    }

CCmPluginBase* CCMObjectPool::GetConnectionMethodL( TUint32 aCmId, 
                                        CCmDestinationImpl* aParentDest )
    {
    CCmPluginBase* connMethod = NULL;
    TObjectPoolCMItem findCM( NULL, aCmId );
    TInt index = iConnectionMethodArray.FindInUnsignedKeyOrder(findCM);
    if (index == KErrNotFound)
        {
        CCmPluginBaseEng* pluginBaseEng = iCmManagerImpl.DoFindConnMethL(
                                                        aCmId, aParentDest);        
        if (!pluginBaseEng) User::Leave(KErrNotFound); //There is no such plugin
        CleanupStack::PushL( pluginBaseEng );        
        connMethod = new (ELeave) CCmPluginBase(pluginBaseEng); 
        CleanupStack::PushL( connMethod );        
        TObjectPoolCMItem aCM( pluginBaseEng, aCmId );
        User::LeaveIfError(
            iConnectionMethodArray.InsertInUnsignedKeyOrder(aCM));
        pluginBaseEng->IncrementRefCounter();
        CleanupStack::Pop( connMethod );
        CleanupStack::Pop( pluginBaseEng );
        }
    else
        {
        // If the cm is allready in the pool than return it.
        iConnectionMethodArray[index].iConnectionMethodItem->IncrementRefCounter();
        connMethod = new (ELeave) CCmPluginBase(
                iConnectionMethodArray[index].iConnectionMethodItem); 
        }
    return connMethod;            
    }

CCmPluginBase* CCMObjectPool::CreateConnectionMethodL( CCmPluginBaseEng* pluginBaseEng )
    {
    CCmPluginBase* connMethod = new (ELeave) CCmPluginBase(pluginBaseEng); 
    CleanupStack::PushL( connMethod );        
    TObjectPoolCMItem aCM( pluginBaseEng, 0 );//The new id is zero till update
    User::LeaveIfError(
        iConnectionMethodArray.InsertInUnsignedKeyOrderAllowRepeats(aCM));
    pluginBaseEng->IncrementRefCounter();
    CleanupStack::Pop( connMethod );
    return connMethod;            
    }

void CCMObjectPool::InsertConnectionMethodL( CCmPluginBaseEng* pluginBaseEng )
    {       
    TObjectPoolCMItem aCM( pluginBaseEng, 0 );//The new id is zero till update
    User::LeaveIfError(
        iConnectionMethodArray.InsertInUnsignedKeyOrderAllowRepeats(aCM));
    pluginBaseEng->IncrementRefCounter();
    }

CCmPluginBase* CCMObjectPool::CreateConnectionMethodL( TUint32 aImplementationUid, 
                                        TCmPluginInitParam& aParams )
    {
    CCmPluginBaseEng* pluginBaseEng = iCmManagerImpl.DoCreateConnectionMethodL(
                                            aImplementationUid, aParams);
    CleanupStack::PushL( pluginBaseEng );        
    CCmPluginBase* connMethod = new (ELeave) CCmPluginBase(pluginBaseEng); 
    CleanupStack::PushL( connMethod );        
    TObjectPoolCMItem aCM( pluginBaseEng, 0 );//The new id is zero till update
    User::LeaveIfError(
        iConnectionMethodArray.InsertInUnsignedKeyOrderAllowRepeats(aCM));
    pluginBaseEng->IncrementRefCounter();
    CleanupStack::Pop( connMethod );
    CleanupStack::Pop( pluginBaseEng );
    return connMethod;            
    }

CCmPluginBase* CCMObjectPool::CreateConnectionMethodL( TUint32 aImplementationUid, 
                                                       TCmPluginInitParam& aParams,
                                                       TUint32 aConnMethodId )
	{
    CCmPluginBaseEng* pluginBaseEng = iCmManagerImpl.DoCreateConnectionMethodL(
                                            aImplementationUid, 
                                            aParams,
                                            aConnMethodId);
    CleanupStack::PushL( pluginBaseEng );
    CCmPluginBase* connMethod = new (ELeave) CCmPluginBase(pluginBaseEng); 
    CleanupStack::PushL( connMethod );        
    TObjectPoolCMItem aCM( pluginBaseEng, 0 );//The new id is zero till update
    User::LeaveIfError(
        iConnectionMethodArray.InsertInUnsignedKeyOrderAllowRepeats(aCM));
    pluginBaseEng->IncrementRefCounter();
    CleanupStack::Pop( connMethod );
    CleanupStack::Pop( pluginBaseEng );
    return connMethod;            
	}

CCmDestinationImpl* CCMObjectPool::GetDestinationL( const TDesC& aName )
    {
    // CmManagerImpl.GetDestinationL will leave with KErrAlreadyExists 
    // if the destination already exists
    CCmDestinationImpl* destImpl = CCmDestinationImpl::NewL( iCmManagerImpl,
         aName );
    // Yet destImpl->Id() == 0
    TObjectPoolDestinationItem aDest( destImpl->GetData(), destImpl->Id() );
    // InsertInUnsignedKeyOrderAllowRepeats is used because all
    // new destinations' Id is zero   
    User::LeaveIfError(
        iDestinationArray.InsertInUnsignedKeyOrderAllowRepeats(aDest) );
    destImpl->IncrementRefCounter();
    return destImpl;            
    }

CCmDestinationImpl* CCMObjectPool::CreateDestinationL( const TDesC& aName,
                                                       TUint32 aDestId )
    {
    // CmManagerImpl.GetDestinationL will leave with KErrAlreadyExists 
    // if the destination already exists
    CCmDestinationImpl* destImpl = CCmDestinationImpl::NewL( iCmManagerImpl,
                                                             aName,
                                                             aDestId);
    // Yet destImpl->Id() == 0
    TObjectPoolDestinationItem aDest( destImpl->GetData(), destImpl->Id() );
    // InsertInUnsignedKeyOrderAllowRepeats is used because all
    // new destinations' Id is zero   
    User::LeaveIfError(
                   iDestinationArray.InsertInUnsignedKeyOrderAllowRepeats(aDest) );
    destImpl->IncrementRefCounter();
    return destImpl;            
    }


void CCMObjectPool::RemoveDestination( CCmDestinationData* aDestination )
    {
    if (aDestination->IdIsValid())
        {
        aDestination->DecrementRefCounter();
        if (!aDestination->GetRefCounter())
            {// this was the last reference -> must delete        
            TObjectPoolDestinationItem findD( NULL, aDestination->Id() );
            TInt index = iDestinationArray.FindInUnsignedKeyOrder(findD);
            iDestinationArray.Remove(index);
            delete aDestination;
            }        
        }
    else
        { // this is a new destination which hasn't been updated yet
        // there may be more than one dest with id 0 -> must search by 
        // iDestinationItem        
        for (TInt index = 0; index < iDestinationArray.Count(); index++)
            {
            if ( iDestinationArray[index].iDestinationItem == 
                 aDestination )
                {
                aDestination->DecrementRefCounter();
                if (!aDestination->GetRefCounter())
                    {// this was the last reference -> must delete        
                    iDestinationArray.Remove(index);
                    delete aDestination;
                    }
                break;    
                }
            }                
        }
    }

void CCMObjectPool::RemoveDestination( CCmDestinationImpl* aDestination )
    {
    RemoveDestination(aDestination->GetData());
    aDestination->SetData(NULL);
    }

void CCMObjectPool::DestinationUpdated( CCmDestinationImpl* aDestination )
    {
    // there may be more than one dest with id 0 -> must search by 
    // iDestinationItem        
    for (TInt index = 0; index < iDestinationArray.Count(); index++)
        {
        if ( iDestinationArray[index].iDestinationItem == 
                aDestination->GetData() )
            {
            if (aDestination->IdIsValid()) break; //allready updated
            iDestinationArray[index].iDestinationId = aDestination->Id();
            iDestinationArray.SortUnsigned();
            break;    
            }
        }        
    }

void CCMObjectPool::ConnMethodUpdatedL( CCmPluginBaseEng* aCM )
    {
    // there may be more than one dest with id 0 -> must search by 
    // iDestinationItem        
    for (TInt index = 0; index < iConnectionMethodArray.Count(); index++)
        {
        if ( iConnectionMethodArray[index].iConnectionMethodItem == 
                aCM )
            {
            TInt cmId = aCM->GetIntAttributeL(CMManager::ECmId);
            iConnectionMethodArray[index].iConnectionMethodId = cmId;
            iConnectionMethodArray.SortUnsigned();
            break;    
            }
        }        
    }

void CCMObjectPool::RemoveConnectionMethodL( CCmPluginBase* aCM)
    {
    RemoveConnectionMethodL(aCM->Plugin());
    aCM->SetPlugin(NULL);
    }

void CCMObjectPool::RemoveConnectionMethodL( CCmPluginBaseEng* aCM)
    {
    if (aCM->IdIsValid())
        {
        aCM->DecrementRefCounter();
        if (!aCM->GetRefCounter())
            {// this was the last reference -> must delete        
            TUint32 cmId = aCM->GetIntAttributeL(CMManager::ECmId);
            TObjectPoolCMItem findD( NULL, cmId );
            TInt index = iConnectionMethodArray.FindInUnsignedKeyOrder(findD);
            iConnectionMethodArray.Remove(index);
            delete aCM;
            }        
        }
    else
        { // this is a new cm which hasn't been updated yet
        // there may be more than one cm with id 0 -> must search by pointer
        for (TInt index = 0; index < iConnectionMethodArray.Count(); index++)
            {
            if ( iConnectionMethodArray[index].iConnectionMethodItem == aCM )
                {
                aCM->DecrementRefCounter();
                if (!aCM->GetRefCounter())
                    {// this was the last reference -> must delete        
                    iConnectionMethodArray.Remove(index);
                    delete aCM;
                    }
                break;    
                }
            }
        }
    }