diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/comms-infras/cftransport.inl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/epoc32/include/comms-infras/cftransport.inl	Tue Mar 16 16:12:26 2010 +0000
@@ -0,0 +1,305 @@
+// 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// cftransport.inl
+// 
+//
+
+inline TCookie::TCookie()
+: iType(ENull),
+  iChipsFollowing(0)
+	{
+	}
+
+// Cookies are not constructed arbitarily, instead having been generated they are bitwise copied. Consequently we don't trouble to
+// provide clever comparison operators or a copy operation, nor to ensure consistent initialisation of padding fields
+inline TBool TCookie::operator==(const TCookie& aRHS) const
+	{
+	ASSERT(iChipsFollowing==0 && aRHS.iChipsFollowing==0); //This is private (transport's use) information which must not be set here.
+	return Mem::Compare((const TUint8*) this, sizeof(*this), (const TUint8*) &aRHS, sizeof(*this)) == 0;
+	}
+
+inline TCookieAccessor::TCookieAccessor(const TCookie& aCookie)
+: iCookie(aCookie)
+	{
+	}
+
+inline TBool TCookieAccessor::IsNull() const 
+	{
+	return iCookie.iType == TCookie::ENull;
+	}
+
+inline TCookie::TVariety TCookieAccessor::Variety() const 
+	{
+	return static_cast<TCookie::TVariety>(iCookie.iType);
+	}
+
+inline TWorkerId TCookieAccessor::WorkerId() const
+	{
+	return static_cast<TWorkerId>(iCookie.iWorkerId);
+	}
+
+inline TAny* TCookieAccessor::Ptr() const
+	{
+	return iCookie.iUn.iObjPtr.iPtr;
+	}
+
+inline TUint8 TCookieAccessor::PtrSalt() const
+	{
+	ASSERT(Variety() == TCookie::EDispatchItfPtr || Variety() == TCookie::EDispatchItfPtrListener);
+	return iCookie.iSalt;
+	}
+
+inline TInt TCookieAccessor::LegacyCode() const
+	{
+	ASSERT(Variety() == TCookie::ELegacyId);
+	return iCookie.iUn.iLegacyCode;
+	}
+
+
+inline TCookieOp::TCookieOp(TCookie& aCookie)
+: TCookieAccessor(aCookie),
+iCookie(aCookie)
+	{
+	}
+
+/** Initialise cookie with a pointer to an object interface
+*/
+inline void TCookieOp::SetInterface(TAny* aDispatchItf, TUint8 aSalt, TWorkerId aWorkerId)
+	{
+	iCookie.iType = TCookie::EDispatchItfPtr;
+	ASSERT(aWorkerId >= 0 && aWorkerId <= 255);
+	iCookie.iWorkerId = (TUint8) aWorkerId;
+	iCookie.iSalt = aSalt;
+	iCookie.iUn.iObjPtr.iPtr = aDispatchItf;
+	}
+
+/** Initialise pseudo-cookie for a legacy message message handler
+*/
+inline void TCookieOp::SetLegacyMessageCode(TWorkerId aWorkerId, TInt aLegacyCode)
+	{
+	iCookie.iType = TCookie::ELegacyId;
+	ASSERT(aWorkerId >= 0 && aWorkerId <= 255);
+	iCookie.iWorkerId = (TUint8) aWorkerId;
+	iCookie.iUn.iLegacyCode = aLegacyCode;
+	}
+
+inline void TCookieOp::SetNull()
+	{
+	iCookie.iType = TCookie::ENull;
+	iCookie.iUn.iObjPtr.iPtr = NULL;	// unnecessary really, but safety net against those who don't validate type
+	}
+
+inline TCFMessage2::TCFMessage2()
+	{
+	}
+
+inline TCFMessage2::TCFMessage2(const TCookie& aCookie, const TDesC8& aData)
+	{
+	reinterpret_cast<TCookie&>(*RawBlock()) = aCookie;
+	__ASSERT_ALWAYS(aData.Size() <= sizeof(*this) - sizeof(TCookie), User::Panic(KCFChannelPanic, ECFChanMsgTooBig));
+	TPtr8(const_cast<TUint8*>(RawBlock()) + sizeof(TCookie), sizeof(*this) - sizeof(TCookie)).Copy(aData);
+	}
+
+inline const TCookie& TCFMessage2::Cookie() const
+	{
+	return reinterpret_cast<const TCookie&>(*RawBlock());
+	}
+
+inline TPtrC8 TCFMessage2::Data() const
+	{
+	return TPtrC8(RawBlock() + sizeof(TCookie), sizeof(*this) - sizeof(TCookie));
+	}
+/*
+inline TInt TCFMessage2::MaxEmbeddedMessageSize()
+	{
+	return MaxRawBlockSize() - sizeof(TCookie);
+	}
+*/
+inline THeapStoredMessage* THeapStoredMessage::New(RAllocator& aHeap, const TCookie& aCookie, const TDesC8& aData)
+	{
+	THeapStoredMessage* self = reinterpret_cast<THeapStoredMessage*>(aHeap.Alloc(
+		sizeof(THeapStoredMessage) + aData.Length() - 1));	// 1 being the sizeof(iSerialiseData); can't ref directly (CW issue)
+	if(self)
+		{
+		self->iCookie = aCookie;
+		self->iData.Set(self->iSerialisedData, aData.Length());
+		Mem::Copy(self->iSerialisedData, aData.Ptr(), aData.Length());
+		}
+	return self;		
+	}
+
+inline const TCookie& THeapStoredMessage::Cookie() const
+	{
+	return iCookie;
+	}
+
+inline const TPtrC8& THeapStoredMessage::Data() const
+	{
+	return iData;
+	}
+
+
+
+//
+// Thread knowledge
+//
+
+inline TBool TWorkerThreadDataBase::IsValid() const
+	{
+	return iHeap != 0;
+	}
+
+inline CWorkerThreadDataGlobalsBase::CWorkerThreadDataGlobalsBase()
+	{
+	}
+
+inline CWorkerThreadDataGlobalsBase::~CWorkerThreadDataGlobalsBase()
+	{
+	User::Free(iWorkers);
+	}
+
+inline void CWorkerThreadDataGlobalsBase::ConstructL(TInt aWorkerDataSize, TInt TUpperThreadIdBound)
+	{
+	iWorkers = reinterpret_cast<TWorkerThreadDataBase*>(User::AllocZL(aWorkerDataSize * (TUpperThreadIdBound + 1)));
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>* CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>::NewL()
+	{
+	CWorkerThreadDataGlobals* self = new(ELeave) CWorkerThreadDataGlobals();
+	CleanupStack::PushL(self);
+	self->ConstructL(sizeof(TWTD), TUpperThreadIdBound);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline void CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>::ConstructL(TInt aWorkerDataSize, TWorkerId aUpperBoundId)
+	{
+	CWorkerThreadDataGlobalsBase::ConstructL(aWorkerDataSize, aUpperBoundId);
+	for(TInt i = 0; i <= TUpperThreadIdBound; ++i)
+		{
+		new(reinterpret_cast<TUint8*>(iWorkers) + i * aWorkerDataSize) TWTD;
+		}
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline TWorkerId CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>::UpperBoundWorkerId() const
+	{
+	return TUpperThreadIdBound;
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline TWTD* CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>::GetWorkerGlobals(TWorkerId aWorker) const
+	{
+	__ASSERT_DEBUG(aWorker >= 0 && aWorker <= UpperBoundWorkerId(), Panic(ECFTransInvalidWorkerId));
+	return reinterpret_cast<TWTD*>(reinterpret_cast<TUint8*>(iWorkers) + sizeof(TWTD) * aWorker);
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline TBool CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>::WorkerPresent(TWorkerId aId) const
+	{
+	return GetWorkerGlobals(aId)->IsValid();
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline RAllocator& CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>::WorkerHeap(TWorkerId aWorkerId) const
+	{
+	return *(GetWorkerGlobals(aWorkerId)->iHeap);
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline void CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>::PanicWorker(TWorkerId aWorkerId, const TDesC& aCategory, TInt aReason) const
+	{
+	GetWorkerGlobals(aWorkerId)->iThread.Panic(aCategory, aReason);
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>::CWorkerThreadDataGlobals()
+: CWorkerThreadDataGlobalsBase()
+	{
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline CWorkerThreadRegister<TWTD, TUpperThreadIdBound>* CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::NewL(TWorkerId aSelfId, CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>* aGlobalThreadRegister)
+	{
+	return new(ELeave) CWorkerThreadRegister(aSelfId, aGlobalThreadRegister);
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline TWTD* CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::GetWorkerGlobals(TWorkerId aWorker) const
+	{
+	__ASSERT_DEBUG(iGlobals != NULL, Panic(ECFTransThreadRegisterUnspecified));
+	__ASSERT_DEBUG(aWorker >= 0 && aWorker <= TUpperThreadIdBound, Panic(ECFTransInvalidWorkerId));
+	return iGlobals->GetWorkerGlobals(aWorker);
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline TWorkerId CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::UpperBoundWorkerId() const
+	{
+	return TUpperThreadIdBound;
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline TBool CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::WorkerPresent(TWorkerId aWorker) const
+	{
+	__ASSERT_DEBUG(iGlobals != NULL, Panic(ECFTransThreadRegisterUnspecified));
+	__ASSERT_DEBUG(aWorker >= 0 && aWorker <= TUpperThreadIdBound, Panic(ECFTransInvalidWorkerId));
+	return iGlobals->WorkerPresent(aWorker);
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline RAllocator& CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::WorkerHeap(TWorkerId aWorker) const
+	{
+	__ASSERT_DEBUG(iGlobals != NULL, Panic(ECFTransThreadRegisterUnspecified));
+	__ASSERT_DEBUG(aWorker >= 0 && aWorker <= TUpperThreadIdBound, Panic(ECFTransInvalidWorkerId));
+	return iGlobals->WorkerHeap(aWorker);
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline void CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::PanicWorker(TWorkerId aWorkerId, const TDesC& aCategory, TInt aReason) const
+	{
+	GetWorkerGlobals(aWorkerId)->iThread.Panic(aCategory, aReason);
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline TWorkerId CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::SelfWorkerId() const
+	{
+	return iSelfId;
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline TWTD* CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::GetSelfWorkerGlobals() const
+	{
+	__ASSERT_DEBUG(iGlobals != NULL, Panic(ECFTransThreadRegisterUnspecified));
+	return iGlobals->GetWorkerGlobals(iSelfId);
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline void CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::SetGlobalThreadRegister(CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>* aGlobalThreadRegister)
+	{
+	iGlobals = aGlobalThreadRegister;
+	}
+
+template<class TWTD, TInt TUpperThreadIdBound>
+inline CWorkerThreadRegister<TWTD, TUpperThreadIdBound>::CWorkerThreadRegister(TWorkerId aSelfId, CWorkerThreadDataGlobals<TWTD, TUpperThreadIdBound>* aGlobalThreadRegister)
+: iSelfId(aSelfId),
+iGlobals(aGlobalThreadRegister)
+	{
+	}
+
+inline TBool RCFInterfaceBase::IsOpen() const
+	{
+	return !TCookieAccessor(iRecipient).IsNull();
+	}