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

// Buffer Manager for Protocols(Buffer)

// 

//

/**

 @file

 @internalComponent

*/

#include <es_mbman.h>

#include "MBufPoolChain.h"

#include "MBufPoolManager.h"

//

// MBUF

//

TAny *RMBuf::operator new(TUint /*aSize*/, RMBuf* aPtr)

/**

Provide MBuf with a new in-place operator

*/

	{

	__ASSERT_DEBUG(aPtr, CMBufManager::Panic(EMBuf_BadNewInPlace));

	return aPtr;

	}

void RMBuf::operator delete(TAny* /*aPtr*/)

/**

In place delete

*/

	{

	}

void RMBuf::operator delete(TAny* /*aPtr*/, RMBuf*)

/**

extra delete operator for exception unwinding in Code Warrior

*/

	{

	}

RMBuf::RMBuf(TUint8* aBuffer, RMBufPoolChain* aPoolChain, TInt aSize)

	: iBuffer(aBuffer), iSize(aSize), iPoolChain(aPoolChain)

/**

MBuf constructor initialiser

@param aBuffer A buffer

@param aPoolChain The poolchain that contains the MBuf

@param aSize Size

*/

	{

	Init(EMBufFree);

	}

EXPORT_C void RMBuf::Init(TMBufType aType)

/**

Initialises MBuf's members

@param aType A MBuf type

*/

	{

	iType = aType;

	iLength = iSize;

	iOffset = 0;

	iNext = NULL;

	iRefCount = 0;

	iNextPkt.Init();

	}

// allocates memory for a RMBuf object, return a pointer to the RMBuf object memory

// - the size of the mbuf to be allocatd will depend on the available pool chains, eg. 128, 1514, 9000, etc

EXPORT_C RMBuf* RMBuf::AllocL()

 	{

	return CMBufManager::Context()->AllocL(KMBufSmallSize);		// default size is specified within CMufManager implementation, guaranteed to be only 1 mbuf

	}

EXPORT_C RMBuf* RMBuf::AllocL(TUint aSize)

 	{

	RMBuf* mBuf = CMBufManager::Context()->Alloc(aSize, aSize);	// min. size constraint to ensure only 1 mbuf is allocated

	if (!mBuf)

		{

		User::Leave(KErrNoMBufs);

		}

	return mBuf;

	}

EXPORT_C RMBuf* RMBuf::Alloc()

 	{

	return CMBufManager::Context()->Alloc(KMBufSmallSize);		// default size is specified within CMufManager implementation, guaranteed to be only 1 mbuf

	}

EXPORT_C RMBuf* RMBuf::Alloc(TUint aSize)

 	{

	return CMBufManager::Context()->Alloc(aSize, aSize);	// min. size constraint to ensure only 1 mbuf is allocated

	}

// overloading for TLS

EXPORT_C RMBuf* RMBuf::AllocL(RMBufAllocator& aRMBufAllocator)

 	{

	return aRMBufAllocator.MBufManager().AllocL(KMBufSmallSize);		// default size is specified within CMufManager implementation, guaranteed to be only 1 mbuf

	}

EXPORT_C RMBuf* RMBuf::AllocL(TUint aSize, RMBufAllocator& aRMBufAllocator)

 	{

	RMBuf *mBuf = aRMBufAllocator.MBufManager().Alloc(aSize, aSize);	// min. size constraint to ensure only 1 mbuf is allocated

	if (!mBuf)

		{

		User::Leave(KErrNoMBufs);

		}

	return mBuf;

	}

EXPORT_C RMBuf* RMBuf::Alloc(RMBufAllocator& aRMBufAllocator)

	{

	return aRMBufAllocator.MBufManager().Alloc(KMBufSmallSize);		// default size is specified within CMufManager implementation, guaranteed to be only 1 mbuf

	}

EXPORT_C RMBuf* RMBuf::Alloc(TUint aSize, RMBufAllocator& aRMBufAllocator)

	{

	return aRMBufAllocator.MBufManager().Alloc(aSize, aSize);	// min. size constraint to ensure only 1 mbuf is allocated

	}

EXPORT_C void RMBuf::Free()

/**

Frees the allocated memory for the RMBuf object

*/

	{

	// There is currently no support for reference counting, this check is to

	// ensure that someone hasn't mistakenly tried to use the iRefCount member.

	// The iRefCount member was introduced to allow reference counting to be

	// implemented at a later without another BC break having to be raised.

	__ASSERT_DEBUG(iRefCount==0, CMBufManager::Panic(EMBuf_InvalidRefCount));

	__ASSERT_DEBUG(iPoolChain != NULL, CMBufManager::Panic(EMBuf_NoPoolChain));

	((RMBufPoolChain*)iPoolChain)->MBufPoolManager().Free(this, EFalse);

	}

EXPORT_C RMBuf* RMBuf::Last()

/**

Last MBuf in a chain.

Not really supposed to be in RMBuf,

but putting it here allows the code to

be shared by RMBufChain and RMBufQ

@return A pointer to the last MBuf in the chain

*/

{

	RMBuf* p = NULL;

	TMBufIter m(this);

	while (m.More())

		{

		p = m;

		m++;

		}

	return p;

	}

EXPORT_C void RMBuf::__DbgPut(TUint8 aVal, TInt aOffset)

{

	__ASSERT_ALWAYS(aOffset<(iOffset+iLength), CMBufManager::Panic(EMBuf_BadOffset));

	*(Ptr()+aOffset) = aVal;

}

EXPORT_C TUint8 RMBuf::__DbgGet(TInt aOffset) const

{

	__ASSERT_ALWAYS(aOffset<(iOffset+iLength), CMBufManager::Panic(EMBuf_BadOffset));

	return *(Ptr()+aOffset);

}