/*

* 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:  factory class to create access and updateer class implementation

*

*/

// INCLUDE FILES

#include    "cimcachefactory.h"

#include	"cimcacheupdater.h"

#include	"mimcacheupdater.h"

#include	"cimcacheaccessor.h"

#include	"mimcacheaccessor.h"

#include	"cimcacheclient.h"

// logs

#include    "imcachedebugtrace.h"

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

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

// CIMCacheFactory::Instance

//see whether there is an instance in the TLS

//if not create the instance and set the same in TLS

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

//

 EXPORT_C CIMCacheFactory* CIMCacheFactory::InstanceL()

    {

     TRACE( T_LIT("CIMCacheFactory::InstanceL begin") );

     CIMCacheFactory *factory = static_cast<CIMCacheFactory*>( Dll::Tls() );

     if ( ! factory )

        {

        // no existing instance, create a new one

        factory = CIMCacheFactory::NewL();

        CleanupStack::PushL( factory );

        User::LeaveIfError( Dll::SetTls( static_cast<TAny*>( factory ) ) );

        CleanupStack::Pop( factory );

        }

     TRACE( T_LIT("CIMCacheFactory::InstanceL end") );

     factory->IncrementReference();

     return factory;

    }    

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

// CIMCacheFactory::NewL

// Two-phased constructor.

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

//

CIMCacheFactory* CIMCacheFactory::NewL()

	{

    TRACE( T_LIT("CIMCacheFactory::NewL begin") );

    CIMCacheFactory* self = new ( ELeave ) CIMCacheFactory() ;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );  //self

    TRACE( T_LIT("CIMCacheFactory::NewL end") );

    return self;

	}

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

// CIMCacheFactory::Release()

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

// 	       

EXPORT_C void CIMCacheFactory::Release()

    {

    TRACE( T_LIT("CIMCacheFactory::Release start") );

    //if any instance in TLS get the same and delete it    

    CIMCacheFactory *factory = static_cast<CIMCacheFactory*>( Dll::Tls() );

    if ( factory &&  !(factory->DecrementReference()))

    if ( factory )

        {

        delete factory;

        Dll::SetTls( NULL );

        }

    TRACE( T_LIT("CIMCacheFactory::Release end") );

    }

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

// CIMCacheFactory::IncrementReference()

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

//

void CIMCacheFactory::IncrementReference()

    {

    TRACE( T_LIT("CIMCacheFactory::IncrementReference ") );

    iReferenceCount++;   

    }

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

// CPresenceCacheServer::DecrementReference()

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

//

TInt CIMCacheFactory::DecrementReference()

    {

    TRACE( T_LIT("CIMCacheFactory::DecrementReference ") );

    iReferenceCount--; 

    return iReferenceCount;    

    }

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

// CIMCacheFactory::CIMCacheFactory()

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

// might leave.

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

// 

CIMCacheFactory::CIMCacheFactory()

	{

	}

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

// CIMCacheFactory::~CIMCacheFactory()

// Symbian OS desstructor 

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

//

CIMCacheFactory::~CIMCacheFactory()

	{

	TRACE( T_LIT("CIMCacheFactory::~CIMCacheFactory start") );

	iUpdaterArray.ResetAndDestroy();

	iAccessorArray.ResetAndDestroy();

	delete iServerKeepAlive;

	TRACE( T_LIT("CIMCacheFactory::~CIMCacheFactory end") );

	}

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

// CIMCacheFactory::ConstructL()

// Symbian OS default constructor can leave.

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

//

void CIMCacheFactory::ConstructL( )

	{

	TRACE( T_LIT("CIMCacheFactory::ConstructL start") );

	iServerKeepAlive = new(ELeave) CIMCacheClient(); // CSI: 74 # this needs to be like this

	TRACE( T_LIT("CIMCacheFactory::ConstructL end") );

	}

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

// CIMCacheFactory::CreateUpdaterL()

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

//

EXPORT_C MIMCacheUpdater* CIMCacheFactory::CreateUpdaterL(TInt aServiceId,

															const TDesC& aUserId ,

															TBool aRegistrationNeeded )

    {

    TRACE( T_LIT("CIMCacheFactory::CreateAccessL begin") );

    CIMCacheUpdater* updater = NULL;

	TInt count = iUpdaterArray.Count();

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

		{

		if( iUpdaterArray[i]->ServiceId() == aServiceId )

			{

			updater = iUpdaterArray[i];

			break;

			}

		}

	if( !updater ) 

		{

		updater = CIMCacheUpdater::NewL( aServiceId, aUserId, aRegistrationNeeded );

		iUpdaterArray.Append(updater);

		}

    TRACE( T_LIT("CIMCacheFactory::CreateAccessL end") );

    return updater;

    }

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

// CIMCacheFactory::CreateAccessorL()

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

//

EXPORT_C MIMCacheAccessor* CIMCacheFactory::CreateAccessorL(TInt aServiceId,

															const TDesC& aUserId  )

    {

    TRACE( T_LIT("CIMCacheFactory::CreateAccessL begin") );

    CIMCacheAccessor* accessor = NULL;

	TInt count = iAccessorArray.Count();

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

		{

		if( iAccessorArray[i]->ServiceId() == aServiceId )

			{

			accessor = iAccessorArray[i];

			break;

			}

		}

	if( !accessor ) 

		{

		accessor = CIMCacheAccessor::NewL( aServiceId, aUserId );

		iAccessorArray.Append(accessor);

		}

    TRACE( T_LIT("CIMCacheFactory::CreateAccessL end") );

    return accessor;

    }

//  End of File