src/xmlpatterns/data/qcomparisonfactory.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2008 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 #include "qatomiccomparators_p.h"
  43 #include "qatomicstring_p.h"
  44 #include "qcomparisonplatform_p.h"
  45 #include "qvaluefactory_p.h"
  46
  47 #include "qcomparisonfactory_p.h"
  48
  49 QT_BEGIN_NAMESPACE
  50
  51 using namespace QPatternist;
  52
  53 /**
  54  * @short Helper class for ComparisonFactory::fromLexical() which exposes
  55  * CastingPlatform appropriately.
  56  *
  57  * @relates ComparisonFactory
  58  */
  59 class PerformComparison : public ComparisonPlatform<PerformComparison, true>
  60                         , public SourceLocationReflection
  61 {
  62 public:
  63     PerformComparison(const SourceLocationReflection *const sourceLocationReflection,
  64                       const AtomicComparator::Operator op) : m_sourceReflection(sourceLocationReflection)
  65                                                            , m_operator(op)
  66     {
  67         Q_ASSERT(m_sourceReflection);
  68     }
  69
  70     bool operator()(const AtomicValue::Ptr &operand1,
  71                     const AtomicValue::Ptr &operand2,
  72                     const SchemaType::Ptr &type,
  73                     const ReportContext::Ptr &context)
  74     {
  75         const ItemType::Ptr asItemType((AtomicType::Ptr(type)));
  76
  77         /* One area where the Query Transform world differs from the Schema
  78          * world is that @c xs:duration is not considedered comparable, because
  79          * it's according to Schema is partially comparable. This means
  80          * ComparisonPlatform::fetchComparator() flags it as impossible, and
  81          * hence we need to override that.
  82          *
  83          * SchemaType::wxsTypeMatches() will return true for sub-types of @c
  84          * xs:duration as well, but that's ok since AbstractDurationComparator
  85          * works for them too. */
  86         if(BuiltinTypes::xsDuration->wxsTypeMatches(type))
  87             prepareComparison(AtomicComparator::Ptr(new AbstractDurationComparator()));
  88         else if (BuiltinTypes::xsGYear->wxsTypeMatches(type) ||
  89                  BuiltinTypes::xsGYearMonth->wxsTypeMatches(type) ||
  90                  BuiltinTypes::xsGMonth->wxsTypeMatches(type) ||
  91                  BuiltinTypes::xsGMonthDay->wxsTypeMatches(type) ||
  92                  BuiltinTypes::xsGDay->wxsTypeMatches(type))
  93             prepareComparison(AtomicComparator::Ptr(new AbstractDateTimeComparator()));
  94         else
  95             prepareComparison(fetchComparator(asItemType, asItemType, context));
  96
  97         return flexibleCompare(operand1, operand2, context);
  98     }
  99
 100     const SourceLocationReflection *actualReflection() const
 101     {
 102         return m_sourceReflection;
 103     }
 104
 105     AtomicComparator::Operator operatorID() const
 106     {
 107         return m_operator;
 108     }
 109
 110 private:
 111     const SourceLocationReflection *const m_sourceReflection;
 112     const AtomicComparator::Operator      m_operator;
 113 };
 114
 115 bool ComparisonFactory::compare(const AtomicValue::Ptr &operand1,
 116                                 const AtomicComparator::Operator op,
 117                                 const AtomicValue::Ptr &operand2,
 118                                 const SchemaType::Ptr &type,
 119                                 const ReportContext::Ptr &context,
 120                                 const SourceLocationReflection *const sourceLocationReflection)
 121 {
 122     Q_ASSERT(operand1);
 123     Q_ASSERT(operand2);
 124     Q_ASSERT(context);
 125     Q_ASSERT(sourceLocationReflection);
 126     Q_ASSERT(type);
 127     Q_ASSERT_X(type->category() == SchemaType::SimpleTypeAtomic, Q_FUNC_INFO,
 128                "We can only compare atomic values.");
 129
 130     return PerformComparison(sourceLocationReflection, op)(operand1, operand2, type, context);
 131 }
 132
 133 bool ComparisonFactory::constructAndCompare(const DerivedString<TypeString>::Ptr &operand1,
 134                                             const AtomicComparator::Operator op,
 135                                             const DerivedString<TypeString>::Ptr &operand2,
 136                                             const SchemaType::Ptr &type,
 137                                             const ReportContext::Ptr &context,
 138                                             const SourceLocationReflection *const sourceLocationReflection)
 139 {
 140     Q_ASSERT(operand1);
 141     Q_ASSERT(operand2);
 142     Q_ASSERT(context);
 143     Q_ASSERT(sourceLocationReflection);
 144     Q_ASSERT(type);
 145     Q_ASSERT_X(type->category() == SchemaType::SimpleTypeAtomic, Q_FUNC_INFO,
 146                "We can only compare atomic values.");
 147
 148     const AtomicValue::Ptr value1 = ValueFactory::fromLexical(operand1->stringValue(), type, context, sourceLocationReflection);
 149     const AtomicValue::Ptr value2 = ValueFactory::fromLexical(operand2->stringValue(), type, context, sourceLocationReflection);
 150
 151     return compare(value1, op, value2, type, context, sourceLocationReflection);
 152 }
 153
 154 QT_END_NAMESPACE