/*

* 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;        

        }

    }