// Copyright (c) 1997-2009 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:

 // Written by Brendan, Dec 1996

 // Library associated files for pluggable components

 // 

 //

 #if !defined(__LIBASSOC_H__)

 #define __LIBASSOC_H__

 #if !defined(__F32FILE_H__)

 #include <f32file.h>

 #endif

 class TLibAssocBase

 /**

 @publishedAll

 @released

 This is an implementation base class for TLibAssoc.

 */

 	{

 protected:

 	inline TLibAssocBase();

 	IMPORT_C TLibAssocBase(const RLibrary& aLib,TAny* aPtr);

 	IMPORT_C void Set(const RLibrary& aLib,TAny* aPtr);

 	IMPORT_C static void DoUnload(TAny* aThis);

 public:

 	inline TBool IsNull() const;

 private:

 	RLibrary iLibrary;

 protected:

     /**

     A Pointer to the class instance.

     */

 	TAny* iPtr;

 	};

 //	class TLibAssoc inlines

 inline TLibAssocBase::TLibAssocBase()

 	: iPtr(NULL)

 /**

 Default constructor.

 It sets the member TLibAssocBase::iPtr to NULL.

 */	

 	{}

 inline TBool TLibAssocBase::IsNull() const

 /**

 Tests whether the pointer to the class instance is NULL.

 @return ETrue, if the pointer is NULL; EFalse, otherwise.

 */

 	{return iPtr==NULL;}

 //

 //	class TLibAssoc

 //

 template <class T>

 class TLibAssoc : public TLibAssocBase

 /**

 @publishedAll

 @released

 Associates a dynamically loadable DLL and an instance of a class that,

 typically, will have been created using the ordinal 1 function of that DLL.

 An object of this type is useful when cleanup behaviour requires that

 a class instance be deleted and the associated DLL be closed.

 The DLL is expected to be already open when the TLibAssoc object is created.

 */

 	{

 public:

 	inline TLibAssoc();

 	inline TLibAssoc(const RLibrary& aLib,T* aClass);

 	inline void Set(const RLibrary& aLib,T* aClass);

 	//

 	inline void Unload();

 	//

 	inline operator TCleanupItem();

 	operator TLibAssoc*(); // undefined, but here to prevent accidental delete(TLibAssoc)

 	//

 	inline T* Ptr();

 	inline const T* PtrC() const;

 	//

 	inline operator T*();

 	inline operator const T*() const;

 	//

 	inline T* operator->();

 	inline const T* operator->() const;

 private:

 	static void Cleanup(TAny* aThis); // for TCleanupOperation

 	};

 template <class T>

 inline TLibAssoc<T>::TLibAssoc()

 /**

 Default constructor.

 An association between a DLL and a class instance can be made

 after construction using the Set() function.

 */

 	{}

 template <class T>

 inline TLibAssoc<T>::TLibAssoc(const RLibrary& aLib,T* aClass)

 	: TLibAssocBase(aLib,aClass)

 /**

 Constructs the object taking the specified DLL and an instance of

 the specified class.

 @param aLib   A reference to a DLL that has already been opened.

 @param aClass A pointer to an object to be associated with the DLL.

               Typically, this object will have been created using

               the ordinal 1 function from that DLL.

 */	

 	{}

 template <class T>

 inline void TLibAssoc<T>::Set(const RLibrary& aLib,T* aClass)

 /**

 Makes an association between the specified DLL and an instance of

 the specified class.

 @param aLib   A reference to a DLL that has already been opened.

 @param aClass A pointer to an object to be associated with the DLL.

               Typically, this object will have been created using

               the ordinal 1 function from that DLL.

 */

 	{TLibAssocBase::Set(aLib,aClass);}

 template <class T>

 inline T* TLibAssoc<T>::Ptr()

 /**

 Gets a pointer to the class instance.

 @return A pointer to the class instance.

 */

 	{return (T*)iPtr;}

 template <class T>

 inline const T* TLibAssoc<T>::PtrC() const

 /**

 Gets a pointer to the const class instance.

 @return A pointer to the const class instance.

 */

 	{return (const T*)iPtr;}

 template <class T>

 inline TLibAssoc<T>::operator T*()

 /**

 Conversion operator.

 Invoked by the compiler when a TLibAssoc<T> type is passed to a function that

 is prototyped to take a T* type.

 */

 	{return (T*)iPtr;}

 template <class T>

 inline TLibAssoc<T>::operator const T*() const

 /**

 Const conversion operator.

 Invoked by the compiler when a TLibAssoc<T> type is passed to a function that

 is prototyped to take a const T* type.

 */

 	{return (const T*)iPtr;}

 template <class T>

 inline T* TLibAssoc<T>::operator->()

 /**

 Dereferencing operator.

 @return A pointer to the class instance.

 */

 	{return (T*)iPtr;}

 template <class T>

 inline const T* TLibAssoc<T>::operator->() const

 /**

 Const dereferencing operator.

 @return A pointer to the const class instance.

 */

 	{return (const T*)iPtr;}

 template <class T>

 inline TLibAssoc<T>::operator TCleanupItem()

 /**

 The TCleanupItem conversion operator.

 Invoked by the compiler when a TLibAssoc<T> type is passed to a function that

 is prototyped to take a TCleanupItem type.

 The most common usage is to put a cleanup item onto the cleanup stack using

 CleanupStack::PushL(). The cleanup operation is represented by the private

 static function Cleanup().

 For example, if we declare

 @code

 TLibAssoc<A> a;

 @endcode 

 then we can simply put a cleanup item onto the cleanup stack

 by calling

 @code

 CleanupStack::PushL(a);

 @endcode

 @see TCleanupItem

 @see CleanupStack::PushL

 */

 	{return(TCleanupItem(Cleanup,this));}

 template <class T>

 inline void TLibAssoc<T>::Unload()

 /**

 Deletes the class instance and calls Close() on the associated DLL.

 @see RLibrary::Close

 */

 	{Cleanup(this);}

 template <class T>

 void TLibAssoc<T>::Cleanup(TAny* aThis)

 /**

 The cleanup operation.

 The implementation deletes the class instance and calls Close() on

 the associated DLL.

 Note that this function is internal and is not intended for use; it is documented

 for completeness.

 */

 	{

 	delete (T*)(((TLibAssoc<T>*)aThis)->iPtr);

 	TLibAssocBase::DoUnload(aThis);

 	}

 #endif