// Copyright (c) 2007-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:
// interfacetable.h
// THIS WHOLE FILE IS INTERNAL TECHNOLOGY - DO NOT ADD NON-INTERNAL ITEMS
// 
//

/**
 @file
 @internalTechnology
*/

#ifndef SYMBIAN_INTERFACETABLE_INTERNAL_H
#define SYMBIAN_INTERFACETABLE_INTERNAL_H

#include <e32std.h>

const TInt KErrInterfaceNotSupported = -17204;	// Requested interface is not supported by this object

namespace NetInterfaces
{

template<class TINTERFACE> struct TIfStaticFetcherFirstInHierarchy;
class TInterfaceIter;

class TInterfaceControl
/**
This class provides a base for an API extension implementer.
It implements an interface towards the ESock server.

*/
	{
	friend class TIfStaticFetcherFirstInHierarchy<TInterfaceControl>;
	friend class TInterfaceIter;

public:
	struct TFIEntry
		{
		typedef TAny* (*TStaticFetch)(TInterfaceControl*);
		typedef const TFIEntry* (*TStaticNext)();
		TInt iIfId;
		TStaticFetch iFetchFnL;
		TStaticNext iNextFn;
		};

public:
	IMPORT_C TAny* FetchInterfaceL(TInt aInterfaceId);
	IMPORT_C TAny* FetchInterface(TInt aInterfaceId);

protected:
	inline TInterfaceControl();

private:
	TAny* DoFetchInterface(TInt aInterfaceId);

private:
	const TFIEntry* iHead;
	};

TInterfaceControl::TInterfaceControl()
:	iHead(NULL)
	{
	}

/**
	Simple iterator for all the interfaces available via a specified
	TInterfaceControl.

*/
class TInterfaceIter
	{
public:
	IMPORT_C TInterfaceIter(const TInterfaceControl& aItfControl);

	inline TInt ItfId() const
		{
		return iCurrent? iCurrent->iIfId : 0;
		}

	inline TAny* operator++(TInt /*aInd*/)	// postfix
	    {
	    return Next();
		}

	IMPORT_C TAny* operator[](TInt aInd);

private:
	IMPORT_C TAny* Next();

private:
    const TInterfaceControl& iItfControl;
    const TInterfaceControl::TFIEntry* iCurrent;
	};

template <class TINTERFACE>
class TIfStaticFetcherFirstInHierarchy
/**
This class provides a base for the templated hierarchy of
interface fetchers.

*/
	{
public:
    inline static const TInterfaceControl::TFIEntry* IFEntry()
		{
		return NULL;
		}

protected:
	inline explicit TIfStaticFetcherFirstInHierarchy(TInterfaceControl* aInterfaceControl, const TInterfaceControl::TFIEntry* aHead)
		{
		aInterfaceControl->iHead = aHead; //This class is a friend of TInterfaceControl so we can do this
		}
	};

template <class TBASE, class TCLIENT, class TINTERFACE, class TLINK = TBASE>
class TIfStaticFetcher : protected TBASE
/**
Helper templated class used to build a static const linked list of
supported calls to ReturnInterfacePtrL().

*/
	{
public:
	inline static const TInterfaceControl::TFIEntry* IFEntry()
		{
		return &iFIEntry;
		}

protected:
	inline explicit TIfStaticFetcher(TInterfaceControl* aInterfaceControl, const TInterfaceControl::TFIEntry* aHead = NULL)
	:	TBASE(aInterfaceControl,(aHead)?aHead:&iFIEntry)
		{
		}

private:
	inline static TAny* FetchL(TInterfaceControl* aInterfaceControl)
		{
		TINTERFACE* interface;
		TCLIENT* cl = (TCLIENT*)aInterfaceControl;
		cl->ReturnInterfacePtrL(interface);
		return interface;
		}
	static const TInterfaceControl::TFIEntry iFIEntry;
	};

template <class TBASE, class TCLIENT, class TINTERFACE, class TLINK>
const TInterfaceControl::TFIEntry TIfStaticFetcher<TBASE,TCLIENT,TINTERFACE,TLINK>::iFIEntry =
	{
	TINTERFACE::KInterfaceId,
	&TIfStaticFetcher<TBASE,TCLIENT,TINTERFACE,TLINK>::FetchL,
	&TLINK::IFEntry
	};

template <class TBASE, class TCLIENT, class TINTERFACE>
class TIfStaticFetcherLinkBase : protected TBASE
/**
This template works like TIfStaticFetcher, but doesn't use a TLINK. This means that in the
template name TLINK will not be expanded twice. The double expansion was causing linking problems
with armlink. By using this class in ITFHIERARCHY_LINK_1, the final expansion will be shortened,
and the linker bug will be avoided.
This code is only here because of this bug.
-IBK

*/
	{
public:
	inline static const TInterfaceControl::TFIEntry* IFEntry()
		{
		return &iFIEntry;
		}

protected:
	inline explicit TIfStaticFetcherLinkBase(TInterfaceControl* aInterfaceControl, const TInterfaceControl::TFIEntry* aHead = NULL)
	:	TBASE(aInterfaceControl,(aHead)?aHead:&iFIEntry)
		{
		}

private:
	inline static TAny* FetchL(TInterfaceControl* aInterfaceControl)
		{
		TINTERFACE* interface;
		TCLIENT* cl = (TCLIENT*)aInterfaceControl;
		cl->ReturnInterfacePtrL(interface);
		return interface;
		}
	static const TInterfaceControl::TFIEntry iFIEntry;
	};

template <class TBASE, class TCLIENT, class TINTERFACE>
const TInterfaceControl::TFIEntry TIfStaticFetcherLinkBase<TBASE,TCLIENT,TINTERFACE>::iFIEntry =
	{
	TINTERFACE::KInterfaceId,
	&TIfStaticFetcherLinkBase<TBASE,TCLIENT,TINTERFACE>::FetchL,
	&TBASE::IFEntry
	};



class AApiExtBase
/**
*/
	{
public:
	IMPORT_C NetInterfaces::TInterfaceControl* FetchExtInterfaceControlL(TInt aInterfaceId);
	IMPORT_C TAny* FetchExtInterfaceL(TInt aInterfaceId); //Never returns NULL
	IMPORT_C TAny* FetchExtInterface(TInt aInterfaceId); //May return NULL
	IMPORT_C TBool SupportsExtInterface(TInt aInterfaceId) const;
	
protected:
	IMPORT_C virtual NetInterfaces::TInterfaceControl* DoFetchInterfaceControlL(TInt aInterfaceId);
	};

}	// namespace NetInterfaces

#endif
	//SYMBIAN_INTERFACETABLE_INTERNAL_H