Qt 4.8
qcomparisonfactory.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2014 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 
50 
51 using namespace QPatternist;
52 
59 class PerformComparison : public ComparisonPlatform<PerformComparison, true>
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. */
87  prepareComparison(AtomicComparator::Ptr(new AbstractDurationComparator()));
88  else if (BuiltinTypes::xsGYear->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 
101  {
102  return m_sourceReflection;
103  }
104 
106  {
107  return m_operator;
108  }
109 
110 private:
113 };
114 
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);
128  "We can only compare atomic values.");
129 
130  return PerformComparison(sourceLocationReflection, op)(operand1, operand2, type, context);
131 }
132 
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);
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 
static AtomicValue::Ptr fromLexical(const QString &lexicalValue, const SchemaType::Ptr &type, const ReportContext::Ptr &context, const SourceLocationReflection *const sourceLocationReflection)
Returns an AtomicValue of type type from the lexical space lexicalValue, and raise an error through c...
virtual TypeCategory category() const =0
int type
Definition: qmetatype.cpp:239
#define QT_END_NAMESPACE
This macro expands to.
Definition: qglobal.h:90
Helper class for ComparisonFactory::fromLexical() which exposes CastingPlatform appropriately.
static const AtomicType::Ptr xsDuration
PerformComparison(const SourceLocationReflection *const sourceLocationReflection, const AtomicComparator::Operator op)
bool operator()(const AtomicValue::Ptr &operand1, const AtomicValue::Ptr &operand2, const SchemaType::Ptr &type, const ReportContext::Ptr &context)
static const AtomicType::Ptr xsGYearMonth
const AtomicComparator::Operator m_operator
static const AtomicType::Ptr xsGMonthDay
AllCompOperators AtomicComparator::OperatorEqual AtomicComparator::OperatorNotEqual AllCompOperators FloatType IntegerType FloatType IntegerType FloatType AllCompOperators FloatType AllCompOperators AbstractDateTimeComparator
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
static const AtomicType::Ptr xsGDay
#define QT_BEGIN_NAMESPACE
This macro expands to.
Definition: qglobal.h:89
static bool compare(const QVariant::Private *a, const QVariant::Private *b)
Compares a to b.
Definition: qvariant.cpp:383
AtomicComparator::Operator operatorID() const
The namespace for the internal API of QtXmlPatterns.
const SourceLocationReflection * actualReflection() const
virtual QString stringValue() const =0
const SourceLocationReflection *const m_sourceReflection
static const AtomicType::Ptr xsGYear
#define Q_ASSERT_X(cond, where, what)
Definition: qglobal.h:1837
AllCompOperators AtomicComparator::OperatorEqual AtomicComparator::OperatorNotEqual AllCompOperators FloatType IntegerType FloatType IntegerType FloatType AllCompOperators FloatType AllCompOperators AtomicComparator::OperatorEqual AtomicComparator::OperatorNotEqual AtomicComparator::OperatorEqual AtomicComparator::OperatorNotEqual AtomicComparator::OperatorEqual AtomicComparator::OperatorNotEqual AllCompOperators AbstractDurationComparator
static bool wxsTypeMatches(const SchemaType::Ptr &type, const SchemaType::Ptr &otherType, QSet< SchemaType::Ptr > &visitedTypes, SchemaType::Ptr &conflictingType)
static bool constructAndCompare(const DerivedString< TypeString >::Ptr &operand1, const AtomicComparator::Operator op, const DerivedString< TypeString >::Ptr &operand2, const SchemaType::Ptr &type, const ReportContext::Ptr &context, const SourceLocationReflection *const sourceLocationReflection)
Returns the result of evaluating operator op applied to the atomic values operand1 and operand2...
Provides comparison functionality for classes that compare Items, such as ValueComparison or MaxFN...
static const AtomicType::Ptr xsGMonth
Contains all the classes implementing comparisons between atomic values.
static bool compare(const AtomicValue::Ptr &operand1, const AtomicComparator::Operator op, const AtomicValue::Ptr &operand2, const SchemaType::Ptr &type, const ReportContext::Ptr &context, const SourceLocationReflection *const sourceLocationReflection)
Returns the result of evaluating operator op applied to the atomic values operand1 and operand2...
Base class for all instances that represents something at a certain location.
#define Q_FUNC_INFO
Definition: qglobal.h:1871