1 /*

     2 * Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Email XML parser

    15 *

    16 */

    17 

    18 

    19 // 1.2 Changes: nsmlxmlparser module added

    20 

    21 

    22 #ifndef __NSMLXMLPARSER_H__

    23 #define __NSMLXMLPARSER_H__

    24 

    25 // ------------------------------------------------------------------------------------------------

    26 // Includes

    27 // ------------------------------------------------------------------------------------------------

    28 #include <e32base.h>

    29 #include <s32strm.h>

    30 #include "nsmlEmailmtmdefs.h"

    31 

    32 

    33 // ------------------------------------------------------------------------------------------------

    34 // Defines for binary size optimization

    35 // ------------------------------------------------------------------------------------------------

    36 #define __NO_XML_COMMENTS_

    37 //#define __NO_EMPTY_ELEMENTS_

    38 

    39 

    40 // ------------------------------------------------------------------------------------------------

    41 // Class forward declarations

    42 // ------------------------------------------------------------------------------------------------

    43 class CNSmlXmlParser;

    44 class CNSmlExtData;

    45 

    46 

    47 // ------------------------------------------------------------------------------------------------

    48 // Typedefs

    49 // ------------------------------------------------------------------------------------------------

    50 // the array used for xval-values

    51 typedef CArrayPtrFlat<HBufC8> CNSmlXValArray;

    52 // the array used for extension data

    53 typedef CArrayPtrFlat<CNSmlExtData> CNSmlExtDataArray;

    54 // the array used for truncate info attachments data

    55 typedef RPointerArray<CNSmlAttachmentTruncateInfo> RNSmlAttachArray;

    56 // the array used for truncate info body data

    57 typedef RPointerArray<CNSmlBodyTruncateInfo> RNSmlBodyArray;

    58 

    59 

    60 // ------------------------------------------------------------------------------------------------

    61 // constants

    62 // ------------------------------------------------------------------------------------------------

    63 

    64 // the maximum length of an integer in characters

    65 const TInt KIntegerMaxLength = 12;

    66 

    67 // the length of a datetime in characters

    68 const TInt KDateTimeLength = 16;

    69 

    70 // the length of element start (<) and end (>)

    71 const TInt KElementStartEndWidth = 2;

    72 

    73 // constants used with files

    74 const TInt KReadDataLength = 512;

    75 const TUint KFileReadAccess	= EFileRead|EFileShareAny;

    76 const TUint KFileWriteAccess = EFileWrite|EFileShareExclusive;

    77 const TInt KMaxEmailItemFileNameLength = 256;

    78 _LIT(KEmailItemFile, "c:\\system\\temp\\emailitem.txt");

    79 _LIT(KEmailItemPath, "c:\\system\\temp\\");

    80 

    81 const TInt KNSmlEmailItemDrive = EDriveC;

    82 

    83 // Whitespace characters

    84 const TText KWhitespaceEmpty = ' ';

    85 const TText KWhitespaceLineFeed = '\r';

    86 const TText KWhitespaceNewLine = '\n';

    87 const TText KWhitespaceTabular = '\t';

    88 const TText KWhitespaceLineFeedNewLine = '\r\n';

    89 

    90 const TText KCharacterSlash = '/';

    91 

    92 // CData

    93 _LIT8(KCDataStart,		"<![CDATA[");

    94 _LIT8(KCDataEnd,		"]]>");

    95 _LIT8(KCDataInnerEnd,	"]]]]>&gt;<![CDATA[");

    96 

    97 #ifndef __NO_XML_COMMENTS_

    98 // Xml comments

    99 _LIT8(KCommentStart,	"<!--");

   100 _LIT8(KCommentEnd,		"-->");

   101 #endif

   102 

   103 const TText KElementStart = '<';

   104 const TText KElementEnd = '>';

   105 

   106 // Xml entities

   107 _LIT8(KEntityLT,	"<");

   108 _LIT8(KEntityGT,	">");

   109 _LIT8(KEntityAMP,	"&");

   110 _LIT8(KEntityAPOS,	"'");

   111 _LIT8(KEntityQUOT,	""");

   112 

   113 // special characters

   114 _LIT8(KLessThan,	"<");

   115 _LIT8(KGreaterThan,	">");

   116 _LIT8(KAmpersand,	"&");

   117 _LIT8(KApostrophe,	"\'");

   118 _LIT8(KQuotation,	"\"");

   119 

   120 // boolean string representations

   121 _LIT8(KStringTrue,	"true");

   122 _LIT8(KStringFalse,	"false");

   123 

   124 // empty string

   125 _LIT8(KStringEmpty,	"");

   126 

   127 // email spesific elements

   128 _LIT8(KEmailElement,			"Email");

   129 _LIT8(KEmailReadElement,		"read");

   130 _LIT8(KEmailForwardedElement,	"forwarded");

   131 _LIT8(KEmailRepliedElement,		"replied");

   132 _LIT8(KEmailReceivedElement,	"received");

   133 _LIT8(KEmailCreatedElement,		"created");

   134 _LIT8(KEmailModifiedElement,	"modified");

   135 _LIT8(KEmailDeletedElement,		"deleted");

   136 _LIT8(KEmailFlaggedElement,		"flagged");

   137 _LIT8(KEmailItemElement,		"emailitem");

   138 

   139 // truncated info spesific elements

   140 _LIT8(KTruncatedElement,		"truncated");

   141 _LIT8(KTruncatedBodyElement,	"body");

   142 _LIT8(KTruncatedAttachElement,	"attach");

   143 _LIT8(KTruncatedSizeElement,	"size");

   144 _LIT8(KTruncatedTypeElement,	"type");

   145 _LIT8(KTruncatedNameElement,	"name");

   146 

   147 // extension spesific elements

   148 _LIT8(KExtElement,		"Ext");

   149 _LIT8(KExtXNamElement,	"XNam");

   150 _LIT8(KExtXValElement,	"XVal");

   151 

   152 // folder spesific elements

   153 _LIT8(KFolderElement,			"Folder");

   154 _LIT8(KFolderNameElement,		"name");

   155 _LIT8(KFolderCreatedElement,	"created");

   156 _LIT8(KFolderModifiedElement,	"modified");

   157 _LIT8(KFolderAccessedElement,	"accessed");

   158 _LIT8(KFolderAttributesElement,	"attributes");

   159 _LIT8(KFolderRoleElement,		"role");

   160 

   161 // folder attributes

   162 _LIT8(KAttributeHiddenElement,		"h");

   163 _LIT8(KAttributeSystemElement,		"s");

   164 _LIT8(KAttributeArchivedElement,	"a");

   165 _LIT8(KAttributeDeleteElement,		"d");

   166 _LIT8(KAttributeWritableElement,	"w");

   167 _LIT8(KAttributeReadableElement,	"r");

   168 _LIT8(KAttributeExecutableElement,	"x");

   169 

   170 

   171 // The error values returned from parser and generator functions

   172 enum TNSmlParserGeneratorError

   173 	{

   174 	EErrorNone,				// no error

   175 	EOutOfMemory,			// out of memory

   176 	EMandatoryFieldNotFound,// XNam inside Ext missing

   177 	EInvalidBooleanValue,	// Invalid value inside boolean elements

   178 	EInvalidIntegerValue,	// Invalid value inside integer elements

   179 	EInvalidDatetimeValue,	// Invalid value inside datetime elements

   180 	EInvalidCDataStructure,	// CDATA error

   181 	EInvalidXmlError, 		// Xml includes invalid data, i.e. xml generally against dtd

   182 	EInvalidFilename,		// file was not found or the filename was otherwise erroneous

   183 	EUnknownError			// Unknown error

   184 	};

   185 

   186 

   187 // enumeration for boolean values

   188 enum TNSmlBoolean

   189 	{

   190 	EBooleanMissing = 0, // not included in the xml

   191 	EBooleanTrue,

   192 	EBooleanFalse

   193 	};

   194 

   195 

   196 // extension data (found in both email and folder)

   197 class CNSmlExtData : public CBase

   198 	{

   199 public:

   200 	IMPORT_C static CNSmlExtData* NewL();

   201 	IMPORT_C static CNSmlExtData* NewLC();

   202 	IMPORT_C virtual ~CNSmlExtData();

   203 

   204 	IMPORT_C void AddXValL( HBufC8* aXVal );

   205 

   206 	IMPORT_C void GenerateXmlL( TPtr8& aXml, const CNSmlXmlParser* aParser ) const;

   207 	IMPORT_C TInt CountXmlSize( const CNSmlXmlParser* aParser ) const;

   208 	IMPORT_C void ConvertIntoEntitiesL( const CNSmlXmlParser* aParser );

   209 

   210 private:

   211 	CNSmlExtData();

   212 	void ConstructL();

   213 

   214 public:

   215 	HBufC8* iXNam;

   216 	CNSmlXValArray* iXVals;

   217 	};

   218 

   219 

   220 // folder attributes

   221 struct TNSmlFolderAttributeData

   222 	{

   223 	IMPORT_C TNSmlFolderAttributeData();

   224 

   225 	/*

   226 	* Returns the count of attributes that are not EBooleanMissing.

   227 	*/

   228 	IMPORT_C TInt AttributeCount() const;

   229 

   230 	IMPORT_C void GenerateXml( TPtr8& aXml, const CNSmlXmlParser* aParser ) const;

   231 	IMPORT_C TInt CountXmlSize( const CNSmlXmlParser* aParser ) const;

   232 

   233 	TNSmlBoolean iHidden;

   234 	TNSmlBoolean iSystem;

   235 	TNSmlBoolean iArchived;

   236 	TNSmlBoolean iDelete;

   237 	TNSmlBoolean iWritable;

   238 	TNSmlBoolean iReadable;

   239 	TNSmlBoolean iExecutable;

   240 	};

   241 

   242 

   243 // truncate info data

   244 class CNSmlTruncatedData : public CBase

   245 	{

   246 public:

   247 	IMPORT_C static CNSmlTruncatedData* NewL();

   248 	IMPORT_C static CNSmlTruncatedData* NewLC();

   249 	IMPORT_C virtual ~CNSmlTruncatedData();

   250 

   251 	IMPORT_C void AddAttachmentL(HBufC8* aName, TInt aSize, HBufC8* aType);

   252 	IMPORT_C void AddBodyL(TInt aSize, HBufC8* aType);

   253 

   254 	IMPORT_C void GenerateXmlL( TPtr8& aXml, const CNSmlXmlParser* aParser ) const;

   255 	IMPORT_C TInt CountXmlSizeL( const CNSmlXmlParser* aParser ) const;

   256 	IMPORT_C void ConvertIntoEntitiesL( const CNSmlXmlParser* aParser );

   257 

   258 private:

   259 	CNSmlTruncatedData();

   260 	void ConstructL();

   261 

   262 public:

   263 	RNSmlBodyArray iBodys;

   264 	RNSmlAttachArray iAttachments;

   265 	};

   266 

   267 

   268 // Base class for actual parsergenerators. 

   269 // Implements basic utilities for parsing and generating the xml.

   270 class CNSmlXmlParser : public CBase  

   271 	{

   272 public:

   273 	/*

   274 	* The constructor.

   275 	*/

   276 	IMPORT_C CNSmlXmlParser();

   277 

   278 	/*

   279 	* The destructor.

   280 	*/

   281 	IMPORT_C virtual ~CNSmlXmlParser();

   282 

   283 	/*

   284 	* Parses through the given xml and places the data it contains to 

   285 	* member variables.	Removes all the comments from the original string.

   286 	* @param aXml The xml to be parsed.

   287 	* @return 

   288 	*/

   289 	virtual TNSmlParserGeneratorError ParseXml( HBufC8* aXml ) =0;

   290 

   291 	/*

   292 	* Generates xml using the data in member variables of the child class. 

   293 	* aXml contains the generated xml when method returns successfully. 

   294 	* Caller should not instantiate 

   295 	* the buffer, since this method counts the size of the xml and 

   296 	* instantiates the buffer using the size as its maximum size.

   297 	* Caller gets the control of the buffer when method returns.

   298 	* @param aXml A pointer to a buffer, which is instantiated in this 

   299 	* method and contains the xml when method returns succesfully.

   300 	* @return 

   301 	*/

   302 	virtual TNSmlParserGeneratorError GenerateXml( HBufC8*& aXml ) =0;

   303 

   304 	/*

   305 	* Counts the size of the generated xml, when the xml would be generated 

   306 	* using the data in child class' member variables.

   307 	*/

   308 	virtual TInt CountXmlSizeL() =0;

   309 

   310 	/* utility functions */

   311 

   312 	void PreProcessL( HBufC8* aXml ) const;

   313 

   314 	TPtrC8 BooleanToString( const TNSmlBoolean aValue ) const;

   315 	TBuf8<KDateTimeLength> DateTimeToStringL( const TTime& aValue ) const;

   316 	TBuf8<KIntegerMaxLength> IntegerToString( const TInt aValue ) const;

   317 

   318 	TNSmlBoolean StringToBooleanL( const TPtrC8& aValue ) const;

   319 	TInt StringToIntegerL( const TPtrC8& aValue ) const;

   320 	// Note: Ignores UTC-times (Z-ending) and treats them as local time!

   321 	TTime StringToTTimeL( TPtrC8& aValue ) const;

   322 

   323 	void AppendElement( TPtr8& aPtr, const TDesC8& aElementName, const TDesC8& aValue ) const;

   324 	void AppendElement( TPtr8& aPtr, const TDesC8& aElementName ) const;

   325 	void AppendEndElement( TPtr8& aPtr, const TDesC8& aElementName ) const;

   326 

   327 	TInt SizeOfElements( const TDesC8& aElementName ) const;

   328 	TInt SizeOfBoolean( const TNSmlBoolean aValue, const TDesC8& aElementName ) const;

   329 	TInt SizeOfDatetime( const TDesC8& aElementName ) const;

   330 	TInt SizeOfInteger( const TDesC8& aElementName ) const;

   331 	TInt SizeOfString( const HBufC8* aValue, const TDesC8& aElementName ) const;

   332 

   333 	TInt EntitiesToCharactersL( HBufC8*& aXml, TInt aStartPos, TInt aEndPos ) const;

   334 	TInt CharactersToEntitiesL( HBufC8*& aXml, TInt aStartPos, TInt aEndPos ) const;

   335 

   336 	TBool IsWhitespace( const TDesC8& aText ) const;

   337 	void LeaveIfNotWhiteSpaceL( const TDesC8& aText ) const;

   338 

   339 	TNSmlParserGeneratorError CheckError( const TInt error ) const;

   340 

   341 protected:

   342 	// parsing methods

   343 	void ParseL( TPtrC8& aXml );

   344 	void AddToCompleteL( const TPtrC8 aStr );

   345 	void ResetBufferL( HBufC8*& aBuf ) const;

   346 	void AddToBufferL( const TText c, HBufC8*& aBuf ) const;

   347 

   348 	virtual void NextElementL( TPtrC8 aElement ) =0;

   349 	virtual void NextDataL( TPtrC8 aData ) =0;

   350 

   351 private:

   352 	TInt ReplaceL( HBufC8*& aText, const TDesC8& aTarget, const TDesC8& aItem, TInt aStartPos, TInt aEndPos ) const;

   353 	void CheckDatetimeErrorL( const TInt error ) const;

   354 

   355 protected:

   356 	HBufC8* iBuffer;

   357 	HBufC8* iCompleteBuffer;

   358 	};

   359 

   360 

   361 

   362 // Email parser. Implements the parsing and generating of Email xml.

   363 class CNSmlEmailParser : public CNSmlXmlParser

   364 	{

   365 public:

   366 	IMPORT_C static CNSmlEmailParser* NewL();

   367 	IMPORT_C static CNSmlEmailParser* NewLC();

   368 	IMPORT_C virtual ~CNSmlEmailParser();

   369 

   370 	IMPORT_C virtual TNSmlParserGeneratorError ParseXml( HBufC8* aXml );

   371 	IMPORT_C virtual TNSmlParserGeneratorError GenerateXml( HBufC8*& aXml );

   372 	IMPORT_C virtual TInt CountXmlSizeL();

   373 

   374 	IMPORT_C void AddExtL( CNSmlExtData* aExt );

   375 

   376 protected:

   377 	virtual void NextElementL( TPtrC8 aElement );

   378 	virtual void NextDataL( TPtrC8 aData );

   379 

   380 	virtual void HandleNextEmailItemDataL( TPtrC8 aData );

   381 	virtual void HandleNextEmailItemStartL() {}; // nothing to do

   382 	virtual void HandleNextEmailItemEndL() {}; // nothing to do

   383 

   384 	void ConvertIntoEntitiesL();

   385 

   386 	CNSmlEmailParser();

   387 	void ConstructL();

   388 

   389 protected:

   390 	

   391 	// the email elements (states) in the order they appear in DTD

   392 	enum TNSmlCurrentEmailElement

   393 		{

   394 		ENone = 0,

   395 		EEmail,

   396 		ERead, 

   397 		EForwarded,

   398 		EReplied,

   399 		EReceived,

   400 		ECreated,

   401 		EModified,

   402 		EDeleted,

   403 		EFlagged,

   404 		EEmailItem,

   405 		ETrunc,

   406 		ETruncBody,

   407 		ETruncBodySize,

   408 		ETruncBodyType,

   409 		ETruncAttach,

   410 		ETruncAttachName,

   411 		ETruncAttachSize,

   412 		ETruncAttachType, 

   413 		EExt,

   414 		EExtXNam,

   415 		EExtXVal

   416 		};

   417 	

   418 	// struct used in email parsing to know which members are already set

   419 	struct TNSmlSetEmailValues

   420 		{

   421 		TNSmlSetEmailValues();

   422 		void Reset();

   423 		

   424 		TBool iEmail;

   425 		TBool iRead;

   426 		TBool iForwarded;

   427 		TBool iReplied;

   428 		TBool iDeleted;

   429 		TBool iFlagged;

   430 		TBool iReceived;

   431 		TBool iCreated;

   432 		TBool iModified;

   433 		TBool iEmailItem;

   434 		TBool iTrunc;

   435 		TBool iTruncBodySize;

   436 		TBool iTruncBodyType;

   437 		TBool iTruncAttachSize;

   438 		TBool iTruncAttachType;

   439 		TBool iTruncAttachName;

   440 		TBool iXNam;

   441 		};

   442 	

   443 private:

   444 	void StartElementStateChangeL( TNSmlCurrentEmailElement aCurrentState, TNSmlCurrentEmailElement aNextState, TBool aIsSet = EFalse );

   445 	void EndElementStateChangeL( TNSmlCurrentEmailElement aCurrentState, TNSmlCurrentEmailElement aNextState );

   446 	

   447 	void GenerateEmailXmlL( HBufC8*& aXml );

   448 

   449 public:

   450 

   451 	/*

   452 	* The values of the data below is treated as follows:

   453 	* When constructing this data from an xml, boolean values 

   454 	* are EBooleanTrue, when <field>true</field>, EBooleanFalse 

   455 	* when <field>false</field> OR <field/>, and EBooleanMissing 

   456 	* when the field is not present in the xml. Datetime values 

   457 	* are equal to Time::NullTTime when the field is missing (they should 

   458 	* never be empty). Text values (HBufC8*) are NULL when the field is 

   459 	* missing, an empty string when <field></field> OR <field/> and the 

   460 	* actual value between elements if there is data between those 

   461 	* elements. iExt is never NULL, but when iExt->Count() 

   462 	* equals to zero, there are no extensions present in the xml.

   463 	*

   464 	* These same rules are used when generating xml from 

   465 	* this data object.

   466 	*/

   467 

   468 	TNSmlBoolean iRead;

   469 	TNSmlBoolean iForwarded;

   470 	TNSmlBoolean iReplied;

   471 	TTime iReceived;

   472 	TTime iCreated;

   473 	TTime iModified;

   474 	HBufC8* iEmailItem;

   475 	TNSmlBoolean iDeleted;

   476 	TNSmlBoolean iFlagged;

   477 	CNSmlTruncatedData* iTruncated;

   478 	CNSmlExtDataArray* iExt;

   479 

   480 protected:

   481 	TNSmlSetEmailValues iSetValues;

   482 	TNSmlCurrentEmailElement iCurrentState;

   483 	TNSmlCurrentEmailElement iLastState;

   484 

   485 private:

   486 

   487 	TInt iTruncSize;

   488 	HBufC8* iTruncType;

   489 	HBufC8* iTruncName;

   490 	CNSmlExtData* iExtData;

   491 	};

   492 

   493 

   494 

   495 // ------------------------------------------------------------------------------------------------

   496 // Parses and generates the xml using files/streams. If emailitem is present, it is 

   497 // stored in a file.

   498 // ------------------------------------------------------------------------------------------------

   499 class CNSmlEmailFileParser : public CNSmlEmailParser

   500 	{

   501 public:

   502 	IMPORT_C static CNSmlEmailFileParser* NewL();

   503 	IMPORT_C static CNSmlEmailFileParser* NewLC();

   504 	IMPORT_C virtual ~CNSmlEmailFileParser();

   505 

   506 	IMPORT_C virtual TNSmlParserGeneratorError ParseXml( HBufC8* aXml );

   507 	IMPORT_C virtual TNSmlParserGeneratorError ParseXml( RReadStream& aRs );

   508 	IMPORT_C virtual TNSmlParserGeneratorError GenerateXml( HBufC8*& aXml );

   509 	IMPORT_C virtual TNSmlParserGeneratorError GenerateXml( RWriteStream& aWs );

   510 	IMPORT_C virtual TInt CountXmlSizeL();

   511 

   512 protected:

   513 	virtual void HandleNextEmailItemDataL( TPtrC8 aData );

   514 	virtual void HandleNextEmailItemStartL();

   515 	virtual void HandleNextEmailItemEndL();

   516 

   517 private:

   518 	void ParseFromStreamL( RReadStream& rs );

   519 	void ParsePieceL( TPtrC8& aXml, TBool aLastPiece = EFalse );

   520 	TUint RemoveIncompleteL( HBufC8* aPiece, RReadStream& aStream );

   521 	TUint CheckPiece( const TPtrC8 aEnd ) const;

   522 	void PreProcessPieceL( HBufC8* aXml );

   523 

   524 	void GenerateEmailXmlL( RWriteStream& aWs );

   525 

   526 	void ResetParserL();

   527 	void ResetPreProcessor();

   528 

   529 	HBufC* Buf8ToBuf16( const HBufC8* buf8 ) const;

   530 

   531 	CNSmlEmailFileParser();

   532 	void ConstructL();

   533 

   534 public:

   535 

   536 	TBool iUseEmailItem; // whether or not emailitem should be used in generation

   537 

   538 private:

   539 

   540 	// xml parsing state

   541 	TBool iReadingElementName;

   542 	TBool iReadingCData;

   543 #ifndef __NO_XML_COMMENTS_

   544 	TBool iReadingComment;

   545 #endif

   546 	TBool iReadingEmailItemData;

   547 

   548 	// pre-processing state

   549 	TInt iCdataStartPos;

   550 	TInt iCdataEndPos;

   551 

   552 	// file handling

   553 	RFs iRfs;

   554 	RFileWriteStream iWriteStream;

   555 	

   556 	HBufC* iEmailItemFile;

   557 	TBool iFirstPiece;

   558 	TBool iCdataFoundFromFirstPiece;

   559 	};

   560 

   561 

   562 

   563 

   564 // Folder parser. Implements parsing and generating of Folder xml.

   565 class CNSmlFolderParser : public CNSmlXmlParser

   566 	{

   567 public:

   568 	IMPORT_C static CNSmlFolderParser* NewL();

   569 	IMPORT_C static CNSmlFolderParser* NewLC();

   570 	IMPORT_C virtual ~CNSmlFolderParser();

   571 

   572 	IMPORT_C virtual TNSmlParserGeneratorError ParseXml( HBufC8* aXml );

   573 	IMPORT_C virtual TNSmlParserGeneratorError GenerateXml( HBufC8*& aXml );

   574 	IMPORT_C virtual TInt CountXmlSizeL() ;

   575 

   576 	IMPORT_C void AddExtL( CNSmlExtData* aExt );

   577 

   578 protected:

   579 	virtual void NextElementL( TPtrC8 aElement );

   580 	virtual void NextDataL( TPtrC8 aData );

   581 

   582 protected:

   583 	

   584 	// the folder elements (states) in the order they appear in DTD

   585 	enum TNSmlCurrentFolderElement

   586 		{

   587 		EFolderNone = 0,

   588 		EFolder,

   589 		EFolderName, 

   590 		EFolderCreated,

   591 		EFolderModified,

   592 		EFolderAccessed,

   593 		EAttributes,

   594 		EAttributesH,

   595 		EAttributesS,

   596 		EAttributesA,

   597 		EAttributesD,

   598 		EAttributesW,

   599 		EAttributesR,

   600 		EAttributesX,

   601 		EFolderRole,

   602 		EFolderExt,

   603 		EFolderExtXNam,

   604 		EFolderExtXVal

   605 		};

   606 	

   607 	// struct used in folder parsing (which members are already set)

   608 	struct TNSmlSetFolderValues

   609 		{

   610 		TNSmlSetFolderValues();

   611 		void Reset();

   612 		

   613 		TBool iFolder;

   614 		TBool iName;

   615 		TBool iCreated;

   616 		TBool iModified;

   617 		TBool iAccessed;

   618 		TBool iAttributes;

   619 		TBool iAttributesH;

   620 		TBool iAttributesS;

   621 		TBool iAttributesA;

   622 		TBool iAttributesD;

   623 		TBool iAttributesW;

   624 		TBool iAttributesR;

   625 		TBool iAttributesX;

   626 		TBool iRole;

   627 		TBool iXNam;

   628 		};

   629 	

   630 private:

   631 	void StartElementStateChangeL( TNSmlCurrentFolderElement aCurrentState, TNSmlCurrentFolderElement aNextState, TBool aIsSet = EFalse );

   632 	void EndElementStateChangeL( TNSmlCurrentFolderElement aCurrentState, TNSmlCurrentFolderElement aNextState );

   633 

   634 	void GenerateFolderXmlL( HBufC8*& aXml );

   635 	void ConvertIntoEntitiesL();

   636 

   637 	CNSmlFolderParser();

   638 	void ConstructL();

   639 

   640 public:

   641 	HBufC8* iName;

   642 	TTime iCreated;

   643 	TTime iModified;

   644 	TTime iAccessed;

   645 	TNSmlFolderAttributeData iAttributes;

   646 	HBufC8* iRole;

   647 	CNSmlExtDataArray* iExt;

   648 

   649 private:

   650 	TNSmlCurrentFolderElement iCurrentState;

   651 	TNSmlCurrentFolderElement iLastState;

   652 	TNSmlSetFolderValues iSetValues;

   653 

   654 	CNSmlExtData* iExtData;

   655 	};

   656 

   657 

   658 

   659 #endif // __NSMLXMLPARSER_H__