/*
* Copyright (c) 2002-2006 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:  CCFCacheElement class implementation.
*
*/


#include "CFCacheElement.h"
#include "CFContextObjectImpl.h"
#include "cftrace.h"
#include "cfcontextsourceinterface.h"

// CONSTANTS

#ifdef _DEBUG
// Panic category
_LIT( KPanicCat, "CONTEXTCACHE" );

// Panic codes
enum TPanicReason
    {
    EInvalidSubscriptionIndex,
    };

// Local panic function
LOCAL_C void Panic( TInt aCode )
    {
    User::Panic( KPanicCat, aCode );
    }
#endif

// MEMBER FUNCTIONS

CCFCacheElement* CCFCacheElement::NewL()
    {
    FUNC_LOG;

    CCFCacheElement* self  = CCFCacheElement::NewLC();
    CleanupStack::Pop( self );
    
    return self;
    }

CCFCacheElement* CCFCacheElement::NewLC()
    {
    FUNC_LOG;

    CCFCacheElement* self = new( ELeave ) CCFCacheElement;
    CleanupStack::PushL( self );
    self->ConstructL();
    
    return self;
    }

CCFCacheElement::~CCFCacheElement()
    {
    FUNC_LOG;
    
    delete iContext;
    iSubscriptions.Close();
    }

CCFCacheElement::CCFCacheElement()
    {
    FUNC_LOG;
    }

void CCFCacheElement::ConstructL()
    {
    FUNC_LOG;

    iContext = CCFContextObject::NewL();
    }

// METHODS

//-----------------------------------------------------------------------------
// CCFCacheElement::Context
//-----------------------------------------------------------------------------
// 
CCFContextObject& CCFCacheElement::Context() const
    {
    FUNC_LOG;
    
    return *iContext;
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::AddSubscriptionL
//-----------------------------------------------------------------------------
// 
void CCFCacheElement::AddSubscriptionL(
    CCFContextSubscriptionImpl& aSubscription )
    {
    FUNC_LOG;
    
    iSubscriptions.AppendL( &aSubscription );
    
    // notify context source if this was the first subscription
    if (iSubscriptions.Count() == 1 && iPublisher )
    	{
    	iPublisher->Subscribers( iContext->Source(), iContext->Type() );
    	}
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::RemoveSubscription
//-----------------------------------------------------------------------------
// 
void CCFCacheElement::RemoveSubscription( TInt aIndex )
    {
    FUNC_LOG;
    
    __ASSERT_DEBUG( aIndex >= 0 && aIndex < iSubscriptions.Count(),
        Panic( EInvalidSubscriptionIndex ) );
    
    iSubscriptions.Remove( aIndex );

    // notify context source if this was the first subscription
    if (iSubscriptions.Count() == 0 && iPublisher )
    	{
    	iPublisher->NoSubscribers( iContext->Source(), iContext->Type() );
    	}
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::NullifySubscription
//-----------------------------------------------------------------------------
// 
void CCFCacheElement::NullifySubscription( TInt aIndex )
    {
    FUNC_LOG;

    __ASSERT_DEBUG( aIndex >= 0 && aIndex < iSubscriptions.Count(),
        Panic( EInvalidSubscriptionIndex ) );

    iSubscriptions[ aIndex ] = NULL;
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::RemoveNullSubscriptions
//-----------------------------------------------------------------------------
// 
void CCFCacheElement::RemoveNullSubscriptions()
    {
    FUNC_LOG;

    TInt count = iSubscriptions.Count();
    for ( TInt i = count - 1; i >= 0; --i )
        {
        CCFContextSubscriptionImpl* subscription = iSubscriptions[ i ];
        if ( !subscription )
            {
            iSubscriptions.Remove( i );
            }
        }

    // notify context source if no more subscriptions exist
    if ( count && iSubscriptions.Count() == 0 && iPublisher )
        {
        iPublisher->NoSubscribers( iContext->Source(), iContext->Type() );
        }
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::Subscriptions
//-----------------------------------------------------------------------------
// 
const RPointerArray<CCFContextSubscriptionImpl>& CCFCacheElement::Subscriptions() const
    {
    FUNC_LOG;
    
    return iSubscriptions;
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::SetReadSecurityPolicy
//-----------------------------------------------------------------------------
// 
void CCFCacheElement::SetReadSecurityPolicy(
    const TSecurityPolicy& aSecurityPolicy )
    {
    FUNC_LOG;
    
    iReadSecurityPolicy = aSecurityPolicy;
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::GetReadSecurityPolicy
//-----------------------------------------------------------------------------
// 
const TSecurityPolicy& CCFCacheElement::GetReadSecurityPolicy() const
    {
    FUNC_LOG;
    
    return iReadSecurityPolicy;
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::SetWriteSecurityPolicy
//-----------------------------------------------------------------------------
// 
void CCFCacheElement::SetWriteSecurityPolicy(
    const TSecurityPolicy& aSecurityPolicy )
    {
    FUNC_LOG;
    
    iWriteSecurityPolicy = aSecurityPolicy;
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::GetWriteSecurityPolicy
//-----------------------------------------------------------------------------
// 
const TSecurityPolicy& CCFCacheElement::GetWriteSecurityPolicy() const
    {
    FUNC_LOG;
    
    return iWriteSecurityPolicy;
    }


//-----------------------------------------------------------------------------
// CCFCacheElement::SetContextPublisher
//-----------------------------------------------------------------------------
// 
void CCFCacheElement::SetContextPublisher( MCFContextSource* aPublisher )
    {
    FUNC_LOG;

    iPublisher = aPublisher;
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::SetContextPublisher
//-----------------------------------------------------------------------------
// 
void CCFCacheElement::SetContextPublisher(
	    MCFContextSource* aPublisher, const TUid& aPublisherUid )
    {
    FUNC_LOG;
    
    iPublisher = aPublisher;
    iPublisherUid = aPublisherUid;
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::ContextPublisher
//-----------------------------------------------------------------------------
// 
const MCFContextSource* CCFCacheElement::ContextPublisher() const
    {
    FUNC_LOG;
    
    return iPublisher;
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::PublisherUid
//-----------------------------------------------------------------------------
// 
const TUid& CCFCacheElement::PublisherUid() const
	{
	FUNC_LOG;
	
	return iPublisherUid;
	}


//-----------------------------------------------------------------------------
// CCFCacheElement::CompareByTypeAndSource
//-----------------------------------------------------------------------------
// 
TInt CCFCacheElement::CompareByTypeAndSource(
    const CCFCacheElement& aFirst,
    const CCFCacheElement& aSecond)
    {
    FUNC_LOG;

    return CCFContextObjectImpl::CompareByTypeAndSource(
        *aFirst.iContext, *aSecond.iContext );
    }

//-----------------------------------------------------------------------------
// CCFCacheElement::CompareByType
//-----------------------------------------------------------------------------
// 
TInt CCFCacheElement::CompareByType(
    const CCFCacheElement& aFirst,
    const CCFCacheElement& aSecond)
    {
    FUNC_LOG;

    return CCFContextObjectImpl::CompareByType(
        *aFirst.iContext, *aSecond.iContext);
    }