src/xmlpatterns/expr/qapplytemplate.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include <QtDebug>
  43
  44 #include "qaxisstep_p.h"
  45 #include "qcommonsequencetypes_p.h"
  46 #include "qcommonvalues_p.h"
  47 #include "qitemmappingiterator_p.h"
  48 #include "qsequencemappingiterator_p.h"
  49 #include "qpatternistlocale_p.h"
  50
  51 #include "qapplytemplate_p.h"
  52
  53 QT_BEGIN_NAMESPACE
  54
  55 using namespace QPatternist;
  56
  57 ApplyTemplate::ApplyTemplate(const TemplateMode::Ptr &mode,
  58                              const WithParam::Hash &withParams,
  59                              const TemplateMode::Ptr &defaultMode) : TemplateInvoker(withParams)
  60                                                                    , m_mode(mode)
  61                                                                    , m_defaultMode(defaultMode)
  62 {
  63     Q_ASSERT_X(m_mode || m_defaultMode, Q_FUNC_INFO,
  64                "Either a mode, or the default mode must be supplied.");
  65 }
  66
  67 Item ApplyTemplate::mapToItem(const QXmlNodeModelIndex &node,
  68                               const DynamicContext::Ptr &) const
  69 {
  70     return Item(node);
  71 }
  72
  73 Item::Iterator::Ptr ApplyTemplate::mapToSequence(const Item &item,
  74                                                  const DynamicContext::Ptr &context) const
  75 {
  76     Q_UNUSED(item);
  77     return evaluateSequence(context);
  78 }
  79
  80 TemplateMode::Ptr ApplyTemplate::effectiveMode(const DynamicContext::Ptr &context) const
  81 {
  82     if(m_mode)
  83         return m_mode;
  84     else
  85     {
  86         const TemplateMode::Ptr currentMode(context->currentTemplateMode());
  87
  88         if(currentMode)
  89             return currentMode;
  90         else
  91             return m_defaultMode;
  92     }
  93 }
  94
  95 Template::Ptr ApplyTemplate::findTemplate(const DynamicContext::Ptr &context,
  96                                           const TemplateMode::Ptr &templateMode) const
  97 {
  98     const int count = templateMode->templatePatterns.count();
  99     Template::Ptr result;
 100     /* It's redundant to initialize these values, but it suppresses false
 101      * positives with GCC. */
 102     PatternPriority priority = 0;
 103     TemplatePattern::ID id = -1;
 104
 105     /* Possible optimization: detecting ambiguous rule matches could be forked off to a
 106      * low prioirity thread. */
 107     for(int i = 0; i < count; ++i)
 108     {
 109         const TemplatePattern::Ptr &candidate = templateMode->templatePatterns.at(i);
 110         if(candidate->matchPattern()->evaluateEBV(context))
 111         {
 112             if(result)
 113             {
 114                 if(   candidate->id() != id
 115                    && candidate->priority() == priority
 116                    && candidate->templateTarget()->importPrecedence ==
 117                                                         result->importPrecedence)
 118                 {
 119                     context->error(QtXmlPatterns::tr("Ambiguous rule match."),
 120                                    ReportContext::XTRE0540, this);
 121                 }
 122                 else
 123                     break;
 124             }
 125             else
 126             {
 127                 result = candidate->templateTarget();
 128                 priority = candidate->priority();
 129                 id = candidate->id();
 130             }
 131         }
 132     }
 133
 134     return result;
 135 }
 136
 137 Item::Iterator::Ptr ApplyTemplate::evaluateSequence(const DynamicContext::Ptr &context) const
 138 {
 139     const TemplateMode::Ptr templateMode(effectiveMode(context));
 140     const Template::Ptr &templateMatch = findTemplate(context, templateMode);
 141
 142     if(templateMatch)
 143         return templateMatch->body->evaluateSequence(templateMatch->createContext(this, context, false));
 144     else
 145     {
 146         /* None of our templates matched. Proceed with a built-in. */
 147         const Item current(context->contextItem());
 148         // TODO it can be an atomic value?
 149         const QXmlNodeModelIndex::NodeKind kind(current.asNode().kind());
 150
 151         if(kind == QXmlNodeModelIndex::Element || kind == QXmlNodeModelIndex::Document)
 152         {
 153             pDebug() << "No template match, using builtin template for element() | document-node()";
 154
 155             const Item::Iterator::Ptr focusIterator(makeItemMappingIterator<Item>(ConstPtr(this),
 156                                                                                   current.asNode().iterate(QXmlNodeModelIndex::AxisChild),
 157                                                                                   context));
 158
 159             const DynamicContext::Ptr focus(context->createFocus());
 160             focus->setFocusIterator(focusIterator);
 161             return makeSequenceMappingIterator<Item>(ConstPtr(this), focusIterator, focus);
 162         }
 163         return CommonValues::emptyIterator;
 164     }
 165 }
 166
 167 Expression::Ptr ApplyTemplate::compress(const StaticContext::Ptr &context)
 168 {
 169     /* If we have a mode, we will never need the default mode. */
 170     if(m_mode)
 171         m_defaultMode.reset();
 172
 173     return TemplateInvoker::compress(context);
 174 }
 175
 176 SequenceType::Ptr ApplyTemplate::staticType() const
 177 {
 178     return CommonSequenceTypes::ZeroOrMoreItems;
 179 }
 180
 181 ExpressionVisitorResult::Ptr ApplyTemplate::accept(const ExpressionVisitor::Ptr &visitor) const
 182 {
 183     return visitor->visit(this);
 184 }
 185
 186 Expression::Properties ApplyTemplate::properties() const
 187 {
 188     return RequiresFocus | DisableElimination;
 189 }
 190
 191 bool ApplyTemplate::configureRecursion(const CallTargetDescription::Ptr &sign)
 192 {
 193     Q_ASSERT_X(false, Q_FUNC_INFO, "We're not expected to be called.");
 194     Q_UNUSED(sign);
 195     return false;
 196 }
 197
 198 Expression::Ptr ApplyTemplate::body() const
 199 {
 200     Q_ASSERT_X(false, Q_FUNC_INFO, "We're not expected to be called.");
 201     return Expression::Ptr();
 202 }
 203
 204 CallTargetDescription::Ptr ApplyTemplate::callTargetDescription() const
 205 {
 206     Q_ASSERT_X(false, Q_FUNC_INFO, "We're not expected to be called.");
 207     return CallTargetDescription::Ptr();
 208 }
 209
 210 QT_END_NAMESPACE