// 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:

//

#ifndef __LOADMANAGER_H__

#define __LOADMANAGER_H__

#include <e32base.h>

#include <ecom/extendedinterfaceimplementationproxy.h>

//Forward declarations

class CUnloadPolicy;

/**

@internalComponent

Represents an instance of an implementation

*/

NONSHARABLE_CLASS(CInstanceInfo): public CBase

	{

public:

	virtual ~CInstanceInfo();

	CUnloadPolicy* UnloadPolicy() {return iUnloadPolicy;};

public:

	virtual TUid ImplementationUid() = 0;

    virtual TProxyExtendedInterfaceGetPtrL ProxyExtendedIntGetPtr() = 0;

    virtual TProxyExtendedInterfaceReleasePtr ProxyExtendedIntReleasePtr() = 0;

    virtual TAny* CreateExtObjectL(const TUid& aExtendedInterfaceUID) = 0;

    virtual void DestroyExtObject(const TUid& aExtendedInterfaceUID) = 0;

    virtual TAny* ImplementationObject() = 0;

protected:

    CInstanceInfo(CUnloadPolicy* aUnloadPolicy);

private:

   	// The Unload Policy for the dll which contains this implementation

	CUnloadPolicy*	iUnloadPolicy;

	};

/**

@internalComponent

Represents an instance of a PLUGIN3 type implementation

*/

NONSHARABLE_CLASS(CInstanceInfoExtended): public CInstanceInfo

{

public:

	static CInstanceInfoExtended* NewL(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy3* aRow);

	void SetObject(TAny* aImplementationObject);

	~CInstanceInfoExtended(); // Release all extended objects (if not already released)

public:

    TUid ImplementationUid() {return iImplementationProxyRow->iImplementationUid;};

    TProxyExtendedInterfaceGetPtrL ProxyExtendedIntGetPtr() {return iImplementationProxyRow->iFuncPtrInterfaceGetL;};

    TProxyExtendedInterfaceReleasePtr ProxyExtendedIntReleasePtr() {return iImplementationProxyRow->iFuncPtrInterfaceRelease;};

    TAny* CreateExtObjectL(const TUid& aExtendedInterfaceUID);

    void DestroyExtObject(const TUid& aExtendedInterfaceUID);

    TAny* ImplementationObject() {return iImplementationObject;};

private:

	CInstanceInfoExtended(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy3* aImplementationProxyRow);

private:

   // Pointer to proxy implementation table row entry that this instance corresponds to.

   // This is where the implementation UID, get and release extended interface function

   // pointers reside.

   const TImplementationProxy3* iImplementationProxyRow;

   // The instantiation interface object for the dll which contains this implementation

   TAny*	iImplementationObject;

   // The created extended object information structure.

   struct TExtendedObjectInfo

	   {

	   // The extended interface UID

       TUid    iExtendedInterfaceUID;

	   // The extended interface object for the this implementation

	   TAny*   iExtendedInterfaceObject;

	   };

    // List of all of the created extended objects for this implementation

	RArray<TExtendedObjectInfo> iExtendedObjectInfo;

	// Friend classes

	friend class TLoadManager_StateAccessor;

};

/**

@internalComponent

Represents an instance of a PLUGIN1 type implementation

*/

NONSHARABLE_CLASS(CInstanceInfoSimple): public CInstanceInfo

{

public:

	static CInstanceInfoSimple* NewL(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy* aImplementationProxyRow);

public:

    TUid ImplementationUid() {return iImplementationProxyRow->iImplementationUid;};

	// The following functions are not required for CInstanceInfoSimple.

	// PLUGIN1 type is not meant to extend interfaces.  	

  	TProxyExtendedInterfaceGetPtrL ProxyExtendedIntGetPtr(){return NULL;};

 	TProxyExtendedInterfaceReleasePtr ProxyExtendedIntReleasePtr(){return NULL;};

 	TAny* CreateExtObjectL(const TUid& /*aExtendedInterfaceUID*/) {return NULL;};

 	void DestroyExtObject(const TUid& /* aExtendedInterfaceUID*/) {};

	TAny* ImplementationObject() {return NULL;}; 

private:

	CInstanceInfoSimple(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy* aImplementationProxyRow);

private:

   // Pointer to proxy implementation table row entry that this instance corresponds to.

   // This is where the implementation UID resides.

   const TImplementationProxy* iImplementationProxyRow;

};

/**

@internalComponent

Manages the loading and unloading of interface implementation groupings.

*/

NONSHARABLE_CLASS(CLoadManager) : public CBase

{

public:

	static CLoadManager* NewL();

	~CLoadManager();

	TBool DestroyedThis(TUid aInstanceKey);

	TBool PolicyArraysEmpty() const ;

	TAny* ImplementationObjectL(const TUid& aUniqueImplementationUid,

							   const TEntry& aEntry,

							   TAny* aCreationParameters,

							   TBool aCreationParamsFlag,

							   TUid& aInstanceKey);

	TAny* GetExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid);

	void ManuallyReleaseExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid);

	void ClearGarbage();

	TUid GetImplementationUidL(TUid aInstanceKey);

private:

	CLoadManager();

	void GetUnloadPolicy(TUid aUniqueImplementationUid,

						 const TEntry& aEntry,

						 CUnloadPolicy*& aPolicy);

	template<typename TImpProxy,typename T> TAny* GetNewLPointerAndProxyTableRowL(TUid aUniqueImplementationUid,

										 TImpProxy*& aImplementationTableEntry,

										 const T aProxy);

	TAny* ImplementationObject1L(const TUid& aUniqueImplementationUid,

						   	     TAny* aCreationParameters,

								 TBool aCreationParamsFlag,

								 TUid& aInstanceKey,

								 CUnloadPolicy* aPolicy,

								 TLibraryFunction& aLibFunctionProxy);

	TAny* ImplementationObject3L(const TUid& aUniqueImplementationUid,

						   	     TAny* aCreationParameters,

								 TBool aCreationParamsFlag,

								 TUid& aInstanceKey,

								 CUnloadPolicy* aPolicy,

								 TLibraryFunction& aLibFunctionProxy);

	TAny* ImplementationObjectL(TAny* aCreationParameters,

								TBool aCreationParamsFlag,

								const TAny* aNewLpointer);

	void CleanupAfterFailure(CUnloadPolicy* aPolicy);

	void Cleanup(CUnloadPolicy* aPolicy);

private:

#ifdef ECOM_TRACE

	/** Instantiation counter for debug trace */

	TInt iDebugInstantiationCounter;

#endif

	/** List of all the UnloadPolicies for objects which have been created */

	RPointerArray<CUnloadPolicy> iAllUnloadPolicies;

	/** Garbage UnloadPolicy which is not in use anymore */

	CUnloadPolicy* iGarbagePolicy;

	// Array of instance information

	RPointerArray<CInstanceInfo> iInstanceInfoList;

	// Make the test State Accessor a friend

	friend class TLoadManager_StateAccessor;

};

#include "loadmanager.inl"

#endif //__LOADMANAGER_H__