/*
* Copyright (c) 2004 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:  Inline methods for thin templated RGenericObserverArray
*
*/



// ================= HELPER CLASS =======================
/**
 * Helper inline class to forward requests
 * from base mediator (typeless) to type specific
 * mediator.
 *
 * @since 2.1
 */
template <class T, class P>
class TGenObserverNotifyMediatorBase : public MGenObserverNotifyMediatorBase
    {
    public:
        inline TGenObserverNotifyMediatorBase( MGenObserverNotifyMediator<T, P>& aSpecificMediator )
            : iSpecificMediator( aSpecificMediator ){}

    private:
        inline void MediateNotifyL( TAny* aObserverToNotify, TAny* aNotifyData )
            { iSpecificMediator.MediateNotifyL( *( static_cast<T*>( aObserverToNotify ) ),
                                                *( static_cast<P*>( aNotifyData ) ) ); }

        inline void MediateNotifyError( TAny* aObserverToNotify, TInt aLeaveError )
            { iSpecificMediator.MediateNotifyError( *( static_cast<T*>( aObserverToNotify ) ), aLeaveError ); }

        inline void MediateError( TAny* aObserverToNotify, TInt aError )
            { iSpecificMediator.MediateError( *( static_cast<T*>( aObserverToNotify ) ), aError ); }

    private:
        ///< Observer type specific notify mediator, not owned
        MGenObserverNotifyMediator<T, P>& iSpecificMediator;
        };


// ================= MEMBER FUNCTIONS =======================
// C++ default constructor can NOT contain any code, that
// might leave.
//
template <class T, class P>
inline RGenericObserverArray<T, P>::RGenericObserverArray()
    {
    }

// -----------------------------------------------------------------------------
// RGenericObserverArray::Close()
// -----------------------------------------------------------------------------
//
template <class T, class P>
inline void RGenericObserverArray<T, P>::Close()
    {
    RGenericObserverArrayBase::Close();
    }


// -----------------------------------------------------------------------------
// RGenericObserverArray::AddObserver()
// -----------------------------------------------------------------------------
//
template <class T, class P>
inline TInt RGenericObserverArray<T, P>::AddObserver( const T* aObserver )
    {
    return RGenericObserverArrayBase::AddObserver( static_cast<const TAny*>( aObserver ) );
    }


// -----------------------------------------------------------------------------
// RGenericObserverArray::AddObserverL()
// -----------------------------------------------------------------------------
//
template <class T, class P>
inline void RGenericObserverArray<T, P>::AddObserverL( const T* aObserver )
    {
    User::LeaveIfError( AddObserver( aObserver ) );
    }


// -----------------------------------------------------------------------------
// RGenericObserverArray::RemoveObserver()
// -----------------------------------------------------------------------------
//
template <class T, class P>
inline TInt RGenericObserverArray<T, P>::RemoveObserver( T* aObserver )
    {
    return RGenericObserverArrayBase::RemoveObserver( static_cast<TAny*>( aObserver ) );
    }


// -----------------------------------------------------------------------------
// RGenericObserverArray::Count()
// -----------------------------------------------------------------------------
//
template <class T, class P>
inline TInt RGenericObserverArray<T, P>::Count()
    {
    return RGenericObserverArrayBase::Count();
    }


// -----------------------------------------------------------------------------
// RGenericObserverArray::NotifyObservers()
// -----------------------------------------------------------------------------
//
template <class T, class P>
inline void RGenericObserverArray<T, P>::NotifyObservers( MGenObserverNotifyMediator<T, P>& aNotifyMediator,
                                                          P& aNotifyData )
    {
    TGenObserverNotifyMediatorBase<T, P> baseMediator( aNotifyMediator );
    RGenericObserverArrayBase::NotifyObservers( baseMediator,
                                                static_cast<TAny*>( &aNotifyData) );
    }


// -----------------------------------------------------------------------------
// RGenericObserverArray::NotifyObserversFromError()
// -----------------------------------------------------------------------------
//
template <class T, class P>
inline void RGenericObserverArray<T, P>::NotifyObserversFromError( MGenObserverNotifyMediator<T, P>& aNotifyMediator,
                                                                   TInt aError )
    {
    TGenObserverNotifyMediatorBase<T, P> baseMediator( aNotifyMediator );
    RGenericObserverArrayBase::NotifyObserversFromError( baseMediator, aError );
    }

//  End of File