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 #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