src/xmlpatterns/expr/qnodecomparison.cpp

   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 ** 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 #include "qcommonsequencetypes_p.h"
  43 #include "qcommonvalues_p.h"
  44 #include "qemptysequence_p.h"
  45 #include "qinteger_p.h"
  46 #include "qschemanumeric_p.h"
  47 #include "qrangeiterator_p.h"
  48
  49 #include "qnodecomparison_p.h"
  50
  51 QT_BEGIN_NAMESPACE
  52
  53 using namespace QPatternist;
  54
  55 NodeComparison::NodeComparison(const Expression::Ptr &operand1,
  56                                const QXmlNodeModelIndex::DocumentOrder op,
  57                                const Expression::Ptr &operand2)
  58                                : PairContainer(operand1, operand2)
  59                                , m_op(op)
  60 {
  61     Q_ASSERT(op == QXmlNodeModelIndex::Precedes   ||
  62              op == QXmlNodeModelIndex::Follows    ||
  63              op == QXmlNodeModelIndex::Is);
  64 }
  65
  66 Item NodeComparison::evaluateSingleton(const DynamicContext::Ptr &context) const
  67 {
  68     switch(evaluate(context))
  69     {
  70         case True:
  71             return CommonValues::BooleanTrue;
  72         case False:
  73             return CommonValues::BooleanFalse;
  74         default:
  75             return Item();
  76     }
  77 }
  78
  79 bool NodeComparison::evaluateEBV(const DynamicContext::Ptr &context) const
  80 {
  81     switch(evaluate(context))
  82     {
  83         case True:
  84             return true;
  85         default:
  86             /* We include the empty sequence here. */
  87             return false;
  88     }
  89 }
  90
  91 NodeComparison::Result NodeComparison::evaluate(const DynamicContext::Ptr &context) const
  92 {
  93     const Item op1(m_operand1->evaluateSingleton(context));
  94     if(!op1)
  95         return Empty;
  96
  97     const Item op2(m_operand2->evaluateSingleton(context));
  98     if(!op2)
  99         return Empty;
 100
 101     /* We just returns an arbitrary value, since there's no order defined for nodes from different
 102      * models, except for that the return value must be stable. */
 103     if(op1.asNode().model() != op2.asNode().model())
 104         return False;
 105
 106     switch(m_op)
 107     {
 108         case QXmlNodeModelIndex::Is:
 109             return op1.asNode().is(op2.asNode()) ? True : False;
 110         case QXmlNodeModelIndex::Precedes:
 111             return op1.asNode().compareOrder(op2.asNode()) == QXmlNodeModelIndex::Precedes ? True : False;
 112         default:
 113         {
 114             Q_ASSERT(m_op == QXmlNodeModelIndex::Follows);
 115             return op1.asNode().compareOrder(op2.asNode()) == QXmlNodeModelIndex::Follows ? True : False;
 116         }
 117     }
 118 }
 119
 120
 121 SequenceType::List NodeComparison::expectedOperandTypes() const
 122 {
 123     SequenceType::List result;
 124     result.append(CommonSequenceTypes::ZeroOrOneNode);
 125     result.append(CommonSequenceTypes::ZeroOrOneNode);
 126     return result;
 127 }
 128
 129 Expression::Ptr NodeComparison::compress(const StaticContext::Ptr &context)
 130 {
 131     const Expression::Ptr me(PairContainer::compress(context));
 132
 133     if(me != this)
 134     /* We're already rewritten. */
 135         return me;
 136
 137     if(m_operand1->staticType()->cardinality().isEmpty() ||
 138        m_operand2->staticType()->cardinality().isEmpty())
 139     {
 140         // TODO issue a warning in the @p context saying that one of the operands
 141         // were empty, and that the expression always result in the empty sequence
 142         // (which never is the intent, right?).
 143         return EmptySequence::create(this, context);
 144     }
 145
 146     return Expression::Ptr(this);
 147 }
 148
 149 QString NodeComparison::displayName(const QXmlNodeModelIndex::DocumentOrder op)
 150 {
 151     switch(op)
 152     {
 153         case QXmlNodeModelIndex::Is:
 154             return QLatin1String("is");
 155         case QXmlNodeModelIndex::Precedes:
 156             return QLatin1String("<<");
 157         default:
 158         {
 159             Q_ASSERT(op == QXmlNodeModelIndex::Follows);
 160             return QLatin1String(">>");
 161         }
 162     }
 163 }
 164
 165 SequenceType::Ptr NodeComparison::staticType() const
 166 {
 167     if(m_operand1->staticType()->cardinality().allowsEmpty() ||
 168        m_operand2->staticType()->cardinality().allowsEmpty())
 169         return CommonSequenceTypes::ZeroOrOneBoolean;
 170     else
 171         return CommonSequenceTypes::ExactlyOneBoolean;
 172 }
 173
 174 QXmlNodeModelIndex::DocumentOrder NodeComparison::operatorID() const
 175 {
 176     return m_op;
 177 }
 178
 179 ExpressionVisitorResult::Ptr NodeComparison::accept(const ExpressionVisitor::Ptr &visitor) const
 180 {
 181     return visitor->visit(this);
 182 }
 183
 184 QT_END_NAMESPACE