/*

* 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:  MXIMPObjectCollection implementation

 *

*/

#include "ximpobjectcollectionimp.h"

// ============================ HELPER CLASS =============================

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

// CXIMPCollectionElement::NewL

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

//

CXIMPObjectCollectionImp::CXIMPCollectionElement* 

CXIMPObjectCollectionImp::CXIMPCollectionElement::NewL(

        CXIMPApiObjBase* aObject, const TDesC8& aName )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aObject, aName );

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CXIMPCollectionElement::ConstructL

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

//

void CXIMPObjectCollectionImp::CXIMPCollectionElement::ConstructL(

        CXIMPApiObjBase* aObject, const TDesC8& aName )

    {

    iObject = aObject;

    if ( aName.Length() > 0 )

        {

        iName = aName.AllocL();

        }

    else

        {

        // at least an empty one always exists

        iName = HBufC8::NewL( 0 );

        }

    }

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

// CXIMPCollectionElement::CXIMPCollectionElement

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

//

CXIMPObjectCollectionImp::CXIMPCollectionElement::CXIMPCollectionElement()

    {

    }

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

// CXIMPCollectionElement::~CXIMPCollectionElement

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

//

CXIMPObjectCollectionImp::CXIMPCollectionElement::~CXIMPCollectionElement()

    {

    delete iObject;

    delete iName;

    }

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

// CXIMPCollectionElement::GetObject

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

//

CXIMPApiObjBase* CXIMPObjectCollectionImp::CXIMPCollectionElement::GetObject()

    {

    CXIMPApiObjBase* obj = iObject;

    iObject = NULL;

    return obj;

    }

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

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

// CXIMPObjectCollectionImp::NewL()

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

//

EXPORT_C CXIMPObjectCollectionImp* CXIMPObjectCollectionImp::NewL()

    {

    CXIMPObjectCollectionImp* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CXIMPObjectCollectionImp::NewLC()

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

//

EXPORT_C CXIMPObjectCollectionImp* CXIMPObjectCollectionImp::NewLC()

    {

    CXIMPObjectCollectionImp* self = new ( ELeave ) CXIMPObjectCollectionImp;

    CleanupStack::PushL( self );

    return self;

    }

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

// CXIMPObjectCollectionImp::~CXIMPObjectCollectionImp()

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

//

CXIMPObjectCollectionImp::~CXIMPObjectCollectionImp()

    {

    iCollection.ResetAndDestroy();

    }

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

// CXIMPObjectCollectionImp::CXIMPObjectCollectionImp()

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

//

CXIMPObjectCollectionImp::CXIMPObjectCollectionImp()

    {

    }

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

// Implement supported interface access.

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

//

XIMPIMP_IF_BASE_GET_INTERFACE_BEGIN( CXIMPObjectCollectionImp,

                                     MXIMPObjectCollection )

XIMPIMP_IF_BASE_GET_INTERFACE_END()

XIMPIMP_IF_BASE_GET_CONST_INTERFACE_BEGIN( CXIMPObjectCollectionImp,

                                           MXIMPObjectCollection )

XIMPIMP_IF_BASE_GET_INTERFACE_END()

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

// CXIMPObjectCollectionImp::LookupByType()

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

//

void CXIMPObjectCollectionImp::LookupByType(

        const MXIMPBase*& aObject,

        TInt32 aInterfaceId ) const

    {

    TInt start = FindLRUIndex( aObject );

    aObject = NULL;

    // now find the object without name

    for ( TInt i = start; i < iCollection.Count(); i++ )

        {

        const CXIMPObjectCollectionImp::CXIMPCollectionElement* element = iCollection[ i ];

        if ( ! element->iName->Length() )

            {

            // no name, ok

            if ( aInterfaceId == element->iObject->Base().GetInterfaceId() )

                {

                // got a match!

                aObject = &(element->iObject->Base());

                return;

                }

            }

        }

    return;

    }

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

// CXIMPObjectCollectionImp::LookupByTypeAndName()

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

//

void CXIMPObjectCollectionImp::LookupByTypeAndName(

                const MXIMPBase*& aObject,

                TInt32 aInterfaceId,

                const TDesC8& aMatch ) const

    {

    TInt start = FindLRUIndex( aObject );

    aObject = NULL;

    // now find the object with name

    for ( TInt i = start; i < iCollection.Count(); i++ )

        {

        const CXIMPObjectCollectionImp::CXIMPCollectionElement* element = iCollection[ i ];

        if ( ( KErrNotFound != element->iName->MatchF( aMatch ) ) 

                && ( aInterfaceId == element->iObject->Base().GetInterfaceId() ) )

            {

            // got a match with correct name and interface id

            aObject = &(element->iObject->Base());

            return;

            }

        }

    return;

    }

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

// CXIMPObjectCollectionImp::AddObjectL

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

//

void CXIMPObjectCollectionImp::AddObjectL(

        MXIMPBase* aObject )

    {

    AddObjectWithNameL( aObject, KNullDesC8 );

    }

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

// CXIMPObjectCollectionImp::AddObjectWithNameL

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

//

void CXIMPObjectCollectionImp::AddObjectWithNameL(

        MXIMPBase* aObject,

        const TDesC8& aName )

    {

    // NULL is not accepted

    User::LeaveIfError( aObject == NULL ? KErrArgument : KErrNone );

    // name must not contain wildcards

    User::LeaveIfError( ValidateName( aName ) );

    CXIMPApiObjBase* base = ( CXIMPApiObjBase* ) 

        aObject->GetInterface( XIMPIMP_CLSID_CXIMPAPIOBJBASE, EPanicIfUnknown ); 

    CXIMPObjectCollectionImp::CXIMPCollectionElement* element = 

        CXIMPObjectCollectionImp::CXIMPCollectionElement::NewL( base, aName );

    CleanupStack::PushL( element );

    iCollection.AppendL( element );

    CleanupStack::Pop( element ); 

    }

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

// CXIMPObjectCollectionImp::GetByType

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

//

TBool CXIMPObjectCollectionImp::GetByType(

        MXIMPBase*& aObject,

        TInt32 aInterfaceId )

    {

    aObject = NULL;

    // now find the object without name

    for ( TInt i = 0; i < iCollection.Count(); i++ )

        {

        CXIMPObjectCollectionImp::CXIMPCollectionElement* element = iCollection[ i ];

        if ( ! element->iName->Length() )

            {

            // no name, ok

            if ( aInterfaceId == element->iObject->Base().GetInterfaceId() )

                {

                // got a match!

                CXIMPApiObjBase* object = element->GetObject(); 

                iCollection.Remove( i );

                delete element;

                aObject = &(object->Base());

                return ETrue;

                }

            }

        }

    return EFalse;

    }

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

// CXIMPObjectCollectionImp::GetByTypeAndName

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

//

TBool CXIMPObjectCollectionImp::GetByTypeAndName(

        MXIMPBase*& aObject,

        TInt32 aInterfaceId,

        const TDesC8& aMatch )

    {

    aObject = NULL;

    // now find the object with name

    for ( TInt i = 0; i < iCollection.Count(); i++ )

        {

        CXIMPObjectCollectionImp::CXIMPCollectionElement* element = iCollection[ i ];

        if ( ( KErrNotFound != element->iName->MatchF( aMatch ) ) 

                && ( aInterfaceId == element->iObject->Base().GetInterfaceId() ) )

            {

            // got a match with correct name and interface id

            CXIMPApiObjBase* object = element->GetObject(); 

            iCollection.Remove( i );

            delete element;

            aObject = &(object->Base());

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CXIMPObjectCollectionImp::FindLRUIndex()

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

//

TInt CXIMPObjectCollectionImp::FindLRUIndex( const MXIMPBase*& aObject ) const

    {

    TInt start = 0;

    // naive lookup, least recently used (from beginning to the end).

    // find starting position

    if ( aObject != NULL )

        {

        TBool found = EFalse;

        for ( TInt i = 0; ( i < iCollection.Count()-1 ) && ( ! found ); i++ )

            {

            const CXIMPObjectCollectionImp::CXIMPCollectionElement* element = iCollection[ i ];

            if ( aObject == &(element->iObject->Base()) )

                {

                found = ETrue;

                start = i;

                }

            }

        }

    return start;

    }

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

// CXIMPObjectCollectionImp::ValidateName()

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

//

TInt CXIMPObjectCollectionImp::ValidateName( const TDesC8& aName ) const

    {

    const TUint8* pName = aName.Ptr();

    TInt pNameLen = aName.Length();

    for( ; pNameLen; pName++, pNameLen-- )

        {

        if( *pName > 0x7e || 

            *pName < 0x20 || 

            *pName == '*' || 

            *pName == '?' || 

            *pName == ':' )

            {

            return KErrBadName;                

            }

        }

	return KErrNone;

	}

// End of file