1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 //

    43 //  W A R N I N G

    44 //  -------------

    45 //

    46 // This file is not part of the Qt API.  It exists purely as an

    47 // implementation detail.  This header file may change from version to

    48 // version without notice, or even be removed.

    49 //

    50 // We mean it.

    51 

    52 #ifndef Patternist_MaintainingReader_H

    53 #define Patternist_MaintainingReader_H

    54 

    55 #include <QSet>

    56 #include <QSourceLocation>

    57 #include <QStack>

    58 #include <QStringList>

    59 #include <QXmlStreamReader>

    60 

    61 #include "qxpathhelper_p.h"

    62 #include "qxslttokenlookup_p.h"

    63 

    64 class QUrl;

    65 

    66 QT_BEGIN_HEADER

    67 QT_BEGIN_NAMESPACE

    68 

    69 namespace QPatternist

    70 {

    71     /**

    72      * @short A structure that lists the optional and required

    73      * attributes of an element. Used with MaintainingReader.

    74      *

    75      * A constant source to misunderstandings is mixing up the order of

    76      * arguments for functions that takes a local name and a namespace. Be wary

    77      * of this.

    78      *

    79      * @author Frans Englich <frans.englich@nokia.com>

    80      * @since 4.5

    81      */

    82     template<typename TokenLookupClass,

    83              typename LookupKey = typename TokenLookupClass::NodeName>

    84     class ElementDescription

    85     {

    86     public:

    87         typedef QHash<LookupKey, ElementDescription<TokenLookupClass, LookupKey> > Hash;

    88         QSet<typename TokenLookupClass::NodeName> requiredAttributes;

    89         QSet<typename TokenLookupClass::NodeName> optionalAttributes;

    90     };

    91 

    92     /**

    93      * @short Base class for tokenizers that reads XML formats. This is

    94      * XSLTTokenizer, and the W3C XML Schema parser.

    95      *

    96      * MaintainingReader is intended for sub-classing.

    97      *

    98      * @tparam TokenLookupClass The name of the class that is generated by

    99      * QTokenAutomaton and which supplies tokenizing tokens. For XSLTTokenizer,

   100      * this is XSLTTokenLookup, for instance.

   101      *

   102      * @tparam LookupKey The type that is passed to validateElement() and is

   103      * the key in ElementDescription. For the schema code, where elements have

   104      * different interpretations depending on context, the lookup key is hence

   105      * not equal element name.

   106      *

   107      * @author Frans Englich <frans.englich@nokia.com>

   108      * @since 4.5

   109      */

   110     template<typename TokenLookupClass,

   111              typename LookupKey = typename TokenLookupClass::NodeName>

   112     class MaintainingReader : public QXmlStreamReader

   113                             , protected TokenLookupClass

   114     {

   115     protected:

   116 

   117         MaintainingReader(const typename ElementDescription<TokenLookupClass, LookupKey>::Hash &elementDescriptions,

   118                           const QSet<typename TokenLookupClass::NodeName> &standardAttributes,

   119                           const ReportContext::Ptr &context,

   120                           QIODevice *const queryDevice);

   121 

   122         virtual ~MaintainingReader();

   123 

   124         TokenType readNext();

   125 

   126         /**

   127          * Returns the name of the current element.

   128          */

   129         inline typename TokenLookupClass::NodeName currentElementName() const;

   130 

   131         /**

   132          * @short Convenience function for calling ReportContext::error().

   133          */

   134         void error(const QString &message,

   135                    const ReportContext::ErrorCode code) const;

   136 

   137         /**

   138          * @short Convenience function for calling ReportContext::warning().

   139          */

   140         void warning(const QString &message) const;

   141 

   142         /**

   143          * @short Returns the location of the document that MaintainingReader

   144          * is parsing. Used for error reporting

   145          */

   146         virtual QUrl documentURI() const = 0;

   147 

   148         /**

   149          * @short Returns @c true, if any attribute is allowed on the

   150          * element currently being validated.

   151          */

   152         virtual bool isAnyAttributeAllowed() const = 0;

   153 

   154         /**

   155          * QXmlStreamReader::isWhitespace() returns true for whitespace that is

   156          * not expressed as character references, while XSL-T operatates ontop

   157          * of the XDM, which means we needs to return true for those too.

   158          *

   159          * @see <a href="http://www.w3.org/TR/xslt20/#data-model">4 Data Model</a>

   160          */

   161         bool isWhitespace() const;

   162 

   163         /**

   164          * This function is not merged with handleStandardAttributes() because

   165          * handleStandardAttributes() needs to be called for all elements,

   166          * while validateElement() only applies to XSL-T elements.

   167          *

   168          * @see handleStandardAttributes()

   169          */

   170         void validateElement(const LookupKey name) const;

   171 

   172         QXmlStreamAttributes                                                    m_currentAttributes;

   173 

   174         bool                                                                    m_hasHandledStandardAttributes;

   175 

   176         /**

   177          * This stack mirrors the depth of elements in the parsed document. If

   178          * no @c xml:space is present on the current element, MaintainingReader

   179          * simply pushes the current top(). However, it never sets the value

   180          * depending on @c xml:space's value.

   181          */

   182         QStack<bool>                                                            m_stripWhitespace;

   183 

   184         /**

   185          * @short Returns the value for attribute by name \a name.

   186          *

   187          * If it doesn't exist, an error is raised.

   188          *

   189          * It is assumed that m_reader's current state is

   190          * QXmlStreamReader::StartElement.

   191          */

   192         QString readAttribute(const QString &localName,

   193                               const QString &namespaceURI = QString()) const;

   194 

   195         /**

   196          * @short Returns @c true if the current element has an attribute whose

   197          * name is @p namespaceURI and local name is @p localName.

   198          */

   199         bool hasAttribute(const QString &namespaceURI, const QString &localName) const;

   200 

   201         /**

   202          * @short Returns @c true if the current element has an attribute whose

   203          * local name is @p localName and namespace URI is null.

   204          */

   205         inline bool hasAttribute(const QString &localName) const;

   206 

   207     private:

   208         typename TokenLookupClass::NodeName                                     m_currentElementName;

   209 

   210         /**

   211          * This member is private, see the error() and warning() functions in

   212          * this class.

   213          */

   214         const ReportContext::Ptr                                                m_context;

   215 

   216         /**

   217          * Returns the current location that QXmlStreamReader has.

   218          */

   219         inline QSourceLocation currentLocation() const;

   220 

   221         const typename ElementDescription<TokenLookupClass, LookupKey>::Hash    m_elementDescriptions;

   222         const QSet<typename TokenLookupClass::NodeName>                         m_standardAttributes;

   223         Q_DISABLE_COPY(MaintainingReader)

   224     };

   225 

   226 #include "qmaintainingreader.cpp"

   227 

   228 }

   229 

   230 QT_END_NAMESPACE

   231 QT_END_HEADER

   232 

   233 #endif

   234