// 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 (MBuf and Packet Queues)
// 
//

#include <es_mbuf.h>

//
// MBUF QUEUE
//

__IMPLEMENT_CLEANUP(RMBufQ, Free)


EXPORT_C RMBufQ::RMBufQ(RMBuf* aChain)
/**
Constructor initializes the members
*/
 	{
	iNext = aChain;
	iLast = aChain->Last(); // Safe even if aChain==NULL
	}


EXPORT_C void RMBufQ::Init()
/**
initializes the members
*/
	{
	RCommsBufQ::Init();
	}


EXPORT_C void RMBufQ::Assign(RMBufQ& aQueue)
/**
Assign this queue to a MBuf queue
@param aQueue to queue
*/
	{
	RCommsBufQ::Assign(aQueue);
	}


EXPORT_C void RMBufQ::Assign(RMBufChain& aChain)
/**
Assign this a MBuf chain to this queue
@param aChain the chain
*/
 	{
 	RCommsBufQ::Assign(aChain);
	}


EXPORT_C void RMBufQ::Free()
/**
Frees the queue making it empty
*/
	{
	RCommsBufQ::Free();
	}


EXPORT_C void RMBufQ::Append(RMBuf* aBuf)
/**
Appends a MBuf to the queue
@param aBuf the buffer to be prepended
*/
 	{
 	RCommsBufQ::Append(aBuf);
	}


EXPORT_C void RMBufQ::Prepend(RMBuf* aBuf)
/**
Prepends one MBuf to this queue. aBuf must not point to any further Mbufs.
@param aBuf the buffer to be appended
*/
	{
	RCommsBufQ::Prepend(aBuf);
	}


EXPORT_C void RMBufQ::Append(RMBufQ& aQueue)
/**
Appends a MBuf queue to this queue
@param aQueue the queue to be appended
*/
 	{
 	RCommsBufQ::Append(aQueue);
	}


EXPORT_C void RMBufQ::Append(RMBufChain& aChain)
/**
Appends a MBuf chain to this queue
@param aChain the chain to be appended
*/
 	{
 	RCommsBufQ::Append(aChain);
	}


EXPORT_C void RMBufQ::Prepend(RMBufChain& aChain)
/**
Prepends a MBuf chain to this queue
@param aChain the chain to be prepended
*/
 	{
 	RCommsBufQ::Prepend(aChain);
	}


EXPORT_C void RMBufQ::Prepend(RMBufQ& aQueue)
/**
Prepends a MBuf queue to this queue
@param aQueue the queue to be prepended
*/ 
 	{
 	RCommsBufQ::Prepend(aQueue);
	}


EXPORT_C RMBuf* RMBufQ::Remove()
/**
Removes the first MBuf from the queue
@return the MBuf
*/
	{
	return static_cast<RMBuf*>(RCommsBufQ::Remove());
	}

EXPORT_C TInt RMBufQ::Transfer(RMBufQ& aQueue, TInt aSize, TInt aBufSize)
/**
For the benefit of the MBuf allocator
Grab as many buffer as possible, as quickly as possible.
@param aQueue the queue
@param aSize the size
@return aSize - buffer_space_transfered
*/
	{
	TInt bufCount;
	return RCommsBufQ::Transfer(aQueue, aSize, aBufSize, bufCount);
	}

EXPORT_C RMBuf* RMBufQ::RemoveLast()
/**
Removes and returns the last RMBuf from the queu
 */
    {
    return static_cast<RMBuf*>(RCommsBufQ::RemoveLast());
    }

//
// MBUF PACKET QUEUE
//

__IMPLEMENT_CLEANUP(RMBufPktQ, Free)


EXPORT_C void RMBufPktQ::Init()
/**
Initializes the the members
*/
	{
	iNext.Init();
	iLast.Init();
	}


EXPORT_C void RMBufPktQ::Free()
/**
Frees the RMBuf Paket Queue, delets all objects
*/
	{
	RMBufChain chain;
	while (Remove(chain))
		chain.Free();
	}


EXPORT_C void RMBufPktQ::Append(RMBufChain& aChain)
/**
Appends a MBuf chain to the queue
@param aCHain A MBuf Chain
*/
 	{
	if (IsEmpty())
		{
		iNext = aChain;
		iLast = aChain;
		}
	else
		{
		iLast.Link(aChain);
		iLast = aChain;
		}
	aChain.Init();
	}


EXPORT_C void RMBufPktQ::Append(RMBufPktQ& aQueue)
/**
Appends a queue to the queue
@param aQueue a BMuf Paket Queue
*/
 	{
	if (aQueue.IsEmpty())
		return;

	if (IsEmpty())
		{
		iNext = aQueue.iNext;
		iLast = aQueue.iLast;
		}
	else
		{
		iLast.Link(aQueue.iNext);
		iLast = aQueue.iLast;
		}
	aQueue.Init();
	}


EXPORT_C void RMBufPktQ::Prepend(RMBufChain& aChain)
/**
Prepends a MBuf chain to the queue
@param aCHain A MBuf Chain
*/
 	{
	if (IsEmpty())
		{
		iNext = aChain;
		iLast = aChain;
		}
	else
		{
		aChain.Link(iNext);
		iNext = aChain;
		}
	aChain.Init();
	}


EXPORT_C TBool RMBufPktQ::Remove(RMBufChain& aChain)
/**
Prepends a queue to the queue
@param aQueue a BMuf Packet Queue
*/
	{
	if (IsEmpty())
		return EFalse;

	aChain = iNext;

	if (iNext = iNext.Next(), iNext.IsEmpty())
		iLast.Init();

	aChain.Unlink();
	return ETrue;
	}


void RMBufPktQ::Insert(RMBufChain& aNew, RMBufChain& aPrev)
/**
Inserts a MBuf chain next to a member in the queue
@param aNew A MBuf chain to be inserted
@param aPrev the member (a RMBufChain object) of the chain next to which the chain in inserted into
*/
	{
	if (aPrev.IsEmpty())
		Prepend(aNew);
	else if (aPrev.Next().IsEmpty())
 		Append(aNew);
	else
		{
		RMBufChain tmp;
		tmp.Assign(aNew);
		tmp.Link(aPrev.Next());
		aPrev.Link(tmp);
		}
	}

void RMBufPktQ::Remove(RMBufChain& aNew, RMBufChain& aPrev)
/**
Removes the part after a member from the queue
@param aNew the resulted removed part
@param aPrevious the memeber (a RMBufChain object) of the chain the part of which is removed from the queue
*/
	{
	if (aPrev.IsEmpty())
		(void)Remove(aNew);
	else
		{
		aNew.Assign(aPrev.Next());
		aPrev.Link(aNew.Next());
		aNew.Unlink();
		}
	}

EXPORT_C void TMBufPktQIter::Insert(RMBufChain& aNewChain)
/**
Inserts a chain into the queue to the part after current position
@param aNewChain the chain to be inserted
*/
	{
	iQueue->Insert(aNewChain, iPrev);
	TidyAfterUpdate();
	}

EXPORT_C void TMBufPktQIter::Remove(RMBufChain& aNewChain)
/**
Removes the part after the current position
@param aNewChain the resulted removed queue
*/
	{
	iQueue->Remove(aNewChain, iPrev);
	TidyAfterUpdate();
	}

EXPORT_C const RMBufChain& TMBufPktQIter::operator ++(TInt)
/**
Operator ++
move to the next position in the queue
*/
	{
	if (iPrev = iCurrent, !iPrev.IsEmpty())
		iCurrent = iPrev.Next();
	return iPrev;
	}

EXPORT_C void TMBufPktQIter::TidyAfterUpdate()
/**
Update the current position, after update
if the current position becomes empty after update - the current position will
be the first in the queue, else the next in the queue
*/
	{
	if (iPrev.IsEmpty())
		SetToFirst();
	else
		iCurrent = iPrev.Next();
	}