src/xmlpatterns/data/qcomparisonfactory.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/legal
   5 **
   6 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** Commercial License Usage
  10 ** Licensees holding valid commercial Qt licenses may use this file in
  11 ** accordance with the commercial license agreement provided with the
  12 ** Software or, alternatively, in accordance with the terms contained in
  13 ** a written agreement between you and Digia.  For licensing terms and
  14 ** conditions see http://qt.digia.com/licensing.  For further information
  15 ** use the contact form at http://qt.digia.com/contact-us.
  16 **
  17 ** GNU Lesser General Public License Usage
  18 ** Alternatively, this file may be used under the terms of the GNU Lesser
  19 ** General Public License version 2.1 as published by the Free Software
  20 ** Foundation and appearing in the file LICENSE.LGPL included in the
  21 ** packaging of this file.  Please review the following information to
  22 ** ensure the GNU Lesser General Public License version 2.1 requirements
  23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  24 **
  25 ** In addition, as a special exception, Digia gives you certain additional
  26 ** rights.  These rights are described in the Digia Qt LGPL Exception
  27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  28 **
  29 ** GNU General Public License Usage
  30 ** Alternatively, this file may be used under the terms of the GNU
  31 ** General Public License version 3.0 as published by the Free Software
  32 ** Foundation and appearing in the file LICENSE.GPL included in the
  33 ** packaging of this file.  Please review the following information to
  34 ** ensure the GNU General Public License version 3.0 requirements will be
  35 ** met: http://www.gnu.org/copyleft/gpl.html.
  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