--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/serialserver/packetloopbackcsy/src/LoopbackQueue.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,350 @@
+// Copyright (c) 2004-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:
+// This file implements a loopback driver for use with the ETel Regression test harness.  This
+// driver supports up to 100 virtual port connections, from port 501 to 600
+// directory exists.  The log file is named loopback.
+// 
+//
+
+/**
+ @file
+ @note	This driver will create a log file in the Logs\ETel directory if the Logs\ETel
+*/
+
+#include "LoopbackQueue.h"
+#include "LoopbackConfig.h"
+
+CTPtr8Queue* CTPtr8Queue::NewL(TInt aBufferLength, TInt aQueueLength)
+	{
+	CTPtr8Queue* me = new(ELeave) CTPtr8Queue(aQueueLength);
+	CleanupStack::PushL(me);
+	me->ConstructL(aBufferLength, aQueueLength);
+	CleanupStack::Pop(me);
+	return me;
+	}
+	
+CTPtr8Queue::CTPtr8Queue(TInt aQueueLength) : iFirstBuffer(0), iNextBuffer(0), iQueueFull(EFalse), 
+	iDescriptors(aQueueLength)
+	{}
+	
+void CTPtr8Queue::ConstructL(TInt aBufferLength, TInt aQueueLength)
+	{
+	HBufC8* buffer = HBufC8::NewL(aBufferLength*aQueueLength);
+	// don't push onto the cleanup stack, as we are assigning to member variable here
+	iBuffer = buffer;
+	TPtr8 tmp = buffer->Des();
+	tmp.AppendFill('C', aBufferLength*aQueueLength);
+	for (TInt i = 0; i < aQueueLength; i++)
+		{
+		TUint8& startChar = tmp[i*aBufferLength];
+		TPtr8 nextElement = TPtr8(&startChar, aBufferLength);
+		iDescriptors.AppendL(nextElement);
+		}
+	}
+	
+CTPtr8Queue::~CTPtr8Queue()
+	{
+	delete iBuffer;
+	}
+	
+void CTPtr8Queue::Clear()
+	{
+	iFirstBuffer = iNextBuffer = 0;
+	iQueueFull = EFalse;
+	}
+	
+TBool CTPtr8Queue::IsEmpty() const
+	{
+	if (iQueueFull)
+		return EFalse;
+	else
+		return iFirstBuffer == iNextBuffer;
+	}
+	
+TBool CTPtr8Queue::QueueLength() const
+	{
+	if (iQueueFull)
+		return iDescriptors.Count();
+	else
+		return Abs(iFirstBuffer - iNextBuffer) % iDescriptors.Count();
+	}
+	
+TBool CTPtr8Queue::IsFull() const
+	{
+	if (iQueueFull)
+		{
+		ASSERT(iFirstBuffer == iNextBuffer);
+		}
+	return iQueueFull;
+	}
+	
+TPtr8& CTPtr8Queue::GetNewBuffer()
+	{
+	ASSERT(!IsFull());
+	TPtr8& ret = iDescriptors[iNextBuffer];
+	iNextBuffer++;
+	if (iNextBuffer >= iDescriptors.Count())
+		iNextBuffer = 0;
+	if (iNextBuffer == iFirstBuffer)
+		iQueueFull = ETrue;
+	return ret;
+	}
+	
+const TPtr8& CTPtr8Queue::PeekFirstBuffer() const
+	{
+	ASSERT(!IsEmpty());
+	return iDescriptors[iFirstBuffer];
+	}
+
+TPtr8& CTPtr8Queue::DequeueFirstBuffer()
+	{
+	ASSERT(!IsEmpty());
+	TPtr8& ret = iDescriptors[iFirstBuffer];
+	iFirstBuffer++;
+	if (iFirstBuffer >= iDescriptors.Count())
+		iFirstBuffer = 0;
+	iQueueFull = EFalse;
+	return ret;
+	}
+
+MLoopbackQueue::~MLoopbackQueue()
+	{}
+	
+CPacketBufferQueue* CPacketBufferQueue::NewL(TInt aBufferLength, TInt aQueueLength)
+	{
+	CPacketBufferQueue* me = new (ELeave)CPacketBufferQueue(aBufferLength);
+	CleanupStack::PushL(me);
+	me->ConstructL(aBufferLength, aQueueLength);
+	CleanupStack::Pop(me);
+	return me;
+	}
+	
+CPacketBufferQueue::CPacketBufferQueue(TInt aBufferLength) : iBufferLength(aBufferLength)
+	{}
+	
+void CPacketBufferQueue::ConstructL(TInt aBufferLength, TInt aQueueLength)
+	{
+	iReadQueue = CTPtr8Queue::NewL(aBufferLength, aQueueLength);
+	iWriteQueue = CTPtr8Queue::NewL(aBufferLength, aQueueLength);
+	}
+	
+CPacketBufferQueue::~CPacketBufferQueue()
+	{
+	delete iReadQueue;
+	delete iWriteQueue;
+	}
+	
+TPtrC8 CPacketBufferQueue::PeekNextReadBuffer(TBool& aCompleteIfBufferNotFull) const
+	{
+	aCompleteIfBufferNotFull = ETrue;
+	return iReadQueue->PeekFirstBuffer();
+	}
+
+void CPacketBufferQueue::DiscardNextReadBuffer()
+	{
+	iReadQueue->DequeueFirstBuffer();
+	}
+
+void CPacketBufferQueue::AppendToReadBuffer(TDesC8& aSrcData)
+	{
+	TPtr8& destBuf = iReadQueue->GetNewBuffer();
+	destBuf.Copy(aSrcData);
+	}
+
+TPtrC8 CPacketBufferQueue::PeekNextWriteBuffer() const
+	{
+	return iWriteQueue->PeekFirstBuffer();
+	}
+
+void CPacketBufferQueue::DiscardNextWriteBuffer()
+	{
+	iWriteQueue->DequeueFirstBuffer();
+	}
+
+TPtr8 CPacketBufferQueue::AppendToWriteBuffer(TInt aLength)
+	{
+	TPtr8& newBuf = iWriteQueue->GetNewBuffer();
+	newBuf.FillZ(aLength);
+	newBuf.LeftTPtr(aLength);
+	return newBuf;
+	}
+
+TBool CPacketBufferQueue::IsReadBufferEmpty() const
+	{
+	return iReadQueue->IsEmpty();
+	}
+
+TBool CPacketBufferQueue::IsWriteBufferEmpty() const
+	{
+	return iWriteQueue->IsEmpty();
+	}
+
+TBool CPacketBufferQueue::IsReadBufferFull(TInt /*aLength*/) const
+	{
+	return iReadQueue->IsFull();
+	}
+
+TBool CPacketBufferQueue::IsWriteBufferFull(TInt /*aLength*/) const
+	{
+	return iWriteQueue->IsFull();
+	}
+
+TInt CPacketBufferQueue::BufferSize() const
+	{
+	return iBufferLength;
+	}
+
+void CPacketBufferQueue::Clear()
+	{
+	iWriteQueue->Clear();
+	iReadQueue->Clear();
+	}
+
+CSerialBufferQueue* CSerialBufferQueue::NewL(TInt aBufferLength, TCommConfigV01* aConfig)
+	{
+	CSerialBufferQueue* me = new (ELeave)CSerialBufferQueue(aBufferLength, aConfig);
+	CleanupStack::PushL(me);
+	me->ConstructL(aBufferLength);
+	CleanupStack::Pop(me);
+	return me;
+	}
+	
+CSerialBufferQueue::CSerialBufferQueue(TInt aBufferLength, TCommConfigV01* aConfig) : 
+	iBufferLength(aBufferLength), iConfig(aConfig), iWriteData(NULL, 0), iReadData(NULL, 0)
+	{}
+	
+void CSerialBufferQueue::ConstructL(TInt aBufferLength)
+	{
+	iReadBuffer = HBufC8::NewL(aBufferLength);
+	iWriteBuffer = HBufC8::NewL(aBufferLength);
+	iReadData.Set(iReadBuffer->Des());
+	iWriteData.Set(iWriteBuffer->Des());
+	}
+	
+CSerialBufferQueue::~CSerialBufferQueue()
+	{
+	delete iReadBuffer;
+	delete iWriteBuffer;
+	}
+	
+TPtrC8 CSerialBufferQueue::NextBuffer(const TPtrC8& aBuffer, TBool& aTerminatorFound) const
+	{
+	// Search for terminator characters
+	TInt len = 0;
+	aTerminatorFound = EFalse;
+	const TText8* terminators = iConfig->iTerminator;
+	TPtrC8 dataToTerminator(aBuffer);
+	for (TInt termNum = 0; termNum < iConfig->iTerminatorCount; ++termNum)
+		{
+		TInt termIndex = dataToTerminator.Locate(terminators[termNum]);
+		if (termIndex >= 0)
+			{
+			// Found the terminator; reduce the length of ptr and search for the next one
+			len = termIndex + 1;
+			dataToTerminator.Set(dataToTerminator.Ptr(), len);
+			aTerminatorFound = ETrue;
+			}
+		}
+	return dataToTerminator;
+	}
+
+TPtrC8 CSerialBufferQueue::PeekNextReadBuffer(TBool& aCompleteIfBufferNotFull) const
+	{
+	// if the terminator is found, we want the requrest completed even if the buffer is not full
+	return NextBuffer(iReadData, aCompleteIfBufferNotFull);
+	}
+
+void CSerialBufferQueue::DiscardNextReadBuffer()
+	{
+	TBool terminatorFound;
+	TPtrC8 dataToTerminator = NextBuffer(iReadData, terminatorFound);
+
+	if (terminatorFound)
+		{
+		TPtrC8 source = iReadData.Right(iReadData.Length()-dataToTerminator.Length());
+		iReadData.Copy(source);
+		}
+	else
+		{
+		iReadData.SetLength(0);
+		}
+	}
+
+void CSerialBufferQueue::AppendToReadBuffer(TDesC8& aSrcData)
+	{
+	ASSERT(aSrcData.Length() < iReadData.MaxLength()-iReadData.Length());
+	iReadData.Append(aSrcData);
+	}
+
+TPtrC8 CSerialBufferQueue::PeekNextWriteBuffer() const
+	{
+	TBool dummy;
+	return NextBuffer(iWriteData, dummy);
+	}
+
+void CSerialBufferQueue::DiscardNextWriteBuffer()
+	{
+	TBool terminatorFound;
+	TPtrC8 dataToTerminator = NextBuffer(iWriteData, terminatorFound);
+	
+	// Delete the write data from the buffer
+	if (terminatorFound)
+		{
+		TPtrC8 source = iWriteData.Right(iWriteData.Length()-dataToTerminator.Length());
+		iWriteData.Copy(source);
+		}
+	else
+		{
+		iWriteData.SetLength(0);
+		}
+	}
+
+TPtr8 CSerialBufferQueue::AppendToWriteBuffer(TInt aLength)
+	{
+	TInt length = iWriteData.Length();
+	ASSERT(aLength < iWriteData.MaxLength()-length);
+	iWriteData.AppendFill('C', aLength);
+	TUint8 *start = &iWriteData[length];
+	return TPtr8(start, aLength, aLength);
+	}
+	
+TBool CSerialBufferQueue::IsReadBufferEmpty() const
+	{
+	return iReadData.Length() == 0;
+	}
+
+TBool CSerialBufferQueue::IsWriteBufferEmpty() const
+	{
+	return iWriteData.Length() == 0;
+	}
+
+TBool CSerialBufferQueue::IsReadBufferFull(TInt aLength) const
+	{
+	return ( aLength > (iReadData.MaxLength()-iReadData.Length()) );
+	}
+
+TBool CSerialBufferQueue::IsWriteBufferFull(TInt aLength) const
+	{
+	return ( aLength > (iWriteData.MaxLength()-iWriteData.Length()) );
+	}
+
+TInt CSerialBufferQueue::BufferSize() const
+	{
+	return iWriteData.MaxLength()-iWriteData.Length();
+	}
+
+void CSerialBufferQueue::Clear()
+	{
+	}
+