1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtXmlPatterns module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain
** additional rights. These rights are described in the Nokia Qt LGPL
** Exception version 1.1, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
#ifndef Patternist_ComparisonPlatform_H
#define Patternist_ComparisonPlatform_H
#include "qatomiccomparators_p.h"
#include "qitem_p.h"
#include "qcommonsequencetypes_p.h"
#include "qdynamiccontext_p.h"
#include "qbuiltintypes_p.h"
#include "qitemtype_p.h"
#include "qpatternistlocale_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
namespace QPatternist
{
/**
* @short Provides comparison functionality for classes that compare Items,
* such as ValueComparison or MaxFN.
*
* Classes which need comparison functionalities should inherit from this class.
*
* The parameter of this template class is the class inheriting from ComparisonPlatform.
*
* The class inheriting ComparisonPlatform must implement the following function:
* @code
* AtomicComparator::Operator operatorID() const
* @endcode
*
* @author Vincent Ricard <magic@magicninja.org>
* @ingroup Patternist_expressions
*/
template <typename TSubClass,
bool issueError,
AtomicComparator::ComparisonType comparisonType = AtomicComparator::AsValueComparison,
ReportContext::ErrorCode errorCode = ReportContext::XPTY0004>
class ComparisonPlatform
{
protected:
/**
* Makes ComparisonPlatform use the AtomicComparator @p comparator.
*/
void prepareComparison(const AtomicComparator::Ptr &comparator);
/**
* Default constructor. Does nothing. It is implemented in order make template
* instantiation easier.
*/
inline ComparisonPlatform()
{
}
/**
* Utility function for fetching the appropriate AtomicComparator
* for two atomic values of type @p type1 and @p type2, for the operator @p op.
*
* This function is used throughout the implementation, ranging from the ValueComparison
* itself, to for example the aggregate functions.
*
* @param context the ordinary ReportContext, used for issuing errors.
* @param type1 the type of the first operand value in a comparison for which the
* returned AtomicComparator is intended for
* @param type2 the type of the second operand value in a comparison for which the
* returned AtomicComparator is intended for. Whether @p type1 and @p type2 corresponds
* to what is the first second operand type does not have significance, the order
* can be arbitrary
*/
AtomicComparator::Ptr
fetchComparator(const ItemType::Ptr &type1,
const ItemType::Ptr &type2,
const ReportContext::Ptr &context) const;
/**
* @short Compares @p i1 and @p i2 with operator @p op, using comparator @p
* comp. All input arguments must be valid, and not @c null.
*
* This is a fast, raw function which has the requirement that the
* caller knows what to compare and with what.
*/
bool compare(const Item &i1,
const Item &i2,
const AtomicComparator::Ptr &comp,
const AtomicComparator::Operator op) const;
/**
* @short Compares @p it1 against @p it2, using comparator() and operatorID().
*
* If the comparator wasn't looked up at compile time, it will be
* attempted before comparing. If this fails, errors are reported via
* @p context.
*/
bool
flexibleCompare(const Item &it1,
const Item &it2,
const DynamicContext::Ptr &context) const;
/**
* @short like flexibleCompare(), but returns the result
* as an AtomicComparator::Operator instead of @c bool.
*
* This is useful when it is significant how a less than comparison
* fails; whether the two values are equal or greater than.
*/
AtomicComparator::ComparisonResult
detailedFlexibleCompare(const Item &it1,
const Item &it2,
const DynamicContext::Ptr &context) const;
/**
* @returns the AtomicComparator that has been allocated at compile time,
* with prepareComparison(). If no AtomicComparator has been allocated
* for some reason, this function returns @c null.
*/
inline const AtomicComparator::Ptr &comparator() const
{
return m_comparator;
}
/**
* Calling this function makes ComparisonPlatform use a comparator that
* compares strings case insensitively.
*
* @see ValueComparison::isCaseInsensitiveCompare()
*/
inline void useCaseInsensitiveComparator()
{
m_comparator = AtomicComparator::Ptr(new CaseInsensitiveStringComparator());
}
private:
/**
* @returns the operator that is used.
*/
inline AtomicComparator::Operator operatorID() const
{
Q_ASSERT(static_cast<const TSubClass *>(this)->operatorID());
return static_cast<const TSubClass *>(this)->operatorID();
}
/**
* The comparator that is used for comparing atomic values. The AtomicComparator
* that is used, depends on the static type of the operands. m_comparator can be
* @c null if it wasn't possible to determine what comparator to use at compile time.
*/
AtomicComparator::Ptr m_comparator;
};
#include "qcomparisonplatform.cpp"
}
QT_END_NAMESPACE
QT_END_HEADER
#endif
|
