src/xmlpatterns/parser/qmaintainingreader_p.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 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 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  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