/*

* Copyright (c) 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:  Sources

*

*/

// INCLUDE FILES

#include <s32buf.h>

#include <s32file.h>

#include <nsmlfolderparser.h>

#include "nsmlparserconstants.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CNSmlFolderParser::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CNSmlFolderParser* CNSmlFolderParser::NewL()

	{

	CNSmlFolderParser* self = CNSmlFolderParser::NewLC();

	CleanupStack::Pop();

	return self;

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CNSmlFolderParser* CNSmlFolderParser::NewLC()

	{

	CNSmlFolderParser* self = new (ELeave) CNSmlFolderParser();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::~CNSmlFolderParser

// Destructor

// -----------------------------------------------------------------------------

//

EXPORT_C CNSmlFolderParser::~CNSmlFolderParser()

	{

	if(iExt) 

		{

		iExt->ResetAndDestroy();

		delete iExt;

		}

	if(iName) delete iName;

	if(iRole) delete iRole;

	if( iExtData ) delete iExtData;

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::ParseXml

// Parses through the given XML and places the data to member variables.

// Note: The method does not check whether the member variables 

// already contains data or not, but just writes it (if some of them are already 

// instantiated dynamically, they should be deleted before this method is called).

// -----------------------------------------------------------------------------

//

EXPORT_C TNSmlParserGeneratorError CNSmlFolderParser::ParseXml( HBufC8* aXml )

	{

	TRAPD(cdataErr, PreProcessL(aXml));

	if (cdataErr != EErrorNone)

		return (TNSmlParserGeneratorError)cdataErr;

	iSetValues.Reset();

	iCurrentState = EFolderNone;

	iLastState = EFolderNone;

	TPtrC8 ptr(*aXml);

	TRAPD(err, ParseL( ptr ));

	if( err == EErrorNone && iCurrentState != EFolderNone )

		return EInvalidXmlError;

	return CheckError(err);

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::GenerateXml

// Generates Folder-XML using the values in member variables. aXml contains the 

// generated xml when the function returns successfully. Note: caller should not 

// instantiate the HBufC8, since this method first counts the size of the 

// xml to be generated and then instatiates the HBufC8 with a correct maximum size.

// If the given buffer is not NULL, it is destroyed and a new one is instantiated.

// Caller gets the control of the HBufC8 when the function returns.

// -----------------------------------------------------------------------------

//

EXPORT_C TNSmlParserGeneratorError CNSmlFolderParser::GenerateXml( HBufC8*& aXml ) 

	{

	TRAPD( err, ConvertIntoEntitiesL(); // convert special characters into entities

			GenerateFolderXmlL( aXml ) );

	return CheckError(err);

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::GenerateFolderXmlL

// Private methods that does the actual folder xml generation

// -----------------------------------------------------------------------------

//

void CNSmlFolderParser::GenerateFolderXmlL( HBufC8*& aXml )

	{

	// count the size of the xml

	TInt size = CountXmlSizeL();

	// create buffer for the xml

	if ( aXml )

		{

		delete aXml;

		aXml = NULL;

		}

	aXml = HBufC8::NewLC(size);

	TPtr8 ptr = aXml->Des();

	AppendElement(ptr, KFolderElement());

	if ( iName )

		{

		AppendElement(ptr, KFolderNameElement(), *iName);

		}

	if (iCreated != Time::NullTTime())

		{

		AppendElement(ptr, KFolderCreatedElement(), DateTimeToStringL(iCreated));

		}

	if (iModified != Time::NullTTime())

		{

		AppendElement(ptr, KFolderModifiedElement(), DateTimeToStringL(iModified));

		}

	if (iAccessed != Time::NullTTime())

		{

		AppendElement(ptr, KFolderAccessedElement(), DateTimeToStringL(iAccessed));

		}

	if (iAttributes.AttributeCount() > 0)

		{

		iAttributes.GenerateXml(ptr, this);

		}

	if ( iRole )

		{

		AppendElement(ptr, KFolderRoleElement(), *iRole);

		}

	if ( iExt )

		{

		for (TInt i=0; i < iExt->Count(); ++i)

			{

			iExt->At(i)->GenerateXmlL(ptr, this);

			}

		}

	AppendEndElement(ptr, KFolderElement());

	CleanupStack::Pop(); // aXml

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::CountXmlSizeL

// Counts how long the xml string will be if it was generated using 

// the values currently in member variables.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CNSmlFolderParser::CountXmlSizeL()

	{

	TInt size = 0;

	size += SizeOfElements( KFolderElement() );

	size += KCDataStart().Length() + KCDataEnd().Length();

	if ( iName )

		{

		size += SizeOfString( iName, KFolderNameElement() );

		}

	if (iCreated != Time::NullTTime())

		{

		size += SizeOfDatetime( KFolderCreatedElement() );

		}

	if (iModified != Time::NullTTime())

		{

		size += SizeOfDatetime( KFolderModifiedElement() );

		}

	if (iAccessed != Time::NullTTime())

		{

		size += SizeOfDatetime( KFolderAccessedElement() );

		}

	// attributes, if any present

	if (iAttributes.AttributeCount() > 0)

		{

		size += iAttributes.CountXmlSize( this );

		}

	if ( iRole )

		{

		size += SizeOfString( iRole, KFolderRoleElement() );

		}

	if ( iExt )

		{

		for (TInt i=0; i < iExt->Count(); ++i)

			{

			size += iExt->At(i)->CountXmlSize( this );

			}

		}

	return size;

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::AddExtL

// Adds the given extension to iExt

// -----------------------------------------------------------------------------

//

EXPORT_C void CNSmlFolderParser::AddExtL( CNSmlExtData* aExt )

	{

	iExt->AppendL(aExt);

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::NextElementL

// Base class' ParseL method calls this method, when a new element is found. aElement 

// is the name of that element (string inside '<' and '>' characters).

// -----------------------------------------------------------------------------

//

void CNSmlFolderParser::NextElementL( TPtrC8 aElement )

	{

	if (aElement.Length() == 0)

		User::Leave(EInvalidXmlError);

	TBool startElement = ETrue;

	if(aElement[0] == KCharacterSlash)

		{

		// end element

		// remove the '/' character from the beginning

		aElement.Set( aElement.Right( aElement.Length() - 1 ) );

		startElement = EFalse;

		}

#ifndef __NO_EMPTY_ELEMENTS_

	else if (aElement[aElement.Length()-1] == KCharacterSlash)

		{

		// empty element

		// remove the '/' character from the end

		aElement.Set( aElement.Left( aElement.Length() - 1 ) );

		// empty element == start element, empty data, end element

		NextElementL( aElement ); // simulates start element

		NextDataL( _L8("") ); // simulates the empty data

		HBufC8* end = HBufC8::NewLC(aElement.Length()+1);

		TPtr8 ptr = end->Des();

		ptr.Append( _L8("/") );

		ptr.Append( aElement );

		NextElementL( ptr ); // simulates end element

		CleanupStack::PopAndDestroy(); // end

		return;

		}

#endif

	// variables used for state, init to <Folder> and not set

	TNSmlCurrentFolderElement inner = EFolder;

	TNSmlCurrentFolderElement outer = EFolder;

	TBool isSet = EFalse;

	if( aElement == KFolderElement )

		{

		outer = EFolderNone;

		isSet = iSetValues.iFolder;

		if ( startElement ) iSetValues.iFolder = ETrue;

		}

	else if( aElement == KFolderNameElement )

		{

		inner = EFolderName;

		isSet = iSetValues.iName;

		}

	else if( aElement == KFolderCreatedElement )

		{

		inner = EFolderCreated;

		isSet = iSetValues.iCreated;

		}

	else if( aElement == KFolderModifiedElement )

		{

		inner = EFolderModified;

		isSet = iSetValues.iModified;

		}

	else if( aElement == KFolderAccessedElement )

		{

		inner = EFolderAccessed;

		isSet = iSetValues.iAccessed;

		}

	else if( aElement == KFolderAttributesElement )

		{

		inner = EAttributes;

		isSet = iSetValues.iAttributes;

		if ( startElement) iSetValues.iAttributes = ETrue;

		}

	else if( aElement == KAttributeHiddenElement )

		{

		inner = EAttributesH;

		outer = EAttributes;

		isSet = iSetValues.iAttributesH;

		}

	else if( aElement == KAttributeSystemElement )

		{

		inner = EAttributesS;

		outer = EAttributes;

		isSet = iSetValues.iAttributesS;

		}

	else if( aElement == KAttributeArchivedElement )

		{

		inner = EAttributesA;

		outer = EAttributes;

		isSet = iSetValues.iAttributesA;

		}

	else if( aElement == KAttributeDeleteElement )

		{

		inner = EAttributesD;

		outer = EAttributes;

		isSet = iSetValues.iAttributesD;

		}

	else if( aElement == KAttributeWritableElement )

		{

		inner = EAttributesW;

		outer = EAttributes;

		isSet = iSetValues.iAttributesW;

		}

	else if( aElement == KAttributeReadableElement )

		{

		inner = EAttributesR;

		outer = EAttributes;

		isSet = iSetValues.iAttributesR;

		}

	else if( aElement == KAttributeExecutableElement )

		{

		inner = EAttributesX;

		outer = EAttributes;

		isSet = iSetValues.iAttributesX;

		}

	else if( aElement == KFolderRoleElement )

		{

		inner = EFolderRole;

		isSet = iSetValues.iRole;

		}

	else if( aElement == KExtElement )

		{

		inner = EFolderExt;

		if ( startElement )

			{

			if( iExtData )

				{

				delete iExtData;

				iExtData = NULL;

				}

			iExtData = CNSmlExtData::NewL();

			iSetValues.iXNam = EFalse;

			}

		else

			{

			if( !iSetValues.iXNam ) User::Leave(EMandatoryFieldNotFound); // xnam not set

			iExt->AppendL(iExtData);

			iExtData = NULL;

			}

		}

	else if( aElement == KExtXNamElement )

		{

		inner = EFolderExtXNam;

		outer = EFolderExt;

		isSet = iSetValues.iXNam;

		}

	else if( aElement == KExtXValElement )

		{

		inner = EFolderExtXVal;

		outer = EFolderExt;

		}

	else

		{

		User::Leave(EInvalidXmlError);

		}

	// finally, change state depending on was the element start or end element

	if ( startElement )

		{

		StartElementStateChangeL( outer, inner, isSet );

		}

	else

		{

		EndElementStateChangeL( inner, outer );

		}

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::NextDataL

// Base class' ParseL method calls this method, when a data is read from xml,

// but that data is not element name (data inside or between elements).

// -----------------------------------------------------------------------------

//

void CNSmlFolderParser::NextDataL( TPtrC8 aData )

	{

	switch(iCurrentState)

		{

		case EFolderNone:

		case EFolder:

		case EAttributes:

		case EFolderExt:

			LeaveIfNotWhiteSpaceL( aData );

			break;

		case EFolderName:

			iName = aData.AllocL();

			iSetValues.iName = ETrue;

			break;

		case EFolderCreated:

			iCreated = StringToTTimeL(aData);

			iSetValues.iCreated = ETrue;

			break;

		case EFolderModified:

			iModified = StringToTTimeL(aData);

			iSetValues.iModified = ETrue;

			break;

		case EFolderAccessed:

			iAccessed = StringToTTimeL(aData);

			iSetValues.iAccessed = ETrue;

			break;

		case EAttributesH:

			iAttributes.iHidden = StringToBooleanL(aData);

			iSetValues.iAttributesH = ETrue;

			break;

		case EAttributesS:

			iAttributes.iSystem = StringToBooleanL(aData);

			iSetValues.iAttributesS = ETrue;

			break;

		case EAttributesA:

			iAttributes.iArchived = StringToBooleanL(aData);

			iSetValues.iAttributesA = ETrue;

			break;

		case EAttributesD:

			iAttributes.iDelete = StringToBooleanL(aData);

			iSetValues.iAttributesD = ETrue;

			break;

		case EAttributesW:

			iAttributes.iWritable = StringToBooleanL(aData);

			iSetValues.iAttributesW = ETrue;

			break;

		case EAttributesR:

			iAttributes.iReadable = StringToBooleanL(aData);

			iSetValues.iAttributesR = ETrue;

			break;

		case EAttributesX:

			iAttributes.iExecutable = StringToBooleanL(aData);

			iSetValues.iAttributesX = ETrue;

			break;

		case EFolderRole:

			iRole = aData.AllocL();

			iSetValues.iRole = ETrue;

			break;

		case EFolderExtXNam:

			iExtData->iXNam = aData.AllocL();

			iSetValues.iXNam = ETrue;

			break;

		case EFolderExtXVal:

			iExtData->AddXValL(aData.AllocL());

			break;

		default:

			User::Leave(EUnknownError); // should never happen

			break;

		}

	}

// -----------------------------------------------------------------------------

// CNSmlFolderParser::StartElementStateChangeL

// Checks that the state change (new start element) is legal (right order of 

// elements and element not already set) and changes the state.

// -----------------------------------------------------------------------------

//

void CNSmlFolderParser::StartElementStateChangeL(TNSmlCurrentFolderElement aCurrentState, 

											     TNSmlCurrentFolderElement aNextState, 

											     TBool aIsSet)

	{

	if( aIsSet || iCurrentState != aCurrentState || aNextState < iLastState )

		{

		User::Leave(EInvalidXmlError);

		}

	iLastState = iCurrentState;

	iCurrentState = aNextState;

	}