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

// nm_signature.h

// 

//

/**

 @file

 @publishedPartner

 @released

*/

#ifndef SYMBIAN_NM_SIGNATURES_H

#define SYMBIAN_NM_SIGNATURES_H

#include <elements/nm_signals.h>

#include <elements/nm_interfaces.h>

#include <elements/metatype.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ElemNodeMessSigH, "ElemNodeMessSigH");

#endif

#define DECLARE_MESSAGE_SIG_1( sig, type, name ) \

struct T##sig : public Messages::TSignatureBase \

    { \

protected: \

    inline T##sig() {} \

    explicit T##sig( const Messages::TNodeSignal::TMessageId& aMessageId, type a##name ) : \

        Messages::TSignatureBase(aMessageId), \

        i##name(a##name) \

	    {} \

public: \

	   DECLARE_MVIP_CTR( T##sig ) \

   	   EXPORT_DATA_VTABLE_AND_FN \

	   type i##name; \

    }; \

template<TInt id, TInt32 realm> \

struct TMessage##sig : public T##sig, public Messages::TSignatureBase::TTypeToMessageId<id, realm> \

    { \

	explicit TMessage##sig(type a##name ) : \

	    T##sig(Messages::TNodeSignal::TMessageId(id, realm), a##name) \

	    {} \

    };

#define DECLARE_MESSAGE_SIG_2( sig, type, name, type2, name2 ) \

struct T##sig : public Messages::TSignatureBase \

    { \

protected: \

	inline T##sig() {} \

	explicit T##sig( const Messages::TNodeSignal::TMessageId& aMessageId, type a##name, type2 a##name2 ) : \

	   Messages::TSignatureBase(aMessageId), \

	   i##name(a##name), \

	   i##name2(a##name2) \

	    {} \

public: \

	   DECLARE_MVIP_CTR( T##sig ) \

   	   EXPORT_DATA_VTABLE_AND_FN \

	   type i##name; \

	   type2 i##name2; \

    }; \

template<TInt id, TInt32 realm> \

struct TMessage##sig : public T##sig, public Messages::TSignatureBase::TTypeToMessageId<id, realm> \

    { \

	explicit TMessage##sig(type a##name, type2 a##name2 ) : \

	    T##sig(Messages::TNodeSignal::TMessageId(id, realm), a##name, a##name2) \

        {} \

    };

#define DECLARE_MESSAGE_SIG_3( sig, type, name, type2, name2, type3, name3 ) \

struct T##sig : public Messages::TSignatureBase \

    { \

protected: \

	inline T##sig() {} \

	explicit T##sig( const Messages::TNodeSignal::TMessageId& aMessageId, type a##name, type2 a##name2, type3 a##name3 ) : \

	   Messages::TSignatureBase(aMessageId), \

	   i##name(a##name), \

	   i##name2(a##name2), \

	   i##name3(a##name3) \

	    {} \

public: \

	   DECLARE_MVIP_CTR( T##sig ) \

   	   EXPORT_DATA_VTABLE_AND_FN \

	   type i##name; \

	   type2 i##name2; \

	   type3 i##name3; \

    }; \

template<TInt id, TInt32 realm> \

struct TMessage##sig : public T##sig, public Messages::TSignatureBase::TTypeToMessageId<id, realm> \

    { \

	explicit TMessage##sig(type a##name, type2 a##name2, type3 a##name3 ) : \

	    T##sig(Messages::TNodeSignal::TMessageId(id, realm), a##name, a##name2, a##name3) \

        {} \

    };

#define DECLARE_MESSAGE_SIG_4( sig, type, name, type2, name2, type3, name3, type4, name4 ) \

struct T##sig : public Messages::TSignatureBase \

    { \

protected: \

	inline T##sig() {} \

	explicit T##sig( const Messages::TNodeSignal::TMessageId& aMessageId, type a##name, type2 a##name2, type3 a##name3, type4 a##name4 ) : \

	   Messages::TSignatureBase(aMessageId), \

	   i##name(a##name), \

	   i##name2(a##name2), \

	   i##name3(a##name3), \

	   i##name4(a##name4) \

	    {} \

public: \

	   DECLARE_MVIP_CTR( T##sig ) \

   	   EXPORT_DATA_VTABLE_AND_FN \

	   type i##name; \

       type2 i##name2; \

       type3 i##name3; \

	   type4 i##name4; \

    }; \

template<TInt id, TInt32 realm> \

struct TMessage##sig : public T##sig, public Messages::TSignatureBase::TTypeToMessageId<id, realm> \

    { \

	explicit TMessage##sig(type a##name, type2 a##name2, type3 a##name3, type4 a##name4 ) : \

	    T##sig(Messages::TNodeSignal::TMessageId(id, realm), a##name, a##name2, a##name3, a##name4) \

	    {} \

    };

namespace Messages

{

//-=========================================================

//

// TNodeSignal

//

//-=========================================================

class TNodeSignal : public TSignalBase

	{

public:

    class TMessageId

        {

        friend class TNodeSignal;

    public:

		typedef TUint TRealm;

        TBool operator==(const TMessageId& aMessageId) const

            {

            return aMessageId.iRealm == iRealm && aMessageId.iId == iId;

            }

        TBool operator!=(const TMessageId& aMessageId) const

            {

            return !((*this) == aMessageId);

            }

        TMessageId& operator=(const TMessageId& aMessageId)

            {

            iId = aMessageId.iId;

            iRealm = aMessageId.iRealm;

            return *this;

            }

        TUint MessageId() const

            {

            return iId;

            }

        TRealm Realm() const

            {

            return iRealm;

            }

        TBool IsNull() const

            {

            return MessageId() == KNullMessageId;

            }

        TMessageId(TUint aId, TRealm aRealm)

        :	iId(aId), iRealm(aRealm)

        	{ __ASSERT_DEBUG(!(aId & 0xFFFF0000), User::Panic(KSpecAssert_ElemNodeMessSigH, 1)); }

        TMessageId()

        :	iId(KNullMessageId), iRealm(0)

        	{}

    private:

        TUint16 iId;

        TRealm  iRealm;   //determines the realm for the iMessageId

                          //to avoid clashes with other realms.protected:

        };

    template<TInt id, TMessageId::TRealm realm>

    struct TTypeToMessageId

        {

        enum

            {

            EId    = id,

            ERealm = realm,

            };

        inline static TMessageId Id()

            {

            return TMessageId(id,realm);

            }

        };

	typedef TTypeToMessageId<KNullMessageId, 0> TNullMessageId;

	template<typename MSG>

	TBool IsMessage()

		{

		return iMessageId.iId == MSG::EId && iMessageId.iRealm == MSG::ERealm;

		}

protected:

	//We need to define the constructor or the PlacementNew (DECLARE_MVIP_CTR)

	//will use a default one. (And initialise attributes to 0xCCCCCCCC etc).

	TNodeSignal()

	:	TSignalBase()

		{

		}

	explicit TNodeSignal(const TMessageId& aMessageId)

	:	TSignalBase(),

	    iMessageId(aMessageId)

		{

		}

public:

	const TMessageId& MessageId() const

	    {

	    return iMessageId;

	    }

	void ClearMessageId()

	    {

	    iMessageId = TMessageId();

	    }

private:

	mutable TMessageId iMessageId;

public:

	EXPORT_DATA_VTABLE_AND_FN

	};

//-=========================================================

//

// message_cast

//

//-=========================================================

template <class MESSAGE>

MESSAGE& message_cast(Messages::TNodeSignal& aMessage)

    {

    __ASSERT_DEBUG(aMessage.MessageId() == MESSAGE::Id() && aMessage.IsTypeOf(Meta::STypeId(MESSAGE::TypeId())), User::Panic(Messages::KMessagesPanic,Messages::EMessageCastPanic));

    return static_cast<MESSAGE&>(aMessage);

    }

template <class MESSAGE>

const MESSAGE& message_cast(const Messages::TNodeSignal& aMessage)

    {

    __ASSERT_DEBUG(aMessage.MessageId() == MESSAGE::Id() && aMessage.IsTypeOf(Meta::STypeId(MESSAGE::TypeId())), User::Panic(Messages::KMessagesPanic,Messages::EMessageCastPanic));

    return static_cast<const MESSAGE&>(aMessage);

    }

template <class MESSAGE>

MESSAGE* message_cast(Messages::TNodeSignal* aMessage)

    {

    __ASSERT_DEBUG(aMessage ,User::Panic(Messages::KMessagesPanic,Messages::EMessageCastPanic));

    return (aMessage->MessageId() == MESSAGE::Id() && aMessage->IsTypeOf(Meta::STypeId(MESSAGE::TypeId()))) ?

    	static_cast<MESSAGE*>(aMessage) :

    	NULL;

    }

template <class MESSAGE>

const MESSAGE* message_cast(const Messages::TNodeSignal* aMessage)

    {

    __ASSERT_DEBUG(aMessage,User::Panic(Messages::KMessagesPanic,Messages::EMessageCastPanic));

    return (aMessage->MessageId() == MESSAGE::Id() && aMessage->IsTypeOf(Meta::STypeId(MESSAGE::TypeId()))) ?

	    static_cast<const MESSAGE*>(aMessage) :

	    NULL;

    }

//

// TSignatureBase

//

class TSignatureBase : public TNodeSignal

	{

public:

	IMPORT_C virtual void DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient);

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

protected:

	//We need to define the constructor or the PlacementNew (DECLARE_MVIP_CTR)

	//will use a default one. (And initialise attributes to 0xCCCCCCCC etc).

	IMPORT_C explicit TSignatureBase();

	IMPORT_C explicit TSignatureBase(const TNodeSignal::TMessageId& aMessageId);

private:

	//Forbidden ops.

	TSignatureBase(const TSignatureBase&);

	TSignatureBase& operator=(TSignatureBase);

public:

	DECLARE_MVIP_CTR(TSignatureBase)

	EXPORT_DATA_VTABLE_AND_FN

	// GCC enforces the C++ ISO standard rule that a class expose a public copy constructor

	// if a temporary variable is passed as a parameter to a function by reference like this:

	//

	// Func( TMessage() ); // will not compile since the copy constructor is private

	//

	// As this class does not, we provide this CRef function so a temporary can still be

	// passed like this:

	//

	// Func( TMessage().CRef() ); // use CRef() instead

	const TSignatureBase& CRef() const

		{

		return *this;

		}

	};

//

// Signature classes

//

template<TInt id, TInt32 realm>

struct TMessageSigVoid : public Messages::TSignatureBase, public Messages::TSignatureBase::TTypeToMessageId<id, realm>

    {

	explicit TMessageSigVoid() :

	    Messages::TSignatureBase(Messages::TNodeSignal::TMessageId(id, realm))

	    { }

    };

DECLARE_MESSAGE_SIG_1(SigNumber, TInt, Value)

DECLARE_MESSAGE_SIG_1(SigUid, TUid, Uid)

DECLARE_MESSAGE_SIG_1(SigAny, TAny*, Ptr)

DECLARE_MESSAGE_SIG_1(SigNodeId, TNodeId, NodeId)

DECLARE_MESSAGE_SIG_1(SigRMessage2, const RMessage2, Message)

DECLARE_MESSAGE_SIG_1(SigMetaDataPtr, Meta::SMetaData*, Ptr)

DECLARE_MESSAGE_SIG_1(SigClientType, Messages::TClientType, ClientType)

DECLARE_MESSAGE_SIG_1(SigMessageId, TNodeSignal::TMessageId, MsgId)

DECLARE_MESSAGE_SIG_1(SigTypeId, Meta::STypeId, TypeId)

DECLARE_MESSAGE_SIG_2(SigNodeIdNumber, TNodeId, NodeId, TInt, Value)

DECLARE_MESSAGE_SIG_2(SigNodeIdClientType, TNodeId, NodeId, TClientType, ClientType)

DECLARE_MESSAGE_SIG_2(SigNumberNumber, TInt, Value1, TInt, Value2)

DECLARE_MESSAGE_SIG_2(SigAnyNumber, TAny*, Ptr, TInt, Value)

DECLARE_MESSAGE_SIG_2(SigUidNumber, TUid, Uid, TInt, Value)

DECLARE_MESSAGE_SIG_2(SigNodeIdAny, TNodeId, NodeId, TAny*, Ptr)

DECLARE_MESSAGE_SIG_2(SigNodeIdNodeId, TNodeId, NodeId1, TNodeId, NodeId2)

DECLARE_MESSAGE_SIG_2(SigNumberRMessage2, TInt, Value, RMessage2, Message)

DECLARE_MESSAGE_SIG_2(SigClientTypeUid, Messages::TClientType, ClientType, TUid, Uid)

DECLARE_MESSAGE_SIG_2(SigMessageIdNumber, TNodeSignal::TMessageId, MsgId, TInt, Value)

DECLARE_MESSAGE_SIG_3(SigNodeIdNumberNumber, TNodeId, NodeId, TInt, Value1, TInt, Value2)

DECLARE_MESSAGE_SIG_3(SigNumberNumberNumber, TInt, Value1, TInt, Value2, TInt, Value3)

DECLARE_MESSAGE_SIG_3(SigNodeIdNodeIdNumber, TNodeId, NodeId1, TNodeId, NodeId2, TInt, Value)

DECLARE_MESSAGE_SIG_3(SigNumberUidNumber, TInt, Value1, TUid, Uid, TInt, Value2)

DECLARE_MESSAGE_SIG_3(SigClientTypeUidClientType, Messages::TClientType, ClientType1, TUid, Uid, Messages::TClientType, ClientType2)

DECLARE_MESSAGE_SIG_3(SigTypeIdAnyNumber, Meta::STypeId, TypeId, TAny*, Ptr, TInt, Value)

DECLARE_MESSAGE_SIG_4(SigNumberNumberNumberNumber, TInt, Value1, TInt, Value2, TInt, Value3, TInt, Value4)

DECLARE_MESSAGE_SIG_4(SigNodeIdNumberNumberNumber, TNodeId, NodeId, TInt, Value1, TInt, Value2, TInt, Value3)

template<TInt id, TInt32 realm>

class TMessageExtensionRMessage2 : public TSigNumberRMessage2, public TSignatureBase::TTypeToMessageId<id, realm>

    {

public:

	TMessageExtensionRMessage2(TInt aMsgId, const RMessage2& aMessage)

	:	TSigNumberRMessage2(TNodeSignal::TMessageId(id, realm), aMsgId, aMessage) {}

	inline TInt ExtensionMsgId() const

		{

		return iValue;

		}

protected:

	TMessageExtensionRMessage2()

	:	TSigNumberRMessage2()

		{}

    };

template<TInt id, TInt32 realm, TInt defValue = 0>

class TMessageSigNumberDefault : public TSigNumber, public TSignatureBase::TTypeToMessageId<id, realm>

    {

public:

    enum { EDefValue = defValue };

	TMessageSigNumberDefault(TInt aValue = defValue)

	:	TSigNumber(TNodeSignal::TMessageId(id, realm), aValue)

		{}

    };

template<TInt id, TInt32 realm, TInt defValue = 0>

class TMessageSigNumberNumberDefault : public TSigNumberNumber, public TSignatureBase::TTypeToMessageId<id, realm>

    {

public:

    enum { EDefValue = defValue };

	TMessageSigNumberNumberDefault(TInt aValue1, TInt aValue2 = defValue)

	:	TSigNumberNumber(TNodeSignal::TMessageId(id, realm), aValue1, aValue2)

		{}

    };

template<TInt id, TInt32 realm, TInt defValue1 = 0, TInt defValue2 = 0>

class TMessageSigNumberDefaultNumberDefault : public TSigNumberNumber, public TSignatureBase::TTypeToMessageId<id, realm>

    {

public:

    enum { EDefValue1 = defValue1, EDefValue2 = defValue2 };

	TMessageSigNumberDefaultNumberDefault(TInt aValue1 = defValue1, TInt aValue2 = defValue2)

	:	TSigNumberNumber(TNodeSignal::TMessageId(id, realm), aValue1, aValue2)

		{}

    };

template<TInt id, TInt32 realm, TInt defValue = 0>

class TMessageSigAnyNumberDefault : public TSigAnyNumber, public TSignatureBase::TTypeToMessageId<id, realm>

    {

public:

    enum { EDefValue = defValue };

	TMessageSigAnyNumberDefault(TAny* aPtr, TInt aValue = defValue)

	:	TSigAnyNumber(TNodeSignal::TMessageId(id, realm), aPtr, aValue)

		{}

    };

template<TInt id, TInt32 realm, TInt defValue1 = 0>

class TMessageSigNodeIdNumberDefault : public TSigNodeIdNumber, public TSignatureBase::TTypeToMessageId<id, realm>

    {

public:

    TMessageSigNodeIdNumberDefault(const TNodeId& aNodeId, TInt aValue = defValue1)

    :   TSigNodeIdNumber(TNodeSignal::TMessageId(id, realm), aNodeId, aValue)

        {}

    };

template<TInt id, TInt32 realm, TInt defValue1 = 0, TInt defValue2 = 0>

class TMessageSigNodeIdNumberDefaultNumberDefault : public TSigNodeIdNumberNumber, public TSignatureBase::TTypeToMessageId<id, realm>

    {

public:

	TMessageSigNodeIdNumberDefaultNumberDefault(const TNodeId& aNodeId, TInt aValue1 = defValue1, TInt aValue2 = defValue2)

	:	TSigNodeIdNumberNumber(TNodeSignal::TMessageId(id, realm), aNodeId, aValue1, aValue2)

		{}

    };

template<TInt id, TInt32 realm>

struct TMessageSigNum24Num8 : protected TSigNumber, public TSignatureBase::TTypeToMessageId<id, realm>

    {

	explicit TMessageSigNum24Num8(TInt aValue24, TInt aValue8) :

	    TSigNumber(TNodeSignal::TMessageId(id, realm), (aValue24<<8)|(aValue8&0xFF)){}

	TUint Value24() const { return iValue>>8;}

	TUint Value8() const { return iValue&0xFF;}

    };

//

// Signature classes - helper classes

//

class TVCFromGlobalsMessagePayloadCreationPolicy

	{

public:

	IMPORT_C static Meta::SMetaData* New(TPtrC8& aSrc, TPtr8& aDst);

	};

class TSignatureWithPolymorphicPayloadMetaTypeBase : public Meta::MMetaType

	{

protected:

	IMPORT_C TSignatureWithPolymorphicPayloadMetaTypeBase(TUint8* aData, Meta::SMetaData** aPayload, TInt aHostSize);

	IMPORT_C TInt InternalLoad(TPtrC8& aBuffer, TDes8& aTempBuffer);

	IMPORT_C virtual TInt Store(TDes8& aBuffer) const;

	IMPORT_C virtual void Copy(const TAny* aData);

	IMPORT_C virtual TInt Length() const;

protected:

	TUint8* iData;

	Meta::SMetaData** iPayload;

	TInt iHostSize;

	};

/**

The class that determins how the payload will be loaded. A templated class that says the payload attribute offset and

the payload atrribute creation class ( Policy class ). The loading of the payload will be determined by the attribute

creation class.

Template parameters:

class TSIGNATURE - The signature class.

TInt PAYLOADATTRIBOFFSET - The offset where the payload is persent in the signature class.

class TATTRIBUTECREATIONPOLICY - This class determines how the payload should be constructued. The attribute policty class

should implement the Meta::SMetaData* New(TPtrC8& aSrc, TPtr8& aDst) function.

TInt PAYLOADBUFFERMAXLEN - The maximum payload length. Used internally during the load time.

@internalTechnology

*/

template <class TSIGNATURE, TInt PAYLOADATTRIBOFFSET, class TATTRIBUTECREATIONPOLICY, TInt PAYLOADBUFFERMAXLEN = TSignalBase::KMaxInlineMessageSize>

class TSignatureWithPolymorphicPayloadMetaType : public TSignatureWithPolymorphicPayloadMetaTypeBase

{

public:

	inline static MMetaType* NewL(const TAny* aMem, const TAny* aData)

		{

		// For some reason this assertion does not compile under x86gcc which complains

		// that a default template argument has been specified for a templated member

		// function.  There is no such function so this is probably a parser bug.

		#if !defined(__GCCXML__) && !defined(__X86GCC__)

			__ASSERT_COMPILE(PAYLOADATTRIBOFFSET == __Align8(PAYLOADATTRIBOFFSET)); //must be alligned!

		#endif

		return ::new ((TUint8*)aMem) TSignatureWithPolymorphicPayloadMetaType(aData);

		}

	inline virtual TInt Load(TPtrC8& aBuffer)

		{

		TBuf8<PAYLOADBUFFERMAXLEN> buffer;

		TInt error = TSignatureWithPolymorphicPayloadMetaTypeBase::InternalLoad(aBuffer, buffer);

		if (error == KErrNone && buffer.Length() > 0)

			{

			TPtrC8 src(buffer);

			TPtr8 dst(iData + iHostSize, buffer.Length()); //always enough since the STypeId is bigger than the virtual table ptr etc

			*iPayload = TATTRIBUTECREATIONPOLICY::New(src, dst);

			}

		return error;

		}

private:

	TSignatureWithPolymorphicPayloadMetaType(const TAny* aData)

	:	TSignatureWithPolymorphicPayloadMetaTypeBase(const_cast<TUint8*>(reinterpret_cast<const TUint8*>(aData) + sizeof(Meta::SMetaData*) - PAYLOADATTRIBOFFSET),

	                                                 const_cast<Meta::SMetaData**>(reinterpret_cast<Meta::SMetaData* const*>(aData)),

	                                                 sizeof(TSIGNATURE) - sizeof(TSignalBase))

		{