/*

* Copyright (c) 2002-2004 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:   Implements the definition of CICalContentLineReader. It reads the ICAL content.

*

*/

// Class include.

#include "ICalContentLineReader.h"	// CICalContentLineReader

//debug

#include "calendarengines_debug.h"

// System includes.

#include <s32strm.h>	// RReadStream

#include <utf.h>		// CnvUtfConverter

// User includes.

#include "ICalKeyWords.h"	// Literals.

// Constants.

const TInt KICalSkipWhiteSpaceLength = 1;

const TInt KICalSkipCRLength = 1;

const TInt KICalStartChar = 0;

/*

The iCalendar specification states that a content line should be no longer than

75 octets in length, excluding the CRLF delimiter. It appears that MS Outlook

does not include the length of the property string when calculating the length

of a content line, meaning that a content line in an iCalendar exported from MS

Outlook may be longer than the allowed 75 octets. KICalMaxContentLineLength

allows a little extra space to support this.

*/

const TInt KICalMaxContentLineLength = 120;

/**

Allocates and constructs a new CICalContentLineReader.

@param aStream A stream containing iCalendar information to import.

@return The newly constructed CICalContentLineReader.

@internalTechnology

*/

CICalContentLineReader* CICalContentLineReader::NewL(RReadStream& aStream)

	{

	TRACE_ENTRY_POINT;

	CICalContentLineReader* self = CICalContentLineReader::NewLC(aStream);

	CleanupStack::Pop(self);

	TRACE_EXIT_POINT;

	return self;

	}

/**

Allocates and constructs a new CICalContentLineReader.

The pointer to the new object is left on the Cleanup Stack.

@param aStream A stream containing iCalendar information to import.

@return The newly constructed CICalContentLineReader.

@internalTechnology

*/

CICalContentLineReader* CICalContentLineReader::NewLC(RReadStream& aStream)

	{

	TRACE_ENTRY_POINT;

	CICalContentLineReader* self = new (ELeave) CICalContentLineReader(aStream);

	CleanupStack::PushL(self);

	self->ConstructL();

	TRACE_EXIT_POINT;

	return self;

	}

/**

Destructor

@internalTechnology

*/

CICalContentLineReader::~CICalContentLineReader()

	{

	TRACE_ENTRY_POINT;

	delete iCurrentLine;

	delete iNextLine;

	TRACE_EXIT_POINT;

	}

/**

Reads the next content line from the stream into aPtr. If the content line has

been folded, it will be unfolded. After completion aPtr will point to the new

content line

@param aPtr TPtrC& to set to the new content line.

@return KErrNone if successful, KErrEof when the end of the stream is reached.

@internalTechnology

*/

TInt CICalContentLineReader::GetNextContentLine(TPtrC& aPtr)

	{

	TRACE_ENTRY_POINT;

	if (iFlags & EEof)

		{

		TRACE_EXIT_POINT;

		return KErrEof;

		}

	TInt error(KErrNone);

	// Trap errors as the stream will leave with KErrEof when we reach the end.

	TRAP(error, GetNextContentLineL());

	aPtr.Set(iCurrentLine->Des());

	if (error == KErrEof)

		{

		iFlags |= EEof;

		error = KErrNone;

		}

    TRACE_EXIT_POINT;

	return error;

	}

/**

Reads from the stream discarding lines until a matching 'END:' directive is

reached.

@param aName The name of the component we are skipping.

@leave KErrCorrupt if a matching END is not found.

@internalTechnology

*/

void CICalContentLineReader::SkipComponentL(const TDesC& aName)

	{

	TRACE_ENTRY_POINT;

	// Take a copy of the name, since GetNextContentLine may corrupt the original

	HBufC* beginName = aName.AllocLC();

	// Find the next BEGIN: or END:

	TPtrC contentLine;

	TInt error(GetNextContentLine(contentLine));

	while (error == KErrNone)

		{

		// Find the colon separator

		const TInt colonPos = contentLine.Locate(KICalColonChar);

		// If there isn't one it's an error

		if (colonPos == KErrNotFound)

			{

			User::Leave(KErrCorrupt);

			}

		// Find the string preceding the colon

		TPtrC name(contentLine.Left(colonPos));

		// If it's a begin, recursively skip this component also

		if (name.CompareF(KICalBegin) == 0)

			{

			TPtrC value(contentLine.Mid(colonPos + 1));

			SkipComponentL(value);

			}

		// If it's an end, check that it's the right end

		else if (name.CompareF(KICalEnd) == 0)

			{

			TPtrC value(contentLine.Mid(colonPos + 1));

			if (value.CompareF(*beginName) == 0)

				{

				// We have successfully skipped the component

				CleanupStack::PopAndDestroy(beginName);

				return;

				}

			else

				{

				User::Leave(KErrCorrupt);

				}

			}

		// If it is neither a begin nor an end, try the next line

		error = GetNextContentLine(contentLine);

		}

	// If any errors occur in reading we may as well leave with them

	if (error != KErrEof)

		{

		User::Leave(error);

		}

	// If we get this far we have failed to find an end

	User::Leave(KErrCorrupt);

	TRACE_EXIT_POINT;

	}

/**

Default constructor.

@param aStream A stream containing iCalendar information to import.

@internalTechnology

*/

CICalContentLineReader::CICalContentLineReader(RReadStream& aStream)

	: iReadStream(aStream)

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	}

/**

Second phase construction.

@internalTechnology

*/

void CICalContentLineReader::ConstructL()

	{

	TRACE_ENTRY_POINT;

	iCurrentLine = HBufC::NewL(KICalMaxContentLineLength);

	iNextLine = HBufC::NewL(KICalMaxContentLineLength);

	TRACE_EXIT_POINT;

	}

/**

Reads from the stream to the next line feed.

@param aPtr A modifiable pointer to a buffer to read the line into.

@leave With KErrEof when the end of the stream is reached or KErrCorrupt if the

line is invalid.

@internalTechnology

*/

void CICalContentLineReader::GetLineL(TPtr& aPtr)

	{

	TRACE_ENTRY_POINT;

	// Read stream as binary. ReadL() will leave with KErrEof when the end of the stream

	// is reached. Note that we will ignore any text read when leaving as the line must end

	// with a carriage return (and line feed) to be valid.

	TBuf8<KICalMaxContentLineLength> text;

	iReadStream.ReadL(text, TChar(KICalCarriageReturnChar));	// Read up to the next CR.

	// Check next char is line feed

	TUint8 nextChar(iReadStream.ReadUint8L());

	if (nextChar != KICalNewlineChar)

		{

		User::Leave(KErrCorrupt);

		}

	// Handle any character set conversion here

	CnvUtfConverter::ConvertToUnicodeFromUtf8(aPtr, text);	// Convert from UTF-8.

	// Set the length of aPtr to exclude the carriage return.

	if (aPtr.Length())

		{

		aPtr.SetLength(aPtr.Length() - KICalSkipCRLength);

		}

	TRACE_EXIT_POINT;

	}

/**

Reads the next content line from the stream into aPtr. If the content line has

been folded, it will be unfolded. After completion aPtr will point to the new

content line

@param aPtr TPtrC& to set to the new content line.

@leave Leaves with KErrEof when we reach the end of the stream.

@internalTechnology

*/

void CICalContentLineReader::GetNextContentLineL()

	{

	TRACE_ENTRY_POINT;

	TPtr currentLine(iCurrentLine->Des());

	if (iNextLine->Length() == 0)

		{

		// If iNextLine is empty then this is the first line of the file.

		GetLineL(currentLine);

		}

	else

		{

		// Copy iNextLine to currentLine.

		currentLine.Copy(*iNextLine);

		}

	// Get the next line.

	TPtr nextPtr(iNextLine->Des());

	GetLineL(nextPtr);

	// Folded lines are delimited by a CRLF followed by single whitepace

	while (iNextLine->Length() && ((nextPtr[KICalStartChar] == KICalSpaceChar) ||

		(nextPtr[KICalStartChar] == KICalHTabChar)))

		{

		// Append the lines - reallocate buffer if needed.

		if (currentLine.MaxLength() < (iCurrentLine->Length() + nextPtr.Length()))

			{

			iCurrentLine = iCurrentLine->ReAllocL(currentLine.MaxLength() + KICalMaxContentLineLength);

			currentLine.Set(iCurrentLine->Des());

			}

		currentLine.Append(nextPtr.Mid(KICalSkipWhiteSpaceLength));

		GetLineL(nextPtr);

		}

	TRACE_EXIT_POINT;

	}

// End of File