// Copyright (c) 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:

//

inline TCommsBuf::TCommsBuf()

{

}

#ifndef __KERNEL_MODE__

inline TCommsBuf::TCommsBuf(TInt aRawDataOffset, TUint aBufSize, TInt aHandle, TInt aPool) :

	iFrontCanary(KCanaryDefault),

	iLength(aBufSize),

	iOffset(aRawDataOffset),

	iPool(aPool),

	iHandle(aHandle),

	iRawDataOffset(aRawDataOffset),

	iRawSize(aBufSize),

	iNext(NULL),

	iBackCanary(KCanaryDefault)

	{

	iType = 0,

	iReservedBytes[0] = 0;

	iReservedBytes[1] = 0;

	iReservedBytes[2] = 0;

	iReservedWords[0] = 0;

	iReservedWords[1] = 0;

	iReservedWords[2] = 0;

	iReservedWords[3] = 0;

	iReservedWords[4] = 0;

	}

inline TCommsBuf::TCommsBuf(TInt aRawDataOffset, TUint aBufSize, TInt aPool) :

	iFrontCanary(KCanaryDefault),

	iLength(aBufSize),

	iOffset(aRawDataOffset),

	iPool(aPool),

	iHandle(0),

	iRawDataOffset(aRawDataOffset),

	iRawSize(aBufSize),

	iNext(NULL),

	iBackCanary(KCanaryDefault)

	{

	iType = 0,

	iReservedBytes[0] = 0;

	iReservedBytes[1] = 0;

	iReservedBytes[2] = 0;

	iReservedWords[0] = 0;

	iReservedWords[1] = 0;

	iReservedWords[2] = 0;

	iReservedWords[3] = 0;

	iReservedWords[4] = 0;

	}

inline TAny* RCommsBuf::operator new(TUint /* aSize */, const TUint8* aPtr) __NO_THROW

	{

	__ASSERT_COMPILE(sizeof(RCommsBuf) == TCommsBuf::KCommsBufMetadataSize);

	return (TUint8*)aPtr;

	}

inline void RCommsBuf::operator delete(TAny* /* aPtr */, const TUint8*) __NO_THROW

	{		

	}

inline RCommsBuf::RCommsBuf()

	{

	}

inline RCommsBuf::RCommsBuf(TInt aRawDataOffset, TUint aBufSize, TInt aHandle, TInt aPool)

: iCommsBufMetaData(aRawDataOffset, aBufSize, aHandle, aPool)

	{

	}

inline RCommsBuf::RCommsBuf(TInt aRawDataOffset, TUint aBufSize, TInt aPool)

: iCommsBufMetaData(aRawDataOffset, aBufSize, aPool)

	{		

	}

inline TPtrC8 RCommsBuf::DesC8() const

/**

Creates and returns a non-modifiable pointer descriptor representing the contained data

@return non-modifiable pointer descriptor

*/

	{

	__ASSERT_COMMSBUF();

	return TPtrC8((TUint8*)(this) + iCommsBufMetaData.iOffset, iCommsBufMetaData.iLength);

	}

inline const TUint8* RCommsBuf::RawBase() const

/**

Returns a const ponter to the start of the data represented by the RCommsBuf

 @return A const pointer

*/

	{

	__ASSERT_COMMSBUF();

	return ((TUint8*)this + iCommsBufMetaData.iRawDataOffset);

	}

inline TUint8* RCommsBuf::RawBase()

/**

Returns a ponter to the start of the data represented by the RCommsBuf

 @return A pointer

*/

	{

	__ASSERT_COMMSBUF();

	return ((TUint8*)this + iCommsBufMetaData.iRawDataOffset);

	}

inline TInt RCommsBuf::RawSize() const

/**

Returns the raw size of the RCommsBuf data

  @return the size of the RCommsBuf data

*/

	{

	return iCommsBufMetaData.iRawSize;

	}

inline const TUint8* RCommsBuf::Ptr() const

/**

Returns a const pointer to the actual location of the data start. 

Actual data start location may differ from the start of the data 

@see RCommsBuf::RawBase

@return A const pointer

*/

	{

	__ASSERT_COMMSBUF();

	return ((TUint8*)(this) + iCommsBufMetaData.iOffset);

	}

inline TUint8* RCommsBuf::Ptr()

/**

Returns a pointer to the actual location of the data start. 

@see RCommsBuf::RawBase

@return A pointer

*/

	{

	__ASSERT_COMMSBUF();

    return ((TUint8*)(this) + iCommsBufMetaData.iOffset);

	}

inline TInt	RCommsBuf::Length() const

/**

Returns the length of the RCommsBuf data

  @return the length of the RCommsBuf data

*/

	{

	return iCommsBufMetaData.iLength;

	}

inline TInt RCommsBuf::Offset() const

/**

Returns the offset of the RCommsBuf data

  @return the offset of the RCommsBuf data

*/

	{

	return iCommsBufMetaData.iOffset - iCommsBufMetaData.iRawDataOffset;

	}

inline void RCommsBuf::SetOffset(TInt aOffset)

/**

Sets the RCommsBuf data offset

@param aOffset  An offset

 */

	{

	__ASSERT_ALWAYS((aOffset >= 0) && ((aOffset + iCommsBufMetaData.iLength) <= iCommsBufMetaData.iRawSize), CommsBuf::Panic(EMBuf_NegativeOffset));

	iCommsBufMetaData.iOffset = iCommsBufMetaData.iRawDataOffset + aOffset;

	}

inline TUint8 RCommsBuf::operator[] (TInt aPos) const

	{

	__ASSERT_COMMSBUF();

    __ASSERT_ALWAYS(aPos >= 0 && aPos < Length(), CommsBuf::Panic(EMBuf_IndexOutofRange));

	return (Ptr()[aPos]);

	}

inline TUint8& RCommsBuf::operator[] (TInt aPos)

	{

	__ASSERT_COMMSBUF();

    __ASSERT_ALWAYS(aPos >= 0 && aPos < Length(), CommsBuf::Panic(EMBuf_IndexOutofRange));

	return (((TUint8*)Ptr())[aPos]);

	}

inline void RCommsBuf::Reset()

/**

Resets the length and offset of the RCommsBuf data

*/

	{

	iCommsBufMetaData.iLength = 0;

	iCommsBufMetaData.iOffset = iCommsBufMetaData.iRawDataOffset;

	}

inline TInt RCommsBuf::AppendLimit() const

/**

Returns the length of the bytes that can be appended

*/

	{

    return iCommsBufMetaData.iRawDataOffset + iCommsBufMetaData.iRawSize - iCommsBufMetaData.iOffset - iCommsBufMetaData.iLength;

	}

inline TInt RCommsBuf::PrependLimit() const

/**

Returns the length of the data that can be prepended

*/

	{

	return iCommsBufMetaData.iOffset - iCommsBufMetaData.iRawDataOffset;

	}

inline void RCommsBuf::SetDataRange(TInt aOffset, TInt aLength)

/**

Sets the offset and length of the data

@param aOffset An offset

@param aLength A length

*/

	{

	__ASSERT_ALWAYS((aOffset >= 0) && (aLength >= 0) && ((aOffset + aLength) <= iCommsBufMetaData.iRawSize), CommsBuf::Panic(EMBuf_NegativeOffset));

	iCommsBufMetaData.iOffset = iCommsBufMetaData.iRawDataOffset + aOffset;

	iCommsBufMetaData.iLength = aLength;

	}

inline void RCommsBuf::AdjustDataStart(TInt aDelta)

/**

Adjust the RCommsBuf data offset and length with the given delta value.

ie; the data offset is incremented by the given delta value and the data 

length is decremented by the given delta value

*/

	{

	iCommsBufMetaData.iOffset += aDelta;

	iCommsBufMetaData.iLength -= aDelta;

	__ASSERT_ALWAYS((iCommsBufMetaData.iOffset >= iCommsBufMetaData.iRawDataOffset) && (iCommsBufMetaData.iLength >= 0), CommsBuf::Panic(EMBuf_InvalidLengthOrOffset));

	}

inline void RCommsBuf::AdjustDataEnd(TInt aDelta)

/**

Adjust the RCommsBuf data length with the given delta value. 

ie; the data length is incremented by the given value

*/

	{

	iCommsBufMetaData.iLength += aDelta;

	__ASSERT_ALWAYS((iCommsBufMetaData.iLength >= 0) && ((Offset() + iCommsBufMetaData.iLength) <= iCommsBufMetaData.iRawSize), CommsBuf::Panic(EMBuf_InvalidLengthOrOffset));

	}

inline void RCommsBuf::SetNext(RCommsBuf* aBuf)

	{

	iCommsBufMetaData.iNext = aBuf;		

	}

inline RCommsBuf* RCommsBuf::Next()

	{

	return iCommsBufMetaData.iNext;		

	}

inline const RCommsBuf* RCommsBuf::Next() const

	{

	return iCommsBufMetaData.iNext;	

	}

inline CCommsBufPool* RCommsBuf::Pool() const	

	{

	return reinterpret_cast<CCommsBufPool*>(iCommsBufMetaData.iPool);

	}

inline TInt RCommsBuf::Handle() const

	{

	return iCommsBufMetaData.iHandle;

	}

inline void RCommsBuf::AssertCommsBufInvariants() const

    {

    __ASSERT_ALWAYS(iCommsBufMetaData.iFrontCanary == TCommsBuf::KCanaryDefault && iCommsBufMetaData.iBackCanary == TCommsBuf::KCanaryDefault, CommsBuf::Panic(EMBuf_CorruptMBuf));

    }

RCommsBufAccessor::RCommsBufAccessor(const RCommsBuf& aCommsBuf) : iCommsBuf(aCommsBuf)

	{

	}

TInt RCommsBufAccessor::Handle() const

	{

	return iCommsBuf.Handle();

	}

#endif // __KERNEL_MODE__