--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/inc/ss_metaconnprov.h	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,267 @@
+// 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:
+//
+
+/**
+ @file
+ @publishedPartner
+ @released
+*/
+
+#ifndef SYMBIAN_SS_METACONNPROV_H
+#define SYMBIAN_SS_METACONNPROV_H
+
+#define SYMBIAN_NETWORKING_UPS
+
+#include <comms-infras/ss_commsprov.h>
+#include <comms-infras/ss_mmcommsprov.h>
+#include <comms-infras/es_availability.h>
+#include <comms-infras/ss_tiermanager.h>
+#include <comms-infras/ss_nodemessages_mcpr.h>
+#include <ss_fact.h>
+
+class CESockIniData;
+
+#ifdef SYMBIAN_NETWORKING_UPS
+namespace CommsDat
+	{
+	class CMDBSession;
+	class CCDAccessPointRecord;
+	}
+#endif
+
+namespace ESock
+{
+
+const TInt KMetaConnectionFactoryInterfaceUid = 0x10274546;
+
+//
+//RNodeAvailabilityProviderInterface
+class RNodeAvailabilityProviderInterface : public Messages::RNodeInterface
+	{
+public:
+	void SetAvailabilityStatus(const TAvailabilityStatus& aAvailabilityStatus)
+		{
+		iAvailabilityStatus = aAvailabilityStatus;
+		}
+
+	const TAvailabilityStatus& AvailabilityStatus() const
+		{
+		return iAvailabilityStatus;
+		}
+
+protected:
+    TAvailabilityStatus iAvailabilityStatus;
+	};
+
+//
+//RMetaServiceProviderInterface
+class RMetaServiceProviderInterface : public RNodeAvailabilityProviderInterface
+	{
+public:
+	RMetaServiceProviderInterface(const TProviderInfo& aProviderInfo)
+	:	iProviderInfo(aProviderInfo)
+		{
+		}
+
+	const TProviderInfo& ProviderInfo() const
+	    {
+	    return iProviderInfo;
+	    }
+
+protected:
+    TProviderInfo iProviderInfo;
+	};
+
+
+//
+//CMetaConnectionProviderBase
+class TSelectionPrefs;
+class CMetaConnectionProviderFactoryBase;
+class CMetaConnectionProviderBase : public CMMCommsProviderBase, public TCFMcpr
+/** Base class for a meta connection provider.
+*/
+	{
+#ifdef __X86GCC__
+ 	// gcc-mingw does not support declaring friends from different namespaces so we define proxy
+ 	// functions to do the cast.
+	friend CMetaConnectionProviderBase* __x86gcc_meta_connection_provider_base_cast(Factories::AFactoryObject* aFactoryObject);
+	friend const CMetaConnectionProviderBase* __x86gcc_meta_connection_provider_base_cast(const Factories::AFactoryObject* aFactoryObject);
+    friend CMetaConnectionProviderBase* __x86gcc_meta_connection_provider_base_cast(Messages::ANode* aNode);
+    friend CMetaConnectionProviderBase& __x86gcc_meta_connection_provider_base_cast(Messages::ANode& aNode);
+#elif !defined(__GCCXML__)
+	friend CMetaConnectionProviderBase* Messages::mnode_cast<CMetaConnectionProviderBase>(Messages::ANode* aNode);
+	friend CMetaConnectionProviderBase& Messages::mnode_cast<CMetaConnectionProviderBase>(Messages::ANode& aNode);
+#endif
+
+public:
+	IMPORT_C const TProviderInfo& ProviderInfo() const;
+	IMPORT_C void SetProviderInfo(const TProviderInfo& aConnectionInfo);
+	IMPORT_C void ConstructL();
+
+	IMPORT_C RMetaServiceProviderInterface* FindServiceProvider(TUint aAccessPoint);
+
+	IMPORT_C void SetTierManagerL(CTierManagerBase* aTierManager);
+
+	/**
+	  Destruction blocking exists to ensure that a provider will not delete itself while it is still in use.
+	  This scenario occurs when FindOrCreate finds a mcpr which is just about to delete itself (because it
+	  has lost all clients). If this blocking semaphore didn't exist, it would be possible for a deleted
+	  mcpr to be passed to the control client, causing a panic.
+	 */
+	inline TBool BlockingDestroy();
+	/**
+	   Increment blocking destroy semaphore. This should occur immediately after the the selector has found the
+	   provider, generally in the FindOrCreateProviderL method of the selector. */
+	inline void IncrementBlockingDestroy();
+	/**
+	   Decrement blocking destroy semaphore. Occurs when a client joins the provider. Never decrements past zero.
+	*/
+	inline void DecrementBlockingDestroy();
+
+	/**
+	   Meta providers (unlike other providers) are allowed to have write access to their AccessPointConfig
+	   structure provided they know how to do it safely.
+	*/
+	inline RMetaExtensionContainerC& AccessPointConfig();
+
+	inline CTierManagerBase* GetTierManager() const;
+	
+protected:
+	IMPORT_C CMetaConnectionProviderBase(CMetaConnectionProviderFactoryBase& aFactory,
+                                         const TProviderInfo& aProviderInfo,
+                                         const MeshMachine::TNodeActivityMap& aActivityMap);
+	IMPORT_C virtual Messages::RNodeInterface* NewClientInterfaceL(const Messages::TClientType& aClientType, TAny* aClientInfo = NULL);
+	IMPORT_C virtual ~CMetaConnectionProviderBase();
+
+#ifdef SYMBIAN_NETWORKING_UPS
+	IMPORT_C virtual void ShowAccessPointRecordL(CommsDat::CMDBSession* aSession, CommsDat::CCDAccessPointRecord* aApRec);
+#endif //SYMBIAN_NETWORKING_UPS
+
+	void SetAccessPointConfigL();
+
+protected:
+	TProviderInfo iProviderInfo;
+	TInt iBlockingDestroy;
+	CTierManagerBase* iTierManager;
+	};
+
+void CMetaConnectionProviderBase::IncrementBlockingDestroy()
+	{
+	++iBlockingDestroy;
+	}
+
+void CMetaConnectionProviderBase::DecrementBlockingDestroy()
+	{
+	if (iBlockingDestroy > 0)
+		--iBlockingDestroy;
+	}
+
+TBool CMetaConnectionProviderBase::BlockingDestroy()
+	{
+	return (iBlockingDestroy > 0);
+	}
+
+RMetaExtensionContainerC& CMetaConnectionProviderBase::AccessPointConfig()
+	{
+	return CCommsProviderBase::AccessPointConfig();
+	}
+
+CTierManagerBase* CMetaConnectionProviderBase::GetTierManager() const
+	{
+	return iTierManager;
+	}
+
+//
+class CMetaConnectionFactoryContainer;
+
+//
+//Factories - base
+class CMetaConnectionProviderFactoryBase : public CCommsFactoryBase
+/** Base class for all meta connection provider factories. Specifies the interface
+    that all meta connection provider factories must implement. It also provides the
+	ECOM framework (via CCommsFactoryBase) to load meta connection provider factories
+	from other Dynamic Linked Libraries.
+*/
+	{
+public:
+	IMPORT_C virtual ~CMetaConnectionProviderFactoryBase();
+
+protected:
+	IMPORT_C CMetaConnectionProviderFactoryBase(TUid aFactoryUid, CMetaConnectionFactoryContainer& aParentContainer);
+	/** Override this to create a new instance of CMetaConnectionProviderBase
+
+	@return Pointer to the newly created provider
+	@exception Leaves in out of memory conditions */
+	IMPORT_C virtual ACommsFactoryNodeId* DoCreateObjectL(TFactoryQueryBase& aQuery);
+
+	IMPORT_C void DoPostCreationL(ACommsFactoryNodeId* aObject,TFactoryQueryBase& aQuery);
+	};
+
+#ifdef __X86GCC__
+ 	// gcc-mingw does not support declaring friends from different namespaces so we define proxy
+ 	// functions to do the cast...
+
+	enum
+		{
+		EX86GCCMetaConnectionFactoryContainer = 2
+		};
+
+	inline CMetaConnectionProviderBase* __x86gcc_meta_connection_provider_base_cast(Messages::ANode* aNode)
+    	{
+	    return static_cast<CMetaConnectionProviderBase*>(aNode);
+    	}
+
+	inline CMetaConnectionProviderBase& __x86gcc_meta_connection_provider_base_cast(Messages::ANode& aNode)
+    	{
+	    return static_cast<CMetaConnectionProviderBase&>(aNode);
+    	}
+
+	inline CMetaConnectionProviderBase* __x86gcc_meta_connection_provider_base_cast(Factories::AFactoryObject* aFactoryObject)
+    	{
+	    return EX86GCCMetaConnectionFactoryContainer == static_cast<CCommsFactoryContainer&>(aFactoryObject->Factory().ParentContainer()).iId?
+	    	static_cast<CMetaConnectionProviderBase*>(aFactoryObject) : NULL;
+    	}
+
+	inline const CMetaConnectionProviderBase* __x86gcc_meta_connection_provider_base_cast(const Factories::AFactoryObject* aFactoryObject)
+    	{
+	    return EX86GCCMetaConnectionFactoryContainer == static_cast<CCommsFactoryContainer&>(aFactoryObject->Factory().ParentContainer()).iId?
+	    	static_cast<const CMetaConnectionProviderBase*>(aFactoryObject) : NULL;
+    	}
+#endif
+} //namespace ESock
+
+
+#ifdef __X86GCC__
+	namespace Messages
+	{
+ 	// gcc-mingw does not support declaring friends from different namespaces so we define proxy
+ 	// functions to do the cast.
+	template <>
+	inline ESock::CMetaConnectionProviderBase* mnode_cast<ESock::CMetaConnectionProviderBase>(Messages::ANode* aNode)
+		{
+		return ESock::__x86gcc_meta_connection_provider_base_cast(aNode);
+		}
+
+	template <>
+	inline ESock::CMetaConnectionProviderBase& mnode_cast<ESock::CMetaConnectionProviderBase>(Messages::ANode& aNode)
+		{
+		return ESock::__x86gcc_meta_connection_provider_base_cast(aNode);
+		}
+	}
+#endif
+
+#endif //SYMBIAN_SS_METACONNPROV_H
+
+