/*
* Copyright (c) 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: Contains CCatalogsInterfaceBase class implementation
*
*/
#include "catalogsinterfacebase.h"
#include "catalogsinterfaceidentifier.h"
#include "catalogsdebug.h"
CCatalogsInterfaceBase::CCatalogsInterfaceBase( CCatalogsInterfaceBase* aParent )
: CBase(),
iParent( aParent )
{
}
CCatalogsInterfaceBase::~CCatalogsInterfaceBase()
{
DLTRACE(("this-ptr: %x", this));
iInterfaces.ResetAndDestroy();
}
void CCatalogsInterfaceBase::SetParentL( CCatalogsInterfaceBase* aParent )
{
DLTRACEIN(("this-ptr: %x", this));
if ( aParent == this )
{
// We do not accept this object to be its own parent.
DLTRACEOUT(("Parent is same as the object itself"))
return;
}
if ( iParent != NULL )
{
DLERROR(("Object already had a parent"));
// This option can not be accepted, because problems would arise when
// transferring interfaces from this class object to the new parent. Or,
// if this class object should be made the top root, then it would not be
// known which interfaces should be moved here.
// Only parent knows the interfaces and children do not know their own.
// So, we do not know which interfaces should be removed from the parent
// and which should be left.
DASSERT( EFalse );
User::Leave( KErrArgument );
}
else if ( aParent == NULL )
{
DLTRACEOUT(("Nothing needs to be done, because NULL parent was given"));
// Because the parent of this object is NULL and the new parent is NULL
// then nothing needs to be done. In other words, this object remains to be
// the top parent.
return;
}
// This class object was top parent itself and the new parent seems to be acceptable.
// Continue by moving interfaces from this class object to the new top parent.
DLINFO(("New parent object was given"));
// This class object was a top parent itself.
// So, move all the interface elements from this list to the
// list of the new parent.
CCatalogsInterfaceIdentifier* interfaceIdentifier( NULL );
TInt interfaceError( KErrNone );
while ( iInterfaces.Count() > 0 )
{
interfaceIdentifier = iInterfaces[ 0 ];
// Notice that new parent takes the ownership of the interface.
// If the new parent is not the top parent, these interfaces will
// be forwarded to the top parent automatically.
// TRAP updates the error value to KErrNone everytime if no error occurs.
TRAP( interfaceError, aParent->AddInterfaceL( interfaceIdentifier ) );
if ( interfaceError != KErrNone )
{
DLERROR(("Could not add interface to the parent: %d", interfaceError));
DASSERT( EFalse );
// Because the ownership of the interface could not been transferred.
// delete the interface here. There is nothing much else that we could do.
delete interfaceIdentifier;
interfaceIdentifier = NULL;
}
// Remove the interface from the list because it has been moved above.
iInterfaces.Remove( 0 );
}
// The old parent value was NULL because this function is allower only for the
// top parent. Update the parent pointer.
iParent = aParent;
// The top parent also keeps track of the reference counts of all its children.
// Update the reference counts of the new parent.
// Notice that the parent reference count always contains the sum of all the reference
// counts of its children and their children etc. So, add this information to the new
// parent.
for ( TInt i = 0; i < iRefCount; ++i )
{
iParent->AddRef();
}
for ( TInt i = 0; i < iInternalRefCount; ++i )
{
iParent->InternalAddRef();
}
DLTRACEOUT((""));
}
void CCatalogsInterfaceBase::RemoveFromParent()
{
DLTRACEIN(("this-ptr: %x", this));
if ( iParent == NULL )
{
DLTRACEOUT(("This is a top parent itself."));
// Nothing to do here.
return;
}
// This class object has a parent
// Release old parent counter values according
// to the values this object has. Do not change the values
// of this object.
for ( TInt i = 0; i < iRefCount; ++i )
{
iParent->Release();
}
for ( TInt i = 0; i < iInternalRefCount; ++i )
{
iParent->InternalRelease();
}
// Set the parent to be NULL, because this will act as its own parent after this.
iParent = NULL;
DLTRACEOUT((""));
}
void CCatalogsInterfaceBase::AddInterfaceL( CCatalogsInterfaceIdentifier* aInterface )
{
DLTRACE(("this-ptr: %x", this));
if ( aInterface != NULL )
{
// All the interfaces exist in the top parent. So, if this object
// has parent, delegate query to it.
if ( iParent != NULL )
{
iParent->AddInterfaceL( aInterface );
}
else
{
// This is a top parent.
// If old interface of the same type exists, then remove
// it because only one of the kind is accepted.
RemoveInterface( aInterface->InterfaceId() );
CleanupStack::PushL( aInterface );
iInterfaces.AppendL( aInterface );
CleanupStack::Pop( aInterface );
}
}
}
void CCatalogsInterfaceBase::RemoveInterface( TInt aId )
{
DLTRACE(("this-ptr: %x", this));
if ( iParent != NULL )
{
// All the interfaces exist in the top parent. So, if this
// has parent, delegate query to it.
iParent->RemoveInterface( aId );
}
else
{
// This is a top parent
for ( TInt i = 0; i < iInterfaces.Count(); ++i )
{
if ( iInterfaces[ i ]->InterfaceId() == aId )
{
delete iInterfaces[i];
iInterfaces.Remove( i );
break;
}
}
}
}
TInt CCatalogsInterfaceBase::TotalRefCount() const
{
DLTRACE(("this-ptr: %x", this));
if ( iParent != NULL )
{
// Parent has all the information
return iParent->TotalRefCount();
}
else
{
// This is a top parent. So, return the information.
return RefCount() + InternalRefCount();
}
}
TInt CCatalogsInterfaceBase::InternalRefCount() const
{
DLTRACEIN(("this-ptr: %x", this));
if ( iParent != NULL )
{
// Parent has all the information.
return iParent->InternalRefCount();
}
else
{
DLTRACEOUT(( "InternalRefCount: %d", iInternalRefCount ));
// This is a top parent
return iInternalRefCount;
}
}
TInt CCatalogsInterfaceBase::InternalAddRef()
{
DLTRACE(("this-ptr: %x", this));
// Increase the reference counter for all the
// objects starting from this object to the top parent.
iInternalRefCount++;
if ( iParent != NULL )
{
// Parent has all the information
return iParent->InternalAddRef();
}
else
{
DLTRACE(( "InternalRefCount: %d", iInternalRefCount ));
// This is a top parent.
return iInternalRefCount;
}
}
TInt CCatalogsInterfaceBase::InternalRelease()
{
DLTRACE(("this-ptr: %x", this));
DASSERT( iInternalRefCount > 0 );
// Descrease the reference counter for all the
// objects starting from this object to the top parent.
if ( iInternalRefCount > 0 )
{
// Do not let the counter to go below zero.
--iInternalRefCount;
}
if ( iParent != NULL )
{
// Parent has all the information
return iParent->InternalRelease();
}
else
{
// This is parent.
if ( TotalRefCount() > 0 )
{
DLTRACE(( "InternalRefCount: %d", iInternalRefCount ));
return iInternalRefCount;
}
else
{
DLTRACE(("Deleting this: %x", this));
// No references are left for this object.
delete this;
return 0;
}
}
}
TInt CCatalogsInterfaceBase::MyTotalRefCount() const
{
DLTRACE(("this-ptr: %x", this));
return MyRefCount() + MyInternalRefCount();
}
TInt CCatalogsInterfaceBase::MyRefCount() const
{
DLTRACE(("this-ptr: %x", this));
return iRefCount;
}
TInt CCatalogsInterfaceBase::MyInternalRefCount() const
{
DLTRACE(("this-ptr: %x", this));
return iInternalRefCount;
}
// MCatalogsBase functions
TInt CCatalogsInterfaceBase::AddRef() const
{
// Increase the reference counter for all the
// objects starting from this object to the top parent.
iRefCount++;
if ( iParent != NULL )
{
// Parent has all the info.
DLTRACE(( "this-ptr: %x, RefCount: %d", this, iRefCount ));
return iParent->AddRef();
}
else
{
DLTRACE(( "this-ptr: %x, RefCount: %d", this, iRefCount ));
return iRefCount;
}
}
TInt CCatalogsInterfaceBase::Release() const
{
DASSERT( iRefCount > 0 );
// Descrease the reference counter for all the
// objects starting from this object to the top parent.
if ( iRefCount > 0 )
{
// Do not let the counter to go below zero.
--iRefCount;
}
if ( iParent != NULL )
{
DLTRACE((("this-ptr: %x, RefCount: %d"), this, iRefCount ));
// Parent has all the info.
return iParent->Release();
}
else
{
// This is parent
if ( TotalRefCount() > 0 )
{
DLTRACE(( "RefCount: %d, this: %x", iRefCount, this ));
return iRefCount;
}
else
{
DLTRACE(("Deleting this: %x", this));
// No references are left for this object.
delete this;
return 0;
}
}
}
TInt CCatalogsInterfaceBase::RefCount() const
{
if ( iParent != NULL )
{
// Parent has all the info
return iParent->RefCount();
}
else
{
DLTRACE(( "RefCount: %d", iRefCount ));
// This is parent
return iRefCount;
}
}
const TAny* CCatalogsInterfaceBase::QueryInterfaceL( TInt aInterfaceType ) const
{
DLTRACEIN(( "Interface: %d, this-ptr: %x", aInterfaceType, this ));
// All the interfaces exist in the parent. So, if this
// has parent, delegate query to it.
if ( iParent != NULL )
{
// The parent has all the info
return iParent->QueryInterfaceL( aInterfaceType );
}
else
{
// This is parent.
// Check the interfaces from the list and return the interface
// that matches the given type
for ( TInt i = 0; i < iInterfaces.Count(); ++i )
{
if ( iInterfaces[ i ]->InterfaceId() == aInterfaceType )
{
// Match was found
const TAny* interface( iInterfaces[ i ]->InterfaceObject() );
const CCatalogsInterfaceBase* interfaceBase( iInterfaces[ i ]->InterfaceBaseObject() );
// Because interface is returned, the ref count has to be increased.
interfaceBase->AddRef();
DLTRACEOUT(( "Interface found: %X", interface ));
// Return interface, not interfaceBase, because interfaceBase is a pointer to
// the base class. They may have different pointer because of "public virtual <class>"
// inheritance.
return interface;
}
}
// Interface was not found
DLTRACEOUT( ( "return NULL" ) );
return NULL;
}
}