// Copyright (c) 2005-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
 @internalTechnology
*/

#ifndef SS_DISPATCHERS_H
#define SS_DISPATCHERS_H

#include <elements/nm_node.h>
#include <comms-infras/ss_nodeinterfaces.h>
#include <comms-infras/ss_common.h>

namespace ESock
{

//in-process,in/cross-thread node extension message
struct TCFItfExt
    {
protected:
	explicit TCFItfExt()
		{
		}

	IMPORT_C void ForwardMessageL(const Messages::TRuntimeCtxId& aSender,
	                              Messages::TSignalBase& aMessage,
	                              Messages::ANode& aNode,
	                              const Messages::TClientType& aClientType,
	                              const Messages::TClientType& aClientTypeExclude = Messages::TClientType(0, Messages::TClientType::ELeaving));
    IMPORT_C TAny* FetchInterfaceL(Messages::ANode& aNode, TInt aInterface);
	IMPORT_C TAny* FetchInterfaceOrForwardMsgL(const Messages::TRuntimeCtxId& aSender,
	                                           Messages::TSignalBase& aMessage,
	                                           Messages::ANode& aNode, TInt aInterface,
	                                           const Messages::TClientType& aClientType,
	                                           const Messages::TClientType& aClientTypeExclude = Messages::TClientType(0, Messages::TClientType::ELeaving));
	IMPORT_C NetInterfaces::TInterfaceControl* FetchInterfaceControlOrForwardMsgL(const Messages::TRuntimeCtxId& aSender,
	                                                                              Messages::TSignalBase& aMessage,
	                                                                              Messages::ANode& aNode,
																				  TInt aInterface,
									  		   		  							  const Messages::TClientType& aClientType,
									  		   		  							  const Messages::TClientType& aClientTypeExclude = Messages::TClientType(0, Messages::TClientType::ELeaving));
    };

template <TUint32 CLIENT_TYPE, TUint32 CLIENT_FLAGS = 0, TUint32 CLIENT_TYPE_EXCLUDE = 0, TUint32 CLIENT_FLAGS_EXCLUDE = Messages::TClientType::ELeaving>
struct TCFClientItfExt : protected TCFItfExt
    {
protected:
	explicit TCFClientItfExt()
	:	TCFItfExt()
		{
		}

	inline void ForwardMessageL(const Messages::TRuntimeCtxId& aSender, Messages::TSignalBase& aMessage, Messages::ANode& aNode)
		{
		TCFItfExt::ForwardMessageL(aSender, aMessage, aNode, Messages::TClientType(CLIENT_TYPE,CLIENT_FLAGS), Messages::TClientType(CLIENT_TYPE_EXCLUDE,CLIENT_FLAGS_EXCLUDE));
		}

	inline TAny* FetchInterfaceOrForwardMsgL(const Messages::TRuntimeCtxId& aSender, Messages::TSignalBase& aMessage, Messages::ANode& aNode, TInt aInterface)
		{
		return TCFItfExt::FetchInterfaceOrForwardMsgL(aSender, aMessage, aNode, aInterface, Messages::TClientType(CLIENT_TYPE,CLIENT_FLAGS), Messages::TClientType(CLIENT_TYPE_EXCLUDE,CLIENT_FLAGS_EXCLUDE));
		}

	inline NetInterfaces::TInterfaceControl* FetchInterfaceControlOrForwardMsgL(const Messages::TRuntimeCtxId& aSender, Messages::TSignalBase& aMessage, Messages::ANode& aNode, TInt aInterface)
		{
		return TCFItfExt::FetchInterfaceControlOrForwardMsgL(aSender, aMessage, aNode, aInterface, Messages::TClientType(CLIENT_TYPE,CLIENT_FLAGS), Messages::TClientType(CLIENT_TYPE_EXCLUDE,CLIENT_FLAGS_EXCLUDE));
		}
    };

//TCFClientItfExt and its hierarchy is supposed to have 0 lenght (when merged into a hierarchy that is).
//There are several functions taking (for example) TCFSigRMessage2Ext as Messages::TSignalBase
//which explicitly work with this assumtion. If considering adding data members to TCFClientItfExt
//hierarchy, find and fix all of these functions.
class TCFClientItfExtSizeTest : public Messages::TSignalBase, public TCFItfExt {};
__ASSERT_COMPILE(sizeof(TCFClientItfExtSizeTest)==sizeof(Messages::TSignalBase));

/**
	Template to assemble a function dispatching message suitable for use as a MESSAGE
	template parameter of the TCFMessageDispatcher template.
*/
template <TInt INTERFACE_ID, class INTERFACE, typename PARAM_STRUCT,
          TUint32 CLIENT_TYPE, TUint32 CLIENT_FLAGS = 0, TUint32 CLIENT_TYPE_EXCLUDE = 0, TUint32 CLIENT_FLAGS_EXCLUDE = 0>
struct TCFFunctionDispatcher : public TCFClientItfExt<CLIENT_TYPE, CLIENT_FLAGS, CLIENT_TYPE_EXCLUDE, CLIENT_FLAGS_EXCLUDE>
    {
protected:
    typedef void (INTERFACE::*TFunction)(PARAM_STRUCT&);

public:
    explicit TCFFunctionDispatcher()
    :	TCFClientItfExt<CLIENT_TYPE, CLIENT_FLAGS, CLIENT_TYPE_EXCLUDE, CLIENT_FLAGS_EXCLUDE>()
        {
        }

	explicit TCFFunctionDispatcher(TFunction aFunction, const PARAM_STRUCT& aParams)
	:	TCFClientItfExt<CLIENT_TYPE, CLIENT_FLAGS, CLIENT_TYPE_EXCLUDE, CLIENT_FLAGS_EXCLUDE>(),
		iParam(aParams),
		iFunction(aFunction)
		{
		}

protected:
	void DispatchL(Messages::TSignalBase& aThisDispatcher, Messages::ANode* aItf, TPtrC8& /* aParams */)
        {
        INTERFACE* itf = reinterpret_cast<INTERFACE*>(TCFClientItfExt<CLIENT_TYPE, CLIENT_FLAGS, CLIENT_TYPE_EXCLUDE, CLIENT_FLAGS_EXCLUDE>::FetchInterfaceOrForwardMsgL(aThisDispatcher, *aItf, INTERFACE_ID));
        if (itf)
            {
            (itf->*iFunction)(iParam);
            }
        }
    PARAM_STRUCT iParam;
    TFunction iFunction;
    };

/* Example of using TCFFunctionDispatcher in combination with TCFMessageDispatcher
Interface Id must be in api_ext_list.h enum TInt.

Let's assume it's EApiExtSomeInterface

*.h file would contain

// The extension interface declaration (functions must follow the signature pattern given by TCFFunctionDispatcher)
class MSomeExtensionInterface
    {
    public:
    virtual Fn1(TSomeParametersNotMemoryAllocated& aParam) = 0;
    virtual Fn2(TSomeOtherParametersNotMemoryAllocated& aParam) = 0;
    };

// The individual structures
struct TSomeParametersNotMemoryAllocated
    {
    TUint iInt;
    TBuf8<20> iBuf;
    };

struct TSomeOtherParametersNotMemoryAllocated
    {
    };

// Declaration of dispatchers
typedef TCFFunctionDispatcher<EApiExtSomeInterface, MSomeExtensionInterface, TSomeParametersNotMemoryAllocated,
                        RNodeInterface::ECtrl> TFDSomeParametersNotMemoryAllocated;

typedef TCFMessageDispatcher<ESomeMessageId, TFDSomeParametersNotMemoryAllocated, Messages::ANode> TMDSomeParametersNotMemoryAllocated;

// There is a way how to get ESomeMessageId in case it needs to be unique amongst other messages

****.cpp file would contain

// The interface Uid
const TInt KSomeExtensionInterfaceUid = 0xDEADBEEF

// The interface messages implementation table
const TImplementationProxy SomeParametersImplementationTable[] =
	{
	MVIP_CTR_ENTRY(ESomeParam1, TMDSomeParametersNotMemoryAllocated),
	MVIP_CTR_ENTRY(ESomeParam2, TMDSomeOtherParametersNotMemoryAllocated),
	};

// Constructors
DEFINE_MVIP_CTR(TMDSomeParametersNotMemoryAllocated);
DEFINE_MVIP_CTR(TMDSomeOtherParametersNotMemoryAllocated);

// Attribute table(s)
START_ATTRIBUTE_TABLE(TMDSomeParametersNotMemoryAllocated, KSomeExtensionInterfaceUid, ESomeParam1)
	REGISTER_ATTRIBUTE(TTMDSomeParametersNotMemoryAllocated, iInt, TMetaNumber)
	REGISTER_ATTRIBUTE(TMDSomeParametersNotMemoryAllocated, iBuf, TMeta<TBuf8<20>>)
END_ATTRIBUTE_TABLE_BASE(Messages::TSignalBase, 0)

START_ATTRIBUTE_TABLE(TMDSomeOtherParametersNotMemoryAllocated, KSomeExtensionInterfaceUid, ESomeParam2)
END_ATTRIBUTE_TABLE_BASE(Messages::TSignalBase, 0)

// The registration functions
void TSomeExtInterfaceMessageTables::RegisterL()
	{
	TlsGlobals().RegisterInterfaceL(TUid::Uid(KSomeExtensionInterfaceUid), sizeof(SomeParametersImplementationTable) / sizeof(SignatureImplementationTable[0]), SomeParametersImplementationTable);
	}

void TSomeExtInterfaceMessageTables::DeRegister()
	{
	TlsGlobals().DeregisterInterface(TUid::Uid(KSomeExtensionInterfaceUid));
	}

**/

//most common signature for messages originating on user side
class TCFSigRMessage2Ext : public Messages::TSignalBase, public TCFClientItfExt<TCFClientType::ECtrl>
    {
protected:
    TCFSigRMessage2Ext(const RMessage2& aMessage)
    :   TCFClientItfExt<TCFClientType::ECtrl>(),
        iMessage(aMessage)
            {
            }

    TCFSigRMessage2Ext()
    	{
    	}

protected:
	IMPORT_C virtual void Error(const Messages::TRuntimeCtxId& aSender, const Messages::TRuntimeCtxId& aRecipient, TInt aError);

protected:
    RMessage2 iMessage;

public:
    EXPORT_DATA_VTABLE_AND_FN
    };

} //namespace ESock

#endif
// SS_DISPATCHERS_H