// 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:

// This file implements the management of strings for matching between the chat buffer (also

// called the history buffer) and the chat strings.  The chat buffer is a single buffer that

// contains information that has been written to the test harness from the tsy.  The chat

// strings are the expected strings specified in the scripting language (in the RxEvents).

// The expected or chat strings must match the strings received from the TSY.  

// This file also includes the logic to support the use of buffer markers to be associated with

// the history buffer and the Chat strings.  Essentially, these buffer markers delimit the 

// range of addresses in the history buffer where data associated with a particular command 

// could be found.  The buffer marker structure only contains one address and uses the current

// last character address as it's other delimeter.

// 

//

/**

 @file

*/

#include "Te_LoopBackATSTD.H"

#include "Te_LoopBackSCHAT.H"

#include "Te_LoopBackSLOGGER.H"

CCommChatString* CCommChatString::NewL(const TDesC8& aDes, TBool aIsFolded)

/**

 * 2 Phase Constructor

 *

 * This method creates a CCommChatString instance.  After newing the necessary, it

 * pushes the chat string pointer onto the stack.  Then it calls it's second stage

 * constructor (in this case the CreateL method), passing the parameters passed to

 * this method.

 *

 * @param	aDes references the descriptor that contains the string.

 * @param	aIsFolded a boolean that indicates the "foldedness" of this string.

 *

 * @leave	This function will leave if the system is out of memory or unable 

 *			to allocate the amount of memory requested.

 * 

 * @return	A pointer to the newly created CCommChatString

 */

	{

	CCommChatString* cs = new (ELeave) CCommChatString;

	CleanupStack::PushL(cs);

	cs->CreateL(aDes, aIsFolded);

	CleanupStack::Pop();

	return cs;

	}

CCommChatString::CCommChatString()

/**

 * This method is the standard constructor for the class CCommChatString.

 */

	{

	__DECLARE_NAME(_S("CCommChatString"));

	}

CCommChatString::~CCommChatString()

/**

 * This method is the standard destructor.  It frees the memory allocated in the CreateL

 * method during construction.

 *

 * @return	None.

 */

	{

	User::Free(iString);

	}

void CCommChatString::CreateL(const TDesC8& aDes, TBool aIsFolded)

/**

 * Second Phase of Constructor

 *

 * This method is used as the second phase of the constructor for the CComChatString

 * class.  It allocates heap memory as specified by the passed in descriptor's length.

 * Then, the string located in the descriptor is copied into the newly allocated memory.

 * The member data iLastChar is initialized to point to the last byte copied.  The member

 * data iIsFolded is initialized to the passed parameter.

 *

 * @param aDes The descriptor containing the string data specified by the caller.

 * @param aIsFolded A boolean indicating whether or not the string is folded.

 * 

 * @leave	Leaves via User::AllocL if memory can not be allocated.

 */

	{

	iIsFolded = aIsFolded;

	iString = (TText8*) User::AllocL(aDes.Length());

	iLastChar = (iString+aDes.Length())-1;

	Mem::Copy(iString, (TUint8*)aDes.Ptr(), aDes.Length());

	}

//

// CCommChatter

//

CCommChatter::CCommChatter(MCommChatNotify* aNotify, TInt aPriority)

	: CTimer(aPriority), iNotify(aNotify)

/**

 * The constructor for the CCommChatter class.  It adds the active object to the active

 * scheduler of the current thread and initializes member data elements.

 * 

 * @param aNotify A pointer to the mixin class object associated with this object.  This 

 *                information is stored in the iNotify member.

 * @param aPriority The priority which is assigned to the timer this class derives from CTimer.

 */

	{

	__DECLARE_NAME(_S("CCommChatter"));

	CActiveScheduler::Add(this);

	iList.SetOffset(_FOFF(CCommChatString,iLink));

	iMarkWrapCnt=0;

	}

CCommChatter::~CCommChatter()

/**

 * The standard destructor associated with the CCommChatter class.  This method uses the 

 * DeleteAllAndStop method to free resources saved in the CCommChatter object.  Then it frees

 * the buffer created with CCommChatter.

 *

 * @return  None

 */

	{

	DeleteAllAndStop();

	User::Free(iBuffer);

	}

void CCommChatter::CreateL(TInt aBufSize)

/**

 * This method is really the second stage constructor for the CCommChatter class, though it is

 * not called by the typical CCommChatter::NewL() method.  The CCommChatter class is typically

 * created by another method (in the regression test case harness it is created in the 

 * CATIO::ConstructL() method), then this method is called.  This method allocates a buffer and

 * constructs the timer derived from CTimer in this class. The member data iBuffer, iBufferEnd,

 * and iMarkWrapCnt are initialized.

 *

 * @param  aBufSize The size of the buffer to be created with this object.

 * 

 * @leave  This method can Leave via User::AllocL if memory is not available.

 */

	{

	CTimer::ConstructL();

	iBuffer = (TText8*)User::AllocL(aBufSize);

	iBufferEnd = (iBuffer+aBufSize)-1;

	ClearHistory();

	iMarkWrapCnt=0;

	}

void CCommChatter::ClearHistory()

//

// Empty history

//

/**

 * This method resets the history of the CCommChatter buffer in the object.  It simply clears

 * the iCount and initializes the iLastChar member to iBuffer (the beginning of the buffer).

 *

 * @return	None.

 */

	{

	iLastChar = iBuffer;

	iCount = 0;

	}

void CCommChatter::AddCharL(TText8 aChar)

//

// Add a character to the history buffer

// Scan all strings to find any matches that may

// be completed.

//

/**

 * This method adds a single character to the history buffer and then scans all stored

 * strings to find any matches that may have been completed because this character has

 * been added.  The function deals with folded characters during the search.  Note that 

 * the routine first checks to see if the last character in the stored string matches

 * the input character.  This reduces the number of invocations of the string match 

 * functions.

 *

 * @param		aChar The character to add to the buffer.

 * @leave	This method can leave via the ChatStringMatchL call.

 */

	{

	// Add char to buffer

	if (++iLastChar>iBufferEnd)

		{

		iLastChar = iBuffer;

		iMarkWrapCnt++;

		}

	*iLastChar = aChar;

	++iCount;

	TText8 fchar = (TText8)User::Fold(aChar);

	// Scan for matching last character

	CCommChatString* cs;

	TDblQueIter<CCommChatString> iter(iList);

	while (cs = iter++, cs!=NULL)

		{

		if (cs->IsFolded()

			? (User::Fold(cs->LastChar())==fchar && MatchF(cs))

			: (cs->LastChar()==aChar && Match(cs)))

			{

			iNotify->ChatStringMatchL(cs);

			cs = iter;	// In case user removed cs;

			}

		}

	}

TBool CCommChatter::Match(const CCommChatString* aString) const

//

// Match a chat sgring against the history buffer

// (Case sensitive)

//

/**

 * This method matchs a chat string against the history buffer in a case sensitive (unfolded)

 * manner. First the length of the two strings is compared.  Then the actual content of the 

 * strings is compared.

 *

 * @param	aString	A constant pointer to the chat string.

 *

 * @return	ETrue if strings match, EFalse if they do not.

 */

	{

	const TText8* s = aString->Ptr();

	const TText8* sp = aString->EndPtr();

	const TText8* bp = iLastChar;

	if (iCount<aString->Length())

		return EFalse;

	while (*bp==*sp && sp>=s)

		{

		--sp;

		if (--bp<iBuffer)

			bp = iBufferEnd;

		}

	return sp<s;

	}

TBool CCommChatter::MatchF(const CCommChatString* aString) const

//

// Match a folded chat string against the history buffer.

// (Case insensitive)

//

/**

 * This method matchs a chat string against the history buffer in a case insensitive or folded

 * manner.  First the length of the two strings is compared.  Then the actual content of the 

 * strings is compared.

 *

 * @param	aString	A constant pointer to the chat string.

 *

 * @return	ETrue if strings match, EFalse if they do not.

 */

	{

	const TText8* s = aString->Ptr();

	const TText8* sp = aString->EndPtr();

	const TText8* bp = iLastChar;

	if (iCount<aString->Length())

		return EFalse;

	while (User::Fold(*bp)==User::Fold(*sp) && sp>=s)

		{

		--sp;

		if (--bp<iBuffer)

			bp = iBufferEnd;

		}

	return sp<s;

	}

void CCommChatter::GetChatBufferMarker(TInputBufferMark& aBufferMarker)

/**

 * This method sets up a buffer marker structure.  It saves the current last character

 * location and notes the wrap state of the buffer.

 *

 * @param	aBufferMarker A reference to a buffer marker structure.

 *          Is modified with the current location of iLastChar and a wrap flag.

 * @return	None

 */

	{

	aBufferMarker.iMarkChar=iLastChar;

	if(++aBufferMarker.iMarkChar>iBufferEnd)

		{

		aBufferMarker.iMarkWrap=iMarkWrapCnt+1;

		aBufferMarker.iMarkChar=iBuffer;

		}

	else

		aBufferMarker.iMarkWrap=iMarkWrapCnt;

	}

TPtrC8 CCommChatter::GetChatBufferLC(TInputBufferMark& aBufferMarker)

/**

 * This method deals with extracting data from the Chat or History Buffer and returning it

 * to the caller.  The data that is extracted from the buffer marker to the current last

 * character in the buffer.  This method creates a new HBufC8 object and returns a pointer

 * to that descriptor.  This method deals properly with a wrapped history buffer.

 *

 * @param		aBufferMarker is a reference to a buffer marker structure that has been

 *				previously initialized.  This buffer marker structure limits the range of the

 *				history buffer which must be copied/examined to find the relevant data.

 * @leave		Leaves if error processing buffer between the mark and the current

 *				last character.

 * @return		TPtrC8 pointer to a newly created HBufC8 which contains the iRxBuffer

 *				contents between the marker and the current last character.  Data that

 *				is of interest to this completion has been copied from the general 

 *				receive buffer to this buffer.

 */

	{

	TText8* markChar=aBufferMarker.iMarkChar;

	if(iMarkWrapCnt==aBufferMarker.iMarkWrap)

		{

		__ASSERT_ALWAYS(iLastChar>markChar,User::Leave(KErrGeneral));			// Internal Error

		HBufC8* buffer=HBufC8::NewLC(iLastChar-markChar+1);

		TPtr8 ptr(buffer->Des());

		ptr.Copy(markChar,iLastChar-markChar+1);

		return ptr;

		}

	else

		{

		if((iLastChar>markChar)||(iMarkWrapCnt>aBufferMarker.iMarkWrap+1))

			User::Leave(KErrGeneral);																						// Data Lost

		HBufC8* buffer=HBufC8::NewLC(KChatBufferSize-(markChar-iLastChar)+1);

		TPtr8 ptr(buffer->Des());

		ptr.Copy(TPtrC8(markChar,iBufferEnd-markChar+1));

		ptr.Append(TPtrC8(iBuffer,iLastChar-iBuffer+1));

		return ptr;

		}

	}

void CCommChatter::RunL()

/**

 * This is the RunL associated with the CTimer inherited by the CCommChatter class.  This 

 * RunL simply processess a timeout.

 *

 * @return	None

 */

	{

	iNotify->ChatTimeout();

	}

CCommChatString* CCommChatter::AddString(const TDesC8& aString)

/**

 * This method adds a string to the stored chat strings.  It creates a new chat string object

 * and adds it to the list of outstanding chat strings.

 *

 * @param	aString This is a constant TDesC8 reference that is used to create the new string.

 * @return	A pointer to the newly created CCommChatString object.

 */

	{

	CCommChatString* chatString=NULL;

	TRAP_IGNORE(chatString=CCommChatString::NewL(aString,ETrue));		// trap but ignore leaves

	iList.AddLast(*chatString);

	return chatString;

	}

void CCommChatter::RemoveString(CCommChatString* aString)

/**

 * This method removes a string from the stored chat strings.  It dequeues the string from the

 * list of stored chat strings but does not delete the object.

 *

 * @param	aString A pointer to a CCommChatString

 * @return	None

 */	{

	aString->iLink.Deque();

	}

void CCommChatter::DeleteAllAndStop()

/**

 * This method stops the outstanding CTimer and removes all of the outstanding chat strings

 * from the chat string list and deletes them.

 *

 * @return	None.

 */

	{

	StopTimer();

	CCommChatString* cs;

	while (!iList.IsEmpty())

		{

		cs = iList.First();

		RemoveString(cs);

		delete cs;

		}

	}

void CCommChatter::StartTimer(const TTimeIntervalMicroSeconds32 aTimeout)

/**

 * This method starts the timer associated with the CCommChatter class.  This timer

 * triggers after a specific interval of time.  This is a one shot timer.

 *

 * @param	aTimeout	The interval in micro-seconds before the timer should trigger.

 * @return	None

 */

	{

	if (IsActive())

		Cancel();

	After(aTimeout);

	}

void CCommChatter::StopTimer()

/**

 * This method simply stops the outstanding timer for the CCommChatter class.  This timer

 * is implemented via an active object by the CTimer class.

 *

 * @return	None

 */

	{

	Cancel();

	}