diff -r 000000000000 -r dfb7c4ff071f commsfwsupport/commselements/nodemessages/src/nm_messages.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commsfwsupport/commselements/nodemessages/src/nm_messages.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,443 @@ +// 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: +// + +/** + @file +*/ + +#include "nm_signatures.h" +#include "nm_messages_base.h" +#include "nm_messages_errorrecovery.h" +#include "nm_node.h" +#include +#include + + +#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_ElemNodeMessMesC, "ElemNodeMessMesC"); +#endif + +using namespace Messages; +using namespace Elements; +using namespace Meta; + +//We can safely reuse this UID for signature's TIDs (but they mean different things) +static const TInt KNodeMessagesImplementationUid = TEBase::ERealmId; + +// --- TSignatureBase --- +EXPORT_C TSignatureBase::TSignatureBase() + { + } + +EXPORT_C TSignatureBase::TSignatureBase(const TNodeSignal::TMessageId& aMessageId) +: TNodeSignal(aMessageId) + { + } + +EXPORT_C void TSignatureBase::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient) + { + const TNodeId& nodeId = address_cast(aRecipient); //This message type operates on nodes + __ASSERT_DEBUG(nodeId.Ptr(), User::Panic(KSpecAssert_ElemNodeMessMesC, 1)); + nodeId.Node().ReceivedL(aSender, nodeId, *this); + } + +EXPORT_C void TSignatureBase::Error(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient, TInt aError) + { + NM_LOG((KNodeMessagesSubTag, _L8("TSignatureBase %08x:\tError(%d)"), this, aError)); + if (!aSender.IsNull()) + { + NM_LOG((KNodeMessagesSubTag, _L8("Sending TError"))); + RClientInterface::OpenPostMessageClose(aRecipient, aSender, TEBase::TError(MessageId(), aError).CRef()); + } + } + + +enum EMessageTypeId //message signatures only (NOT messages) messages are declared under class TMessage + { + ESignalBase =0, + ENodeSignal =1, + + ESignatureBase =2, + ESignatureNumber =3, + ESignatureUid =4, + ESignatureErrContext =5, + ESignatureErrResponse =6, + //empty =7, + ESignatureNodeId =8, + ESignatureNodeIdNumber =9, + ESignatureNodeIdNumberNumber =10, + ESignatureMessageIdNumber =11, + ESignatureAnyNumber =12, + ESignatureMetaDataPtr =13, //the data itslef is not copied it stays owned by whoever allocated it + //unless agreed otherwise upon the actuall message + ESignatureNumberNumberNumber =14, + ESignatureRMessage2 =15, + ESignatureNumberRMessage2 =16, + ESignatureAny =17, + ESignatureNumberNumber =18, + ESignatureNodeIdAny =19, + ESignatureNodeIdNodeId =20, + ESignatureNodeIdNodeIdNumber =21, + ESignatureNumberNumberNumberNumber =22, + ESignatureUidNumber =23, + ESignatureNumberUidNumber =24, + ESignatureNodeIdClientType =25, + ESignatureClientTypeUidClientType =26, + ESignatureClientType =27, + ESignatureClientTypeUid =28, + ESignatureMessageId =29, + ESignatureNodeIdNumberNumberNumber =30, + ESignatureTypeId =31, + ESignatureTypeIdAnyNumber =32 + }; + + + + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSignalBase, KNodeMessagesImplementationUid, ESignalBase ) +END_ATTRIBUTE_TABLE() + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TNodeSignal, KNodeMessagesImplementationUid, ENodeSignal ) + REGISTER_ATTRIBUTE( TNodeSignal, iMessageId, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignalBase, ESignalBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSignatureBase, KNodeMessagesImplementationUid, ESignatureBase ) +END_ATTRIBUTE_TABLE_BASE( TNodeSignal, ENodeSignal ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigErrContext, KNodeMessagesImplementationUid, ESignatureErrContext ) + REGISTER_ATTRIBUTE( TSigErrContext, iErrContext, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigErrResponse, KNodeMessagesImplementationUid, ESignatureErrResponse ) + REGISTER_ATTRIBUTE( TSigErrResponse, iErrResponse, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNumber, KNodeMessagesImplementationUid, ESignatureNumber ) + REGISTER_ATTRIBUTE( TSigNumber, iValue, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigUid, KNodeMessagesImplementationUid, ESignatureUid ) + REGISTER_ATTRIBUTE( TSigUid, iUid, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeId, KNodeMessagesImplementationUid, ESignatureNodeId ) + REGISTER_ATTRIBUTE( TSigNodeId, iNodeId, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeIdNumber, KNodeMessagesImplementationUid, ESignatureNodeIdNumber ) + REGISTER_ATTRIBUTE( TSigNodeIdNumber, iNodeId, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdNumber, iValue, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeIdClientType, KNodeMessagesImplementationUid, ESignatureNodeIdClientType ) + REGISTER_ATTRIBUTE( TSigNodeIdClientType, iNodeId, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdClientType, iClientType, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeIdNumberNumber, KNodeMessagesImplementationUid, ESignatureNodeIdNumberNumber ) + REGISTER_ATTRIBUTE( TSigNodeIdNumberNumber, iNodeId, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdNumberNumber, iValue1, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNodeIdNumberNumber, iValue2, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigMessageIdNumber, KNodeMessagesImplementationUid, ESignatureMessageIdNumber ) + REGISTER_ATTRIBUTE( TSigMessageIdNumber, iMsgId, TMeta ) + REGISTER_ATTRIBUTE( TSigMessageIdNumber, iValue, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNumberNumberNumber, KNodeMessagesImplementationUid, ESignatureNumberNumberNumber ) + REGISTER_ATTRIBUTE( TSigNumberNumberNumber, iValue1, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNumberNumberNumber, iValue2, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNumberNumberNumber, iValue3, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNumberNumberNumberNumber, KNodeMessagesImplementationUid, ESignatureNumberNumberNumberNumber ) + REGISTER_ATTRIBUTE( TSigNumberNumberNumberNumber, iValue1, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNumberNumberNumberNumber, iValue2, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNumberNumberNumberNumber, iValue3, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNumberNumberNumberNumber, iValue4, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeIdNodeIdNumber, KNodeMessagesImplementationUid, ESignatureNodeIdNodeIdNumber ) + REGISTER_ATTRIBUTE( TSigNodeIdNodeIdNumber, iNodeId1, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdNodeIdNumber, iNodeId2, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdNodeIdNumber, iValue, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigMetaDataPtr, KNodeMessagesImplementationUid, ESignatureMetaDataPtr ) + REGISTER_ATTRIBUTE( TSigMetaDataPtr, iPtr, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigRMessage2, KNodeMessagesImplementationUid, ESignatureRMessage2 ) + REGISTER_ATTRIBUTE( TSigRMessage2, iMessage, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNumberRMessage2, KNodeMessagesImplementationUid, ESignatureNumberRMessage2 ) + REGISTER_ATTRIBUTE( TSigNumberRMessage2, iValue, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNumberRMessage2, iMessage, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigAny, KNodeMessagesImplementationUid, ESignatureAny ) + REGISTER_ATTRIBUTE( TSigAny, iPtr, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigAnyNumber, KNodeMessagesImplementationUid, ESignatureAnyNumber ) + REGISTER_ATTRIBUTE( TSigAnyNumber, iPtr, TMeta ) + REGISTER_ATTRIBUTE( TSigAnyNumber, iValue, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigUidNumber, KNodeMessagesImplementationUid, ESignatureUidNumber ) + REGISTER_ATTRIBUTE( TSigUidNumber, iUid, TMeta ) + REGISTER_ATTRIBUTE( TSigUidNumber, iValue, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNumberNumber, KNodeMessagesImplementationUid, ESignatureNumberNumber ) + REGISTER_ATTRIBUTE( TSigNumberNumber, iValue1, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNumberNumber, iValue2, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeIdAny, KNodeMessagesImplementationUid, ESignatureNodeIdAny ) + REGISTER_ATTRIBUTE( TSigNodeIdAny, iNodeId, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdAny, iPtr, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeIdNodeId, KNodeMessagesImplementationUid, ESignatureNodeIdNodeId ) + REGISTER_ATTRIBUTE( TSigNodeIdNodeId, iNodeId1, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdNodeId, iNodeId2, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNumberUidNumber, KNodeMessagesImplementationUid, ESignatureNumberUidNumber ) + REGISTER_ATTRIBUTE( TSigNumberUidNumber, iValue1, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNumberUidNumber, iUid, TMeta ) + REGISTER_ATTRIBUTE( TSigNumberUidNumber, iValue2, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigClientTypeUidClientType, KNodeMessagesImplementationUid, ESignatureClientTypeUidClientType ) + REGISTER_ATTRIBUTE( TSigClientTypeUidClientType, iClientType1, TMeta ) + REGISTER_ATTRIBUTE( TSigClientTypeUidClientType, iUid, TMeta ) + REGISTER_ATTRIBUTE( TSigClientTypeUidClientType, iClientType2, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigClientType, KNodeMessagesImplementationUid, ESignatureClientType ) + REGISTER_ATTRIBUTE( TSigClientType, iClientType, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigClientTypeUid, KNodeMessagesImplementationUid, ESignatureClientTypeUid ) + REGISTER_ATTRIBUTE( TSigClientTypeUid, iClientType, TMeta ) + REGISTER_ATTRIBUTE( TSigClientTypeUid, iUid, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigMessageId, KNodeMessagesImplementationUid, ESignatureMessageId ) + REGISTER_ATTRIBUTE( TSigMessageIdNumber, iMsgId, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeIdNumberNumberNumber, KNodeMessagesImplementationUid, ESignatureNodeIdNumberNumberNumber ) + REGISTER_ATTRIBUTE( TSigNodeIdNumberNumberNumber, iNodeId, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdNumberNumberNumber, iValue1, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNodeIdNumberNumberNumber, iValue2, TMetaNumber ) + REGISTER_ATTRIBUTE( TSigNodeIdNumberNumberNumber, iValue3, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigTypeId, KNodeMessagesImplementationUid, ESignatureTypeId ) + REGISTER_ATTRIBUTE( TSigTypeId, iTypeId, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigTypeIdAnyNumber, KNodeMessagesImplementationUid, ESignatureTypeIdAnyNumber ) + REGISTER_ATTRIBUTE( TSigTypeIdAnyNumber, iTypeId, TMeta ) + REGISTER_ATTRIBUTE( TSigTypeIdAnyNumber, iPtr, TMeta ) + REGISTER_ATTRIBUTE( TSigTypeIdAnyNumber, iValue, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +DEFINE_MVIP_CTR(TSignatureBase); +DEFINE_MVIP_CTR(TSigErrContext); +DEFINE_MVIP_CTR(TSigErrResponse); +DEFINE_MVIP_CTR(TSigNumber); +DEFINE_MVIP_CTR(TSigUid); +DEFINE_MVIP_CTR(TSigNodeId); +DEFINE_MVIP_CTR(TSigNodeIdNumber); +DEFINE_MVIP_CTR(TSigNodeIdNumberNumber); +DEFINE_MVIP_CTR(TSigMessageIdNumber); +DEFINE_MVIP_CTR(TSigNumberNumberNumber); +DEFINE_MVIP_CTR(TSigNumberNumberNumberNumber); +DEFINE_MVIP_CTR(TSigNodeIdNodeIdNumber); +DEFINE_MVIP_CTR(TSigMetaDataPtr) +DEFINE_MVIP_CTR(TSigRMessage2) +DEFINE_MVIP_CTR(TSigNumberRMessage2) +DEFINE_MVIP_CTR(TSigAny) +DEFINE_MVIP_CTR(TSigAnyNumber) +DEFINE_MVIP_CTR(TSigUidNumber) +DEFINE_MVIP_CTR(TSigNumberNumber) +DEFINE_MVIP_CTR(TSigNodeIdAny) +DEFINE_MVIP_CTR(TSigNodeIdNodeId) +DEFINE_MVIP_CTR(TSigNumberUidNumber) +DEFINE_MVIP_CTR(TSigNodeIdClientType) +DEFINE_MVIP_CTR(TSigClientTypeUidClientType) +DEFINE_MVIP_CTR(TSigClientType) +DEFINE_MVIP_CTR(TSigClientTypeUid) +DEFINE_MVIP_CTR(TSigMessageId); +DEFINE_MVIP_CTR(TSigNodeIdNumberNumberNumber); +DEFINE_MVIP_CTR(TSigTypeId); +DEFINE_MVIP_CTR(TSigTypeIdAnyNumber); + +const TImplementationProxy SignatureImplementationTable[] = + { + //NOTE: Entries must be sorted for the binary search to work efficiently! + MVIP_CTR_ENTRY(ESignatureBase,TSignatureBase), //2 + MVIP_CTR_ENTRY(ESignatureNumber,TSigNumber), //3 + MVIP_CTR_ENTRY(ESignatureUid,TSigUid), //4 + MVIP_CTR_ENTRY(ESignatureErrContext,TSigErrContext), //5 + MVIP_CTR_ENTRY(ESignatureErrResponse,TSigErrResponse), //6 +//empty slot + MVIP_CTR_ENTRY(ESignatureNodeId,TSigNodeId), //8 + MVIP_CTR_ENTRY(ESignatureNodeIdNumber,TSigNodeIdNumber), //9 + MVIP_CTR_ENTRY(ESignatureNodeIdNumberNumber,TSigNodeIdNumberNumber), //10 + MVIP_CTR_ENTRY(ESignatureMessageIdNumber,TSigMessageIdNumber), //11 + MVIP_CTR_ENTRY(ESignatureAnyNumber,TSigAnyNumber), //12 + MVIP_CTR_ENTRY(ESignatureMetaDataPtr,TSigMetaDataPtr), //13 + MVIP_CTR_ENTRY(ESignatureNumberNumberNumber,TSigNumberNumberNumber), //14 + MVIP_CTR_ENTRY(ESignatureRMessage2,TSigRMessage2), //15 + MVIP_CTR_ENTRY(ESignatureNumberRMessage2,TSigNumberRMessage2), //16 + MVIP_CTR_ENTRY(ESignatureAny,TSigAny), //17 + MVIP_CTR_ENTRY(ESignatureNumberNumber,TSigNumberNumber), //18 + MVIP_CTR_ENTRY(ESignatureNodeIdAny,TSigNodeIdAny), //19 + MVIP_CTR_ENTRY(ESignatureNodeIdNodeId,TSigNodeIdNodeId), //20 + MVIP_CTR_ENTRY(ESignatureNodeIdNodeIdNumber,TSigNodeIdNodeIdNumber), //21 + MVIP_CTR_ENTRY(ESignatureNumberNumberNumberNumber,TSigNumberNumberNumberNumber),//22 + MVIP_CTR_ENTRY(ESignatureUidNumber,TSigUidNumber), //23 + MVIP_CTR_ENTRY(ESignatureNumberUidNumber,TSigNumberUidNumber), //24 + MVIP_CTR_ENTRY(ESignatureNodeIdClientType,TSigNodeIdClientType), //25 + MVIP_CTR_ENTRY(ESignatureClientTypeUidClientType,TSigClientTypeUidClientType), //26 + MVIP_CTR_ENTRY(ESignatureClientType,TSigClientType), //27 + MVIP_CTR_ENTRY(ESignatureClientTypeUid,TSigClientTypeUid), //28 + MVIP_CTR_ENTRY(ESignatureMessageId,TSigMessageId), //29 + MVIP_CTR_ENTRY(ESignatureNodeIdNumberNumberNumber,TSigNodeIdNumberNumberNumber),//30 + MVIP_CTR_ENTRY(ESignatureTypeId,TSigTypeId), //31 + MVIP_CTR_ENTRY(ESignatureTypeIdAnyNumber,TSigTypeIdAnyNumber) //32 + }; + + +/*ststic*/ void TEBase::RegisterL(CGlobals& aGlobals) + { + aGlobals.RegisterInterfaceL(TUid::Uid(KNodeMessagesImplementationUid), sizeof(SignatureImplementationTable) / sizeof(SignatureImplementationTable[0]), SignatureImplementationTable); + } + +/*ststic*/ void TEBase::DeRegister(CGlobals& aGlobals) + { + aGlobals.DeregisterInterface(TUid::Uid(KNodeMessagesImplementationUid)); + } + + +EXPORT_C Meta::SMetaData* TVCFromGlobalsMessagePayloadCreationPolicy::New(TPtrC8& aSrc, TPtr8& aDst) + { + Meta::SMetaData* payload = NULL; + Meta::CMetaDataVirtualCtorInPlace* vctr = TlsGlobals::Get().VirtualCtor(); + if (vctr) + { + __ASSERT_DEBUG(aSrc.Length() >= sizeof(STypeId), User::Panic(KSpecAssert_ElemNodeMessMesC, 2)); //At least the type id must be present + TUid uid = *reinterpret_cast(aSrc.Ptr()); + if (vctr->IsInterfaceRegistered(uid)) + { + payload = vctr->New(aSrc, aDst); + } + } + return payload; + } + +EXPORT_C TSignatureWithPolymorphicPayloadMetaTypeBase::TSignatureWithPolymorphicPayloadMetaTypeBase(TUint8* aData, SMetaData** aPayload, TInt aHostSize) +: iData(aData), + iPayload(aPayload), + iHostSize(aHostSize) + { + } + +EXPORT_C TInt TSignatureWithPolymorphicPayloadMetaTypeBase::InternalLoad(TPtrC8& aBuffer, TDes8& aTempBuffer) + { + *iPayload = NULL; //will be set from the buffer, needs to be initialised for length + if (aBuffer.Length() < iHostSize) + { + return KErrArgument; + } + + Mem::Copy(iData, aBuffer.Ptr(), iHostSize); //including the ptr (length) + aBuffer.Set(aBuffer.Ptr() + iHostSize, aBuffer.Length() - iHostSize); //update pointer + + TInt payloadLength = *(reinterpret_cast(iPayload)); //payload length only + if (payloadLength) + { + if (payloadLength < 0 || aBuffer.Length() < payloadLength || payloadLength > aTempBuffer.MaxLength()) + { + return KErrArgument; + } + aTempBuffer.Copy(aBuffer.Ptr(), payloadLength); //aBuffer already moved to the end + } + return KErrNone; //regardless of *iData being initialised (NULL if not) + } + +EXPORT_C TInt TSignatureWithPolymorphicPayloadMetaTypeBase::Store(TDes8& aBuffer) const + { + TInt len = Length(); + if (aBuffer.MaxLength() - aBuffer.Length() < len) //including payload if present + { + return KErrOverflow; + } + + TInt offsetToPayload = (TUint8*)iPayload - iData; + TPtr8 payloadPtr(const_cast(aBuffer.Ptr()) + aBuffer.Length() + offsetToPayload, sizeof(SMetaData*)); + aBuffer.Append(iData, iHostSize); //Store all including the ptr + + len = 0; //Reset the len - now it means payload length only + if (*iPayload) + { + len = (*iPayload)->Length(); //payload length only + TInt error = (*iPayload)->Store(aBuffer); + if (error!=KErrNone) + { + return error; + } + } + + //Store the length where the pointer is stored + payloadPtr.Append(reinterpret_cast(&len), sizeof(SMetaData*)); + return KErrNone; + } + +EXPORT_C void TSignatureWithPolymorphicPayloadMetaTypeBase::Copy(const TAny* aData) + { + TInt offset = (TUint8*)iPayload - iData; + const TUint8* srcdata = reinterpret_cast(aData) + sizeof(SMetaData*) - offset; + Mem::Copy(iData, srcdata, iHostSize); + + SMetaData* const* srcpayload = reinterpret_cast(aData); + if (*iPayload && *srcpayload) + { + (*iPayload)->Copy(**srcpayload); + } + } + +EXPORT_C TInt TSignatureWithPolymorphicPayloadMetaTypeBase::Length() const + { + TInt len = iHostSize; //including the ptr + if (*iPayload) + { + len += (*iPayload)->Length(); //the payload + } + return len; + } + + + +