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

//

#include <e32base.h>

//

//

//	Implementation of LOCAL functions - helper functions

//

//

template<class HBufCType, class TPtrCType, class TDelimitedParserType>

TInt DoDelimitedDataParsingL(const TDelimitedParserType& aParser, VA_LIST& aSegments)

	{

	// Loop through the list

	TPtrCType parseSegment;

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aSegments);

	while( pExpected )

		{

		// Get the parsed segment - test GetNext()

		if( aParser.GetNext(parseSegment) == KErrNotFound )

			{

			// Should have found something - error!

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Got the segment - compare against expected

		if( parseSegment.Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Ok, test Dec()...

		if( aParser.Dec() != KErrNone )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Test Peek()

		if( aParser.Peek(parseSegment) == KErrNotFound )

			{

			// Should have found something - error!

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Got the segment - compare against expected

		if( parseSegment.Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Ok, test Inc()...

		if( aParser.Inc() != KErrNone )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Ok get next expected segment

		CleanupStack::PopAndDestroy(pExpected);	// pExpected

		pExpected = GetNextArgLC<HBufCType>(aSegments);

		}

	// Got to the end - should parse no more segments

	if( aParser.GetNext(parseSegment) != KErrNotFound )

		{

		// Should not have found something - error!

		return KErrNotFound;

		}

	// Ok, test Dec()...

	if( aParser.Dec() != KErrNone )

		{

		return KErrNotFound;

		}

	// Test Peek()

	if( aParser.Peek(parseSegment) == KErrNotFound )

		{

		// Should have found something - error!

		return KErrNotFound;

		}

	// Ok, test Inc()...

	if( aParser.Inc() != KErrNone )

		{

		return KErrNotFound;

		}

	// Ok, test Eos()

	if( !aParser.Eos() != KErrNone )

		{

		return KErrNotFound;

		}

	return KErrNone;

	}

template<class HBufCType>

HBufCType* GetNextArgLC(VA_LIST& aList)

	{

	const TDesC* arg = VA_ARG(aList, const TDesC*);

	if( arg == NULL )

		{

		return NULL;

		}

	HBufCType* buf = HBufCType::NewLC(arg->Length());

	buf->Des().Copy(*arg);

	return buf;

	}

template<class TDelimitedParserType>

TInt DoDelimiterPresenceTest(const TDelimitedParserType& aParser, TBool aFrontDelim, TBool aBackDelim)

	{

	TBool frontDelim = aParser.FrontDelimiter();

	if( (!frontDelim && aFrontDelim) | (frontDelim && !aFrontDelim) )

		{

		return KErrNotFound;

		}

	TBool backDelim = aParser.BackDelimiter();

	if( (!backDelim && aBackDelim) | (backDelim && !aBackDelim) )

		{

		return KErrNotFound;

		}

	return KErrNone;

	}

template<class HBufCType, class TPtrCType, class TDelimitedParserType>

TInt DoDelimitedDataRemainderTestL(const TDelimitedParserType& aParser, VA_LIST& aRemainders)

	{

	// Loop through the list

	TPtrCType parseRemainder;

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aRemainders);

	while( pExpected )

		{

		// Get the remaining data

		if( aParser.Remainder(parseRemainder) == KErrNotFound )

			{

			// Should have found something - error!

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Got the remainder - compare against expected

		if( parseRemainder.Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Ok, parse the to the next segment...

		if( aParser.Inc() != KErrNone )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Ok get next expected remainder

		CleanupStack::PopAndDestroy(pExpected);	// pExpected

		pExpected = GetNextArgLC<HBufCType>(aRemainders);

		}

	// Got to the end - should get no remainder

	if( aParser.Remainder(parseRemainder) != KErrNotFound )

		{

		// Should not have found something - error!

		return KErrNotFound;

		}

	return KErrNone;

	}

template<class TDelimitedParserType, class TDesCType>

TInt DoDelimitedDataDes(const TDelimitedParserType& aParser, const TDesCType& aDelimitedData)

	{

	if( aParser.Des().Compare(aDelimitedData) != 0)

		{

		return KErrNotFound;

		}

	return KErrNone;

	}

template<class HBufCType, class CDelimitedDataType>

TInt DoDelimitedDataPushFrontL(CDelimitedDataType* aParser, VA_LIST& aData)

	{

	// Loop through the list

	TInt error = KErrNone;

	HBufCType* pData = GetNextArgLC<HBufCType>(aData);

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);

	while( pExpected && pData )

		{

		// Push front

		TRAP(error, aParser->PushFrontL(*pData));

		if( error != KErrNone )

			{

			CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

			return error;

			}

		// Check against expected

		if( aParser->Parser().Des().Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

			return KErrNotFound;

			}

		// Ok get next set of data

		CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

		pData = GetNextArgLC<HBufCType>(aData);

		pExpected = GetNextArgLC<HBufCType>(aData);

		}

	return KErrNone;

	}

template<class HBufCType, class CDelimitedDataType>

TInt DoDelimitedDataPushBackL(CDelimitedDataType* aParser, VA_LIST& aData)

	{

	// Loop through the list

	TInt error = KErrNone;

	HBufCType* pData = GetNextArgLC<HBufCType>(aData);

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);

	while( pExpected && pData )

		{

		// Push front

		TRAP(error, aParser->PushBackL(*pData));

		if( error != KErrNone )

			{

			CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

			return error;

			}

		// Check against expected

		if( aParser->Parser().Des().Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

			return KErrNotFound;

			}

		// Ok get next set of data

		CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

		pData = GetNextArgLC<HBufCType>(aData);

		pExpected = GetNextArgLC<HBufCType>(aData);

		}

	return KErrNone;

	}

template<class HBufCType, class CDelimitedDataType>

TInt DoDelimitedDataPopFrontL(CDelimitedDataType* aParser, VA_LIST& aData)

	{

	// Loop through the list

	TInt error = KErrNone;

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);

	while( pExpected )

		{

		// Push front

		TRAP(error, aParser->PopFrontL());

		if( error != KErrNone )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return error;

			}

		// Check against expected

		if( aParser->Parser().Des().Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Ok get next set of data

		CleanupStack::PopAndDestroy(pExpected);	// pExpected

		pExpected = GetNextArgLC<HBufCType>(aData);

		}

	return KErrNone;

	}

template<class HBufCType, class CDelimitedDataType>

TInt DoDelimitedDataPopBackL(CDelimitedDataType* aParser, VA_LIST& aData)

	{

	// Loop through the list

	TInt error = KErrNone;

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);

	while( pExpected )

		{

		// Push front

		TRAP(error, aParser->PopBackL());

		if( error != KErrNone )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return error;

			}

		// Check against expected

		if( aParser->Parser().Des().Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Ok get next set of data

		CleanupStack::PopAndDestroy(pExpected);	// pExpected

		pExpected = GetNextArgLC<HBufCType>(aData);

		}

	return KErrNone;

	}

template<class CDelimitedDataType>

TInt DoDelimitedDataAddAndTrimFrontAndBackDelimiterL(CDelimitedDataType* aParser)

	{

	TInt error = KErrNone;

	// Add front delimiter

	TRAP(error, aParser->AddFrontDelimiterL());

	if( error != KErrNone )

		{

		return KErrNotFound;

		}

	if( !aParser->Parser().FrontDelimiter() )

		{

		return KErrNotFound;

		}

	// Trim front delimiter

	TRAP(error, aParser->TrimFrontDelimiterL());

	if( error != KErrNone )

		{

		return KErrNotFound;

		}

	if( aParser->Parser().FrontDelimiter() )

		{

		return KErrNotFound;

		}

	// Add back delimiter

	TRAP(error, aParser->AddBackDelimiterL());

	if( error != KErrNone )

		{

		return KErrNotFound;

		}

	if( !aParser->Parser().BackDelimiter() )

		{

		return KErrNotFound;

		}

	// Trim back delimiter

	TRAP(error, aParser->TrimBackDelimiterL());

	if( error != KErrNone )

		{

		return KErrNotFound;

		}

	if( aParser->Parser().BackDelimiter() )

		{

		return KErrNotFound;

		}

	return KErrNone;

	}

template<class CDelimitedDataType>

TInt DoDelimitedDataParseToPosition(CDelimitedDataType* aParser, TInt aStartPos)

	{

	// Parse to correct place - initial parse must have been done

	TInt i=0;

	while( i < aStartPos && !aParser->Parser().Eos() )

		{

		aParser->Parser().Inc();

		++i;

		}

	if( i != aStartPos )

		{

		return KErrNotFound;

		}

	return KErrNone;

	}

template<class HBufCType, class TPtrCType, class CDelimitedDataType>

TInt DoDelimitedDataInsertL(CDelimitedDataType* aParser, VA_LIST& aData)

	{

	// Loop through the list and insert!

	TInt error = KErrNone;

	HBufCType* pData = GetNextArgLC<HBufCType>(aData);

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);

	while( pExpected && pData )

		{

		// Get copy of current segment

		TPtrCType seg;

		aParser->Parser().Peek(seg);

		HBufCType* segCopy = seg.AllocLC();

		// Insert current

		TRAP(error, aParser->InsertCurrentL(*pData));

		if( error != KErrNone )

			{

			CleanupStack::PopAndDestroy(3, pData);	// pData, pExpected, segCopy

			return error;

			}

		// Check against expected

		if( aParser->Parser().Des().Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(3, pData);	// pData, pExpected, segCopy

			return KErrNotFound;

			}

		// Check that the current segment hasn't changed

		aParser->Parser().Peek(seg);

		if( segCopy->Compare(seg) != 0 )

			{

			CleanupStack::PopAndDestroy(3, pData);	// pData, pExpected, segCopy

			return KErrNotFound;

			}

		// Ok get next set of data

		CleanupStack::PopAndDestroy(3, pData);	// pData, pExpected, segCopy

		pData = GetNextArgLC<HBufCType>(aData);

		pExpected = GetNextArgLC<HBufCType>(aData);

		}

	return KErrNone;

	}

template<class HBufCType, class TPtrCType, class CDelimitedDataType>

TInt DoDelimitedDataRemoveL(CDelimitedDataType* aParser, VA_LIST& aData)

	{

	// Loop through the list

	TInt error = KErrNone;

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);

	while( pExpected )

		{

		// Remove current

		TRAP(error, aParser->RemoveCurrentL());

		if( error != KErrNone )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return error;

			}

		// Check against expected

		if( aParser->Parser().Des().Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(pExpected);	// pExpected

			return KErrNotFound;

			}

		// Ok get next set of data

		CleanupStack::PopAndDestroy(pExpected);	// pExpected

		pExpected = GetNextArgLC<HBufCType>(aData);

		}

	return KErrNone;

	}

template<class HBufCType, class TPtrCType, class CDelimitedDataType>

TInt DoDelimitedDataInsertAndEscapeL(CDelimitedDataType* aParser, VA_LIST& aData)

	{

	// Loop through the list and insert!

	TInt error = KErrNone;

	HBufCType* pData = GetNextArgLC<HBufCType>(aData);

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);

	while( pExpected && pData )

		{

		// Get copy of current segment

		TPtrCType seg;

		aParser->Parser().Peek(seg);

		HBufCType* segCopy = seg.AllocLC();

		// Insert current

		TRAP(error, aParser->InsertAndEscapeCurrentL(*pData));

		if( error != KErrNone )

			{

			CleanupStack::PopAndDestroy(3, pData);	// pData, pExpected, segCopy

			return error;

			}

		// Check against expected

		if( aParser->Parser().Des().Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(3, pData);	// pData, pExpected, segCopy

			return KErrNotFound;

			}

		// Check that the current segment hasn't changed

		aParser->Parser().Peek(seg);

		if( segCopy->Compare(seg) != 0 )

			{

			CleanupStack::PopAndDestroy(3, pData);	// pData, pExpected, segCopy

			return KErrNotFound;

			}

		// Ok get next set of data

		CleanupStack::PopAndDestroy(3, pData);	// pData, pExpected, segCopy

		pData = GetNextArgLC<HBufCType>(aData);

		pExpected = GetNextArgLC<HBufCType>(aData);

		}

	return KErrNone;

	}

template<class HBufCType, class CDelimitedDataType>

TInt DoDelimitedDataPushAndEscapeFrontL(CDelimitedDataType* aParser, VA_LIST& aData)

	{

	// Loop through the list

	TInt error = KErrNone;

	HBufCType* pData = GetNextArgLC<HBufCType>(aData);

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);

	while( pExpected && pData )

		{

		// Push front

		TRAP(error, aParser->PushAndEscapeFrontL(*pData));

		if( error != KErrNone )

			{

			CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

			return error;

			}

		// Check against expected

		if( aParser->Parser().Des().Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

			return KErrNotFound;

			}

		// Ok get next set of data

		CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

		pData = GetNextArgLC<HBufCType>(aData);

		pExpected = GetNextArgLC<HBufCType>(aData);

		}

	return KErrNone;

	}

template<class HBufCType, class CDelimitedDataType>

TInt DoDelimitedDataPushAndEscapeBackL(CDelimitedDataType* aParser, VA_LIST& aData)

	{

	// Loop through the list

	TInt error = KErrNone;

	HBufCType* pData = GetNextArgLC<HBufCType>(aData);

	HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);

	while( pExpected && pData )

		{

		// Push front

		TRAP(error, aParser->PushAndEscapeBackL(*pData));

		if( error != KErrNone )

			{

			CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

			return error;

			}

		// Check against expected

		if( aParser->Parser().Des().Compare(*pExpected) != 0 )

			{

			CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

			return KErrNotFound;

			}

		// Ok get next set of data

		CleanupStack::PopAndDestroy(2, pData);	// pData, pExpected

		pData = GetNextArgLC<HBufCType>(aData);

		pExpected = GetNextArgLC<HBufCType>(aData);

		}