/*

* Copyright (c) 2002-2005 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:        Class extends Symbian XML framework parser functionality

*

*/

#ifndef SEN_XMLREADER_H

#define SEN_XMLREADER_H

//  INCLUDES

#include <xml/parser.h>

#include <xml/parserfeature.h> // for TParserFeature enumeration

#include <xml/contenthandler.h>

#include <badesca.h>

using namespace Xml;

// CONSTANTS

const TInt KSenDefaultParserFeature = (TInt)EReportNamespaceMapping;

#ifdef RD_SEN_FORCE_LIBXML_SAX_PLUGIN_MIMETYPE

    _LIT8(KXmlParserMimeType,   "text/wsstarlibxml2");

    _LIT8(KXmlVariant,          "wsstarlibxml2");

#else

    _LIT8(KXmlParserMimeType,   "text/xml");

    _LIT8(KXmlVariant,          "libxml2");  // LibXml2 SAX parser

#endif

// FORWARD DECLARATIONS

class MSenContentHandlerClient;

class RFs;

// CLASS DECLARATION

/**

*  Class extends Symbian XML framework parser functionality

*  Callers of this class must register some handler which will

*  then receive XML callback events from underlying Symbian

*  XML framework.

*  @lib SenXML.dll

*  @since Series60 3.0

*/

class CSenXmlReader : public CBase, public MContentHandler 

    {

    public:  // Constructors and destructor

        /**

        * Standard two-phase constructor.

        * Creates new parser instance using default

        * MIME type "text/xml" (KXmlParserMimeType).

        * @since Series60 3.0

        * @return pointer to a new CSenXmlReader instance.

        */

        IMPORT_C static CSenXmlReader* NewL();

        /**

        * Standard two-phase constructor.

        * Creates new parser instance using default

        * MIME type "text/xml" (KXmlParserMimeType).

        * @since Series60 3.0

        * @return pointer to a new CSenXmlReader instance

        * which is left on cleanup stack.

        */

        IMPORT_C static CSenXmlReader* NewLC();

        /**

        * A constructor with parser feature enabling. Uses default

        * parser MIME type "text/xml" (KXmlParserMimeType).        

        * @since Series60 3.0

        * @param aParserFeature is typically some enumeration introduced 

        *      in Xml::TParserFeature or some other feature introduced in 

        *      some XML parser implementation.

        *  Leave codes:

        *      KErrArgument    if aParserFeature value is negative.

        */ 

        IMPORT_C static CSenXmlReader* NewL(TInt aParserFeature);

        /**

        * A constructor with parser feature enabling. Uses default

        * parser MIME type "text/xml" (KXmlParserMimeType). 

        * @since Series60 3.0

        * @param aParserMimeType is the XML parser MIME type.

        *      If descriptor is of zero-length, then default 

        *      MIME type KXmlParserMimeType is used ("text/xml").

        *      Availability of other MIME types depends on 

        *      underlying parser implementation.

        * @param aParserFeature is typically some enumeration introduced 

        *      in Xml::TParserFeature or some other feature introduced in 

        *      some XML parser implementation.

        *  Leave codes:

        *      KErrArgument    if aParserFeature value is negative.

        */ 

        IMPORT_C static CSenXmlReader* NewLC(TInt aParserFeature);

        /**

        * A constructor with parser MIME type.

        * Standard two-phase constructor.

        * @since Series60 3.0

        * @param aParserMimeType is the XML parser MIME type.

        *      If descriptor is of zero-length, then default 

        *      MIME type KXmlParserMimeType is used ("text/xml").

        *      Availability of other MIME types depends on 

        *      underlying parser implementation.

        * @return pointer to a new CSenXmlReader instance.

        */

        IMPORT_C static CSenXmlReader* NewL(const TDesC8& aParserMimeType);

        /**

        * A constructor with parser MIME type.

        * @since Series60 3.0

        * @param aParserMimeType is the XML parser MIME type.

        *      If descriptor is of zero-length, then default 

        *      MIME type KXmlParserMimeType is used ("text/xml").

        *      Availability of other MIME types depends on 

        *      underlying parser implementation.

        * @return pointer to a new CSenXmlReader instance

        * which is left on cleanup stack.

        */

        IMPORT_C static CSenXmlReader* NewLC(const TDesC8& aParserMimeType);

        /**

        * A constructor with parser MIME type and parser feature enabling.

        * @since Series60 3.0

        * @param aParserFeature is typically some enumeration introduced 

        *      in Xml::TParserFeature or some other feature introduced in 

        *      some XML parser implementation.

        *  Leave codes:

        *      KErrArgument    if aParserFeature value is negative.

        */ 

        IMPORT_C static CSenXmlReader* NewL(const TDesC8& aParserMimeType,

                                            TInt aParserFeature);

        /**

        * A constructor with parser MIME type and parser feature enabling.

        * @since Series60 3.0

        * @param aParserMimeType is the XML parser MIME type.

        *      If descriptor is of zero-length, then default 

        *      MIME type KXmlParserMimeType is used ("text/xml").

        *      Availability of other MIME types depends on 

        *      underlying parser implementation.

        * @param aParserFeature is typically some enumeration introduced 

        *      in Xml::TParserFeature or some other feature introduced in 

        *      some XML parser implementation.

        *  Leave codes:

        *      KErrArgument    if aParserFeature value is negative.

        */ 

        IMPORT_C static CSenXmlReader* NewLC(const TDesC8& aParserMimeType,

                                             TInt aParserFeature);

        /**

        * Destructor.

        */

        IMPORT_C virtual ~CSenXmlReader();

        // New functions

        /**

        * Method to allow client to register a content event handler (for XML) for

        * the current reader.

        * @since Series60 3.0

        * @param aContentHandler The new event handler.

        */

        IMPORT_C virtual void SetContentHandler(

                    MSenContentHandlerClient& aContentHandler);

        /**

        * Method for checking which feature has been enabled in the parser.

        * @since Series60 3.0

        * @return the corresponding integer id of the feature

        */

        IMPORT_C virtual TInt EnabledParserFeature();

        /**

        * @deprecated - use EnabledParserFeature() instead.

        */

        IMPORT_C virtual TInt ParserFeature();

        /**

        * Method for enabling a parser feature.

        * @since Series60 3.0

        * @param aParserFeature is typically some enumeration introduced 

        *           in Xml::TParserFeature or some other feature introduced in 

        *           some XML parser implementation.

        * @return KErrNone or some system-wide error code, if an error has 

        *         occurred.

        */

        TInt SetParserFeature(TInt aParserFeature);     

        /**

        * Parse an XML buffer.

        * @since Series60 3.0

        * @param aBuff Buffer containing document to parse.

        * Note that this method will also leave, if an error

        * is returned from Symbian XML framework. Here are

        * the corresponding enums, and their respective

        * error code values (-1000, -999... and up)

        * (XML-specific errors returned by the XML parser)

        * [from XmlParserErrors.h]

    	* EXmlParserError = -1000,

    	* EXmlSyntax = 2+EXmlParserError,		// -998

    	* EXmlNoElements,						// -997

    	* EXmlInvalidToken,					    // -996

    	* EXmlUnclosedToken,					// -995

    	* EXmlPartialChar,                      // -994

    	* EXmlTagMismatch,                      // -993

    	* EXmlDuplicateAttribute,               // -992

    	* EXmlJunkAfterDocElement,              // -991

    	* EXmlPeRef,                            // -990

    	* EXmlUndefinedEntity,                  // -989

    	* EXmlRecursiveEntity,                  // -988

    	* EXmlAsyncEntity,                      // -987

    	* EXmlBadCharRef,                       // -986

    	* EXmlBinaryEntityRef,                  // -985

    	* EXmlAttributeExternalEntityRef,       // -984

    	* EXmlMisplacedPi,                      // -983

    	* EXmlUnknownEncoding,                  // -982

    	* EXmlIncorrectEncoding,                // -981

    	* EXmlUnclosedCdata,                    // -980

    	* EXmlExternalEntityHandling,           // -979

    	* EXmlNotStandalone,                    // -978

    	* EXmlUnexpectedState,                  // -977

    	* EXmlEntityDeclInPe,                   // -976

    	* EXmlDtdRequired,                      // -975

    	* EXmlFeatureLockedWhileParsing         // -974

        */

        IMPORT_C void ParseL(const TDesC8& aBuff);

        /**

        * Parse an XML document.

        * @since Series60 3.0

        * @param aRFs An open filesession.

        * @param aFileToParse Filename of file to parse.

        */

        IMPORT_C void ParseL(RFs &aRFs, const TDesC& aFileToParse);

        // Functions from base classes 

        // Callback functions implementing Symbian MContentHandler interface

        /**

        * @since Series60 3.0

        *   Leave codes:

        *       KErrSenXmlContentHandlerNotSet  if XML content handler

        *       for this XML reader has not been set. This leave can

        *               be avoided calling SetContentHandlerL() method prior

        *               parsing some XML document.

        */

        virtual void OnStartDocumentL(const RDocumentParameters& aDocParam, 

                                      TInt aErrorCode);

        /**

        * @since Series60 3.0

        *   Leave codes:

        *       KErrSenXmlContentHandlerNotSet  if XML content handler

        *       for this XML reader has not been set. This leave can

        *       be avoided calling SetContentHandlerL() method prior

        *       parsing some XML document.

        */

        virtual void OnEndDocumentL(TInt aErrorCode);

        /**

        * @since Series60 3.0

        *   Leave codes:

        *       KErrSenXmlContentHandlerNotSet  if XML content handler

        *       for this XML reader has not been set. This leave can

        *       be avoided calling SetContentHandlerL() method prior

        *       parsing some XML document.

        */

        virtual void OnStartElementL(const RTagInfo& aElement, 

                                     const RAttributeArray& aAttributes, 

                                     TInt aErrorCode);

        /**

        * @since Series60 3.0

        *   Leave codes:

        *       KErrSenXmlContentHandlerNotSet  if XML content handler

        *       for this XML reader has not been set. This leave can

        *       be avoided calling SetContentHandlerL() method prior

        *       parsing some XML document.

        */

        virtual void OnEndElementL(const RTagInfo& aElement, TInt aErrorCode);

        /**

        * @since Series60 3.0

        * @param aBytes is the actual XML data, content in UTF-8 form

        * @param aErrorCode KErrNone, or some system-wide error code

        *        if an error has occured.

        */

        virtual void OnContentL(const TDesC8& aBytes, TInt aErrorCode);

        /**

        * @since Series60 3.0

        *   Leave codes:

        *       KErrSenXmlContentHandlerNotSet  if XML content handler

        *       for this XML reader has not been set. This leave can

        *       be avoided calling SetContentHandlerL() method prior

        *       parsing some XML document.

        */

        virtual void OnStartPrefixMappingL(const RString& aPrefix, 

                                           const RString& aUri, 

                                           TInt aErrorCode);

        /**

        * @since Series60 3.0

        *   Leave codes:

        *       KErrSenXmlContentHandlerNotSet  if XML content handler

        *       for this XML reader has not been set. This leave can

        *       be avoided calling SetContentHandlerL() method prior

        *       parsing some XML document.

        */

        virtual void OnEndPrefixMappingL(const RString& aPrefix, TInt aErrorCode);

        /**

        * @since Series60 3.0

        *   Leave codes:

        *       KErrSenXmlContentHandlerNotSet  if XML content handler

        *       for this XML reader has not been set. This leave can

        *       be avoided calling SetContentHandlerL() method prior

        *       parsing some XML document.

        */

        virtual void OnIgnorableWhiteSpaceL(const TDesC8& aBytes, TInt aErrorCode);

        /**

        * @since Series60 3.0

        *   Leave codes:

        *       KErrSenXmlContentHandlerNotSet  if XML content handler

        *       for this XML reader has not been set. This leave can

        *       be avoided calling SetContentHandlerL() method prior

        *       parsing some XML document.

        */

        virtual void OnSkippedEntityL(const RString& aName, TInt aErrorCode);

        /**

        * @since Series60 3.0

        *   Leave codes:

        *       KErrSenXmlContentHandlerNotSet  if XML content handler

        *       for this XML reader has not been set. This leave can

        *       be avoided calling SetContentHandlerL() method prior

        *       parsing some XML document.

        */

        virtual void OnProcessingInstructionL(const TDesC8& aTarget, 

                                              const TDesC8& aData, 

                                              TInt aErrorCode);

        /**

        * OnError is a callback method signalled by Symbian XML

        * framework. Current implementation of this class issues

        * a leave in original ParseL() call on any received by

        * this callback implementation. Used leave code will be

        * the received error code.

        *

        * @since Series60 3.0

        * @param aErrorCode is one of the Symbian XML framework

        * errors listed in XmlFrameworkErrors.h

        *

        * Currently any s

        *

        * If content handler was not set, ParseL will leaves with

        * KErrSenXmlContentHandlerNotSet.

        */

        virtual void OnError(TInt aErrorCode);

        /**

        * This method obtains the interface matching the specified UID.

        * @since Series60 3.0

        * @param    aUid    the UID identifying the required interface.

        * @return   NULL    if no interface matching the UID is found or

        *                    if content handler was not set. Otherwise, 

        *                    returns pointer to the interface.

        */

        virtual TAny* GetExtendedInterface(const TInt32 aUid);

    protected:

        /**

        * C++ constructor.

        */

        IMPORT_C CSenXmlReader(TInt aParserFeature);

        /**

        * Symbian 2nd phase constructor.

        * @param aParserMimeType sets the MIME type of 

        * this XML parser.

        */

        void ConstructL(const TDesC8& aParserMimeType);

        // New functions

        /**

        * This method re-initializes encapsulated CParser class instance.

        * @since Series60 3.0

        */

        void RecreateParserL();

    private:

        static void CleanupParser(TAny* apReader);

        void CleanUp();

    private:    // Data

            // Owned instance of Symbian XML framework (default) XML parser

        CParser* iParser;

            // Not owned pointer to XML content handler.

        MSenContentHandlerClient* iContentHandler;

        // Owned pointer to XML namespace prefix strings

        CDesC8Array* ipNsPrefixes;

        // Owned pointer to XML namespace URI strings

        CDesC8Array* ipNsUris;

        // Owned string pool for XML attribute handling.

        RStringPool iStringPool;

            // Integer indicating currently enabled features

        TInt iEnabledFeature;

    };

#endif  // SEN_XMLREADER_H

// End of File