// 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 <elements/nm_address_internal.h>

#include <elements/nm_transport.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_ElemNodeMessAdrC, "ElemNodeMessAdrC");

#endif

using namespace Messages;

//

//TRuntimeCtxId

/******************************************************************************************************

*

*

* TRuntimeCtxId

*

*

*******************************************************************************************************/

namespace Mem4NullRuntimeCtxId

{

	static const TUint8 mem[sizeof(TRuntimeCtxId)] = { sizeof(TRuntimeCtxId) & ~TRuntimeCtxId::KIsNullMask8, 0};

}

EXPORT_C const TRuntimeCtxId& TRuntimeCtxId::NullId()

	{

	return *reinterpret_cast<const TRuntimeCtxId *>(Mem4NullRuntimeCtxId::mem);

	}

EXPORT_C TRuntimeCtxId::TRuntimeCtxId(const TRuntimeCtxId& aRuntimeCtxId)

	: iSize(sizeof(TRuntimeCtxId))

	{

	*this = aRuntimeCtxId;

	}

EXPORT_C TRuntimeCtxId::TRuntimeCtxId()

:	iSize(sizeof(TRuntimeCtxId))

	{

	Mem::FillZ((TUint8*)this + _FOFF(TRuntimeCtxId, iSalt), sizeof(TRuntimeCtxId) - _FOFF(TRuntimeCtxId, iSalt));

	}

//protected

EXPORT_C TRuntimeCtxId::TRuntimeCtxId(TUint8 aSize)

:	iSize(aSize)

	{

	Mem::FillZ((TUint8*)this + _FOFF(TRuntimeCtxId, iSalt), sizeof(TRuntimeCtxId) - _FOFF(TRuntimeCtxId, iSalt));

	}

EXPORT_C const TRuntimeCtxId& TRuntimeCtxId::operator=(const TRuntimeCtxId& aRHS)

	{

	if (Size())

		{

		//Valid address already, reassign only the matching part + isnull flag

		iSize = aRHS.IsNull()? iSize & ~KIsNullMask8 : iSize | KIsNullMask8;

		}

	else

		{

		iSize = aRHS.iSize; //This will also set/not set KIsNullMask8!

		}

	Mem::Copy((TUint8*)this + _FOFF(TRuntimeCtxId, iSalt), (const TUint8*)&aRHS + _FOFF(TRuntimeCtxId, iSalt), Min(Size(), aRHS.Size()) - _FOFF(TRuntimeCtxId, iSalt));

	return *this;

	}

EXPORT_C TBool TRuntimeCtxId::operator==(const TRuntimeCtxId& aRHS) const

	{

	return ComparePart(aRHS, Size());

	}

EXPORT_C TBool TRuntimeCtxId::ComparePart(const TRuntimeCtxId& aRHS, TUint8 aSize) const

	{

	__ASSERT_DEBUG(aSize <= Size(), User::Panic(KSpecAssert_ElemNodeMessAdrC, 1));

	//No need to compare bits if either or both operands are NULL.

	TInt comparesize = (IsNull() || aRHS.IsNull()) ? 0 : (Min(aSize, aRHS.Size()) - _FOFF(TRuntimeCtxId, iSalt));

	if (comparesize>0)

		{

		return Mem::Compare((const TUint8*)this + _FOFF(TRuntimeCtxId, iSalt), comparesize, (const TUint8*)&aRHS + _FOFF(TRuntimeCtxId, iSalt), comparesize) == 0;

		}

	//If both are NULL, then we can say they're equal, otherwise they're not.

	return IsNull() && aRHS.IsNull();

	}

EXPORT_C TInt TRuntimeCtxId::Store(TDes8& aDes) const

	{

	if (Size() > aDes.MaxSize())

		{

		return KErrOverflow;

		}

	aDes.Append((TUint8*)this, Size());

	return KErrNone;

	}

EXPORT_C void TRuntimeCtxId::PostTo(const TRuntimeCtxId& aPostFrom, const TSignalBase& aMessage) const

	{

	RClientInterface::OpenPostMessageClose(aPostFrom, *this, aMessage);

	}

/******************************************************************************************************

*

*

* TNodeId

*

*

*******************************************************************************************************/

namespace Mem4NullNodeId

{

	static const TUint8 mem[sizeof(TNodeId)] = { sizeof(TNodeId) & ~TRuntimeCtxId::KIsNullMask8, 0};

}

EXPORT_C const TNodeId& TNodeId::NullId()

	{

	return *reinterpret_cast<const TNodeId *>(Mem4NullNodeId::mem);

	}

EXPORT_C TNodeId::TNodeId()

:	TRuntimeCtxId(sizeof(TNodeId)),

	iPtr(NULL)

	{

	}

EXPORT_C TNodeId::TNodeId(const TNodeId& aNodeId)

:	TRuntimeCtxId(sizeof(TNodeId))

	{

	*this = aNodeId;

	}

//protected

EXPORT_C TNodeId::TNodeId(TUint8 aSize)

:	TRuntimeCtxId(aSize),

	iPtr(NULL)

	{

	}

EXPORT_C const TNodeId& TNodeId::operator=(const TRuntimeCtxId& aRHS)

	{

	return address_cast<TNodeId>(TRuntimeCtxId::operator=(aRHS));

	}

/******************************************************************************************************

* TNodeIdRemainder

*******************************************************************************************************/

EXPORT_C TNodeIdRemainder::TNodeIdRemainder(const TRuntimeCtxId& aFrom)

	{

	*this = aFrom;

	}

EXPORT_C TNodeIdRemainder::TNodeIdRemainder()

:iSize(0)

	{

	Mem::FillZ(iRemainder, sizeof(iRemainder));

	}

EXPORT_C const TNodeIdRemainder& TNodeIdRemainder::operator=(const TRuntimeCtxId& aRHS)

	{

	//Here we assign only the remainder bit off aRHS;

	iSize = aRHS.Size() - sizeof(TNodeId);

	if (iSize > 0)

		{

		//No need to assert no sizes, as no TRuntimeCtxId can exceed KMaxInlineAddressSize + sizeof(TUint)

		//and TNodeIdRemainder::EPayloadSize is calculated based on that. There will always be room.

		Mem::Copy(iRemainder, (const TUint8*)&aRHS + sizeof(TNodeId), iSize);

		}

	else

		{

		//Zero all including size

		Mem::FillZ(iRemainder, sizeof(iRemainder));

		iSize = 0;

		}

	return *this;

	}

EXPORT_C TBool TNodeIdRemainder::operator==(const TRuntimeCtxId& aRHS) const

	{

	TInt comparablePayloadSize = Min(aRHS.Size() - sizeof(TNodeId), iSize);

	return Mem::Compare(iRemainder, comparablePayloadSize, (const TUint8*)&aRHS + sizeof(TNodeId), comparablePayloadSize) == 0;

	}

EXPORT_C TBool TNodeIdRemainder::operator==(const TNodeIdRemainder& aRHS) const

	{

	TInt comparablePayloadSize = Min(aRHS.Size(), iSize);

	return Mem::Compare(iRemainder, comparablePayloadSize, (const TUint8*)&aRHS.iRemainder, comparablePayloadSize) == 0;

	}

/******************************************************************************************************

*

*

* TNodeCtxId

*

*

*******************************************************************************************************/

namespace Mem4NullNodeCtxId

{

	static const TUint8 mem[sizeof(TNodeCtxId)] = { sizeof(TNodeCtxId) & ~TRuntimeCtxId::KIsNullMask8, 0};

}

EXPORT_C const TNodeCtxId& TNodeCtxId::NullId()

	{

	return *reinterpret_cast<const TNodeCtxId *>(Mem4NullNodeCtxId::mem);

	}

EXPORT_C TNodeCtxId::TNodeCtxId()

:	TNodeId(sizeof(TNodeCtxId)),

	iNodeCtx(0),

	iReserved(0)

	{

	}

EXPORT_C TNodeCtxId::TNodeCtxId(TUint16 aNodeCtx, const TNodeId& aNodeId)

:	TNodeId(sizeof(TNodeCtxId)),

	iNodeCtx(aNodeCtx),

	iReserved(0)

	{

	__ASSERT_DEBUG(address_cast<TNodeCtxId>(&aNodeId)==NULL, User::Panic(KSpecAssert_ElemNodeMessAdrC, 2)); //Be careful! You are overriding your aNodeCtx! Use TNodeCtxId(const TNodeCtxId& aNodeCtxId).

	*this = aNodeId;

	}

EXPORT_C TNodeCtxId::TNodeCtxId(const TNodeCtxId& aNodeCtxId)

:	TNodeId(sizeof(TNodeCtxId))

	{

	*this = aNodeCtxId;

	}

//protected

EXPORT_C TNodeCtxId::TNodeCtxId(TUint8 aSize)

:	TNodeId(aSize),

	iNodeCtx(0)

	{

	}

EXPORT_C const TNodeCtxId& TNodeCtxId::operator=(const TRuntimeCtxId& aRHS)

	{

	return address_cast<TNodeCtxId>(TRuntimeCtxId::operator=(aRHS));

	}

/******************************************************************************************************

*

*

* TNodeOid

*

*

*******************************************************************************************************/

EXPORT_C TNodeOid::TNodeOid(TAny* aObj)

	{

	TNodeIdOp(*this).SetPtr(aObj);

	TlsGlobals::Get().TransportReceiver().RegisterAddress(*this);

	}

EXPORT_C TNodeOid::TNodeOid(ANode& aObj)

	{

	TNodeIdOp(*this).SetPtr(static_cast<TAny*>(&aObj));

	TlsGlobals::Get().TransportReceiver().RegisterAddress(*this);

	}

EXPORT_C TNodeOid::~TNodeOid()

	{

	// We allow TNodeOid objects to be unregistered early so we have to permit null TNodeOid

	// objects to exist.  We avoid the assertion that tests for null in UnregisterSelf by

	// checking to make sure that the TNodeOid is not null before calling it.

	// We do not remove the assertion because we still want to guard against repeated calls

	// to UnregisterSelf.

	if(!IsNull())

		{

		UnregisterSelf();

		}

	}

/** Usually a node remains registered with the transport mechanism for its lifetime, however some special

cases need to unregister early (eg to avoid registration at all).

*/

EXPORT_C void TNodeOid::UnregisterSelf()

	{

	__ASSERT_ALWAYS(!IsNull(), User::Panic(KMessagesPanic, EAddressNotValidPanic));

	TlsGlobals::Get().TransportReceiver().DeregisterAddress(*this);

	}