// 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();

	}