// 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:
// SS_METACONNPROV.H
// 
//

/**
 @file
 @internalAll
*/

#ifndef SYMBIAN_SS_METACONNPROV_INTERNAL_H
#define SYMBIAN_SS_METACONNPROV_INTERNAL_H

#include <comms-infras/ss_fact_internal.h>
#include <comms-infras/ss_metaconnprov.h>

namespace ESock
{

class CMetaConnectionProviderBase;

/**
   Configuration classes for Config Access points
*/
class TConfigAccessPointLayer
	{
    public:
	inline TConfigAccessPointLayer() {};
	inline TConfigAccessPointLayer(const TUint aId,
								   const TUid aSCprUid,
								   const TUid aProtocolUid,
								   const TUint iLayerBelow=0,
								   const TBool aTopLevel=EFalse);

	inline TUint Id() const {return iId;}
	inline TUid SCprUid() const {return iSCprUid;}
	inline TUid ProtocolUid() const {return iProtocolUid;}
	inline TUint LayerBelow() const {return iLayerBelow; }
	inline TBool TopLevel() const {return iTopLevel;}

	inline void SetId(const TUint aId) { iId = aId; }
	inline void SetSCprUid(const TUid aUid) { iSCprUid = aUid; }
	inline void SetProtocolUid(const TUid aUid) { iProtocolUid = aUid; }
	inline void SetLayerBelow(const TUint aLayerBelow) { iLayerBelow = aLayerBelow; }
	inline void SetTopLevel(const TBool aTopLevel) { iTopLevel = aTopLevel; }

    private:
	TUint iId;
	TUid iSCprUid;
	TUid iProtocolUid;

	TUint iLayerBelow;
	TBool iTopLevel;
	};

TConfigAccessPointLayer::TConfigAccessPointLayer(const TUint aId, const TUid aSCprUid,
												 const TUid aProtocolUid, const TUint aLayerBelow,
												 const TBool aTopLevel)
	{
	SetId(aId);
	SetSCprUid(aSCprUid);
	SetProtocolUid(aProtocolUid);
	SetLayerBelow(aLayerBelow);
	SetTopLevel(aTopLevel);
	}

class CConfigAccessPointConfig : public CBase, public Meta::SMetaData
	{
    public:
	enum { ETypeId = 0, EUid = 0x102822FF };

	IMPORT_C static CConfigAccessPointConfig* NewL();
	IMPORT_C ~CConfigAccessPointConfig();

	IMPORT_C void AppendLayerL(const TConfigAccessPointLayer& aLayer);
	IMPORT_C TBool LayerExists(const TConfigAccessPointLayer& aLayer) const;
	IMPORT_C void GetTopLayersL(const TUid aScprUid, RPointerArray<TConfigAccessPointLayer>& aTopLayers) const;
	IMPORT_C const TConfigAccessPointLayer& GetLayerL(const TUint aId) const;
	IMPORT_C TUint GetLayerCount() const;

	IMPORT_C void AppendSCprL(const TUid& aUid);
	IMPORT_C const RArray<TUid>& SCprs() const;

	EXPORT_DATA_VTABLE

    private:
	inline CConfigAccessPointConfig() {};

	RArray<TUid> iSCprs;
	RArray<TConfigAccessPointLayer> iLayers;
	};

//
//Factories - container
//
//There are no exports by design. The container is not supposed to be accessed
//synchronously via a function call (other than ReceivedL()).

NONSHARABLE_CLASS(CMetaConnectionFactoryContainer) : public CCommsFactoryContainer
/** Container for meta connection provider factories.
*/
	{
	friend class CMetaConnectionProviderFactoryBase;

#ifdef __X86GCC__
protected:
 	// gcc-mingw does not support declaring friends from different namespaces so we define proxy
 	// functions to do the cast.
    friend CMetaConnectionProviderBase* ESock::__x86gcc_meta_connection_provider_base_cast(Factories::AFactoryObject* aFactoryObject);
    friend const CMetaConnectionProviderBase* ESock::__x86gcc_meta_connection_provider_base_cast(const Factories::AFactoryObject* aFactoryObject);

    enum
        {
        EId = EMetaConnectionFactoryContainer
        };
#elif defined(__GCCXML__)
public:
    enum
        {
        EId = EMetaConnectionFactoryContainer
        };
#else
protected:
    friend CMetaConnectionProviderBase* Factories::factoryobject_cast<CMetaConnectionProviderBase>(Factories::AFactoryObject* aFactoryObject);
    friend const CMetaConnectionProviderBase* Factories::factoryobject_cast<const CMetaConnectionProviderBase>(const Factories::AFactoryObject* aFactoryObject);

    enum
        {
        EId = EMetaConnectionFactoryContainer
        };
#endif

public:
	virtual ~CMetaConnectionFactoryContainer();

public:
	static CMetaConnectionFactoryContainer* NewL();

public:
	CMetaConnectionProviderFactoryBase* Factory(TInt aIndex) const;

protected:
	CMetaConnectionFactoryContainer();
	virtual void ReceivedL(const Messages::TRuntimeCtxId& aSender, const Messages::TNodeId& aRecipient, Messages::TSignatureBase& aMessage);

	};
} // namespace Esock


namespace Factories
{

#ifdef __X86GCC__
 	// gcc-mingw does not support declaring friends from different namespaces so we define proxy
 	// functions to do the cast.
	template <>
	inline ESock::CMetaConnectionProviderBase* factoryobject_cast(AFactoryObject* aFactoryObject)
	    {
	    return ESock::__x86gcc_meta_connection_provider_base_cast(aFactoryObject);
	    };

	template <>
	inline const ESock::CMetaConnectionProviderBase* factoryobject_cast(const AFactoryObject* aFactoryObject)
	    {
	    return ESock::__x86gcc_meta_connection_provider_base_cast(aFactoryObject);
	    }
#else
	// RVCT does not allow the specialisation of template functions in a different namespace from the original
	// so we declare them in the Factories namespace.
	template<>
	inline ESock::CMetaConnectionProviderBase* factoryobject_cast<ESock::CMetaConnectionProviderBase>(Factories::AFactoryObject* aFactoryObject)
	    {
	    return ESock::CMetaConnectionFactoryContainer::EId == static_cast<ESock::CCommsFactoryContainer&>(aFactoryObject->Factory().ParentContainer()).iId?
	    	static_cast<ESock::CMetaConnectionProviderBase*>(aFactoryObject) : NULL;
	    }

	template<>
	inline const ESock::CMetaConnectionProviderBase* factoryobject_cast<const ESock::CMetaConnectionProviderBase>(const Factories::AFactoryObject* aFactoryObject)
	    {
	    return ESock::CMetaConnectionFactoryContainer::EId == static_cast<ESock::CCommsFactoryContainer&>(aFactoryObject->Factory().ParentContainer()).iId?
	    	static_cast<const ESock::CMetaConnectionProviderBase*>(aFactoryObject) : NULL;
	    }
#endif

} //namespace Factories

#endif
// SYMBIAN_SS_METACONNPROV_INTERNAL_H