diff -r 000000000000 -r dfb7c4ff071f commsfwutils/commsbufs/mbufmgr/src/mb_que.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commsfwutils/commsbufs/mbufmgr/src/mb_que.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,354 @@ +// 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 + +// +// 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(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(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(); + }