Qt 4.8
qatomicvalue.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 <QVariant>
43 
44 #include "qabstractdatetime_p.h"
45 #include "qabstractfloat_p.h"
46 #include "qatomicstring_p.h"
47 #include "qatomictype_p.h"
48 #include "qboolean_p.h"
49 #include "qbuiltintypes_p.h"
50 #include "qdate_p.h"
51 #include "qschemadatetime_p.h"
52 #include "qderivedinteger_p.h"
53 #include "qdynamiccontext_p.h"
54 #include "qgenericsequencetype_p.h"
55 #include "qhexbinary_p.h"
56 #include "qinteger_p.h"
57 #include "qpatternistlocale_p.h"
58 #include "qqnamevalue_p.h"
59 #include "qschematime_p.h"
60 #include "qvalidationerror_p.h"
61 
62 #include "qitem_p.h"
63 
65 
71 using namespace QPatternist;
72 
74 {
75 }
76 
78 {
79  context->error(QtXmlPatterns::tr("A value of type %1 cannot have an "
80  "Effective Boolean Value.")
81  .arg(formatType(context->namePool(), type())),
83  QSourceLocation());
84  return false; /* Silence GCC warning. */
85 }
86 
88 {
89  return false;
90 }
91 
93 {
94  Q_ASSERT_X(value, Q_FUNC_INFO,
95  "Internal error, a null pointer cannot be passed.");
96 
97  const ItemType::Ptr t(value->type());
98 
99  if(BuiltinTypes::xsString->xdtTypeMatches(t)
100  || BuiltinTypes::xsUntypedAtomic->xdtTypeMatches(t)
101  || BuiltinTypes::xsAnyURI->xdtTypeMatches(t))
102  return value->stringValue();
103  /* Note, this occurs before the xsInteger test, since xs:unsignedLong
104  * is a subtype of it. */
105  else if(*BuiltinTypes::xsUnsignedLong == *t)
107  else if(BuiltinTypes::xsInteger->xdtTypeMatches(t))
108  return QVariant(value->as<Numeric>()->toInteger());
109  else if(BuiltinTypes::xsFloat->xdtTypeMatches(t)
110  || BuiltinTypes::xsDouble->xdtTypeMatches(t)
111  || BuiltinTypes::xsDecimal->xdtTypeMatches(t))
112  return QVariant(value->as<Numeric>()->toDouble());
113  /* We currently does not support xs:time. */
114  else if(BuiltinTypes::xsDateTime->xdtTypeMatches(t))
115  return QVariant(value->as<AbstractDateTime>()->toDateTime());
116  else if(BuiltinTypes::xsDate->xdtTypeMatches(t))
117  return QVariant(value->as<AbstractDateTime>()->toDateTime().toUTC().date());
118  else if(BuiltinTypes::xsBoolean->xdtTypeMatches(t))
119  return QVariant(value->as<Boolean>()->value());
120  else if(BuiltinTypes::xsBase64Binary->xdtTypeMatches(t)
121  || BuiltinTypes::xsHexBinary->xdtTypeMatches(t))
122  return QVariant(value->as<Base64Binary>()->asByteArray());
123  else if(BuiltinTypes::xsQName->xdtTypeMatches(t))
124  return QVariant::fromValue(value->as<QNameValue>()->qName());
125  else
126  {
127  /* A type we don't support in Qt. Includes xs:time currently. */
128  return QVariant();
129  }
130 }
131 
133 {
134  Q_ASSERT_X(value.isValid(), Q_FUNC_INFO,
135  "QVariants sent to Patternist must be valid.");
136 
137  switch(value.userType())
138  {
139  case QVariant::Char:
140  /* Fallthrough. A single codepoint is a string in XQuery. */
141  case QVariant::String:
142  return AtomicString::fromValue(value.toString());
143  case QVariant::Url:
144  {
145  /* QUrl doesn't follow the spec properly, so we
146  * have to let it be an xs:string. Calling QVariant::toString()
147  * on a QVariant that contains a QUrl returns, surprisingly,
148  * an empty string. */
149  return AtomicString::fromValue(value.toUrl().toString());
150  }
151  case QVariant::ByteArray:
152  return HexBinary::fromValue(value.toByteArray());
153  case QVariant::Int:
154  /* Fallthrough. */
155  case QVariant::LongLong:
156  /* Fallthrough. */
157  case QVariant::UInt:
158  return Integer::fromValue(value.toLongLong());
159  case QVariant::ULongLong:
161  case QVariant::Bool:
162  return Boolean::fromValue(value.toBool());
163  case QVariant::Time:
164  return SchemaTime::fromDateTime(value.toDateTime());
165  case QVariant::Date:
166  return Date::fromDateTime(QDateTime(value.toDate(), QTime(), Qt::UTC));
167  case QVariant::DateTime:
168  return DateTime::fromDateTime(value.toDateTime());
169  case QMetaType::Float:
170  return Item(Double::fromValue(value.toFloat()));
171  case QVariant::Double:
172  return Item(Double::fromValue(value.toDouble()));
173  default:
174  {
175  if (value.userType() == qMetaTypeId<float>())
176  {
177  return Item(Float::fromValue(value.value<float>()));
178  }
179  else {
180  Q_ASSERT_X(false,
181  Q_FUNC_INFO,
183  "QVariants of type %1 are not supported in "
184  "Patternist, see the documentation")
185  .arg(QLatin1String(value.typeName()))));
186  return AtomicValue::Ptr();
187  }
188  }
189  }
190 }
191 
193 {
194  Q_ASSERT(!item.isNull());
195 
196  if(item.isNull())
197  return ItemType::Ptr();
198 
199  if(item.isNode())
200  return BuiltinTypes::node;
201 
202  Q_ASSERT(item.isAtomicValue());
203  const QVariant v(item.toAtomicValue());
204 
205  switch(int(v.type()))
206  {
207  case QVariant::Char:
208  /* Fallthrough. */
209  case QVariant::String:
210  /* Fallthrough. */
211  case QVariant::Url:
212  return BuiltinTypes::xsString;
213  case QVariant::Bool:
215  case QVariant::ByteArray:
217  case QVariant::Int:
218  /* Fallthrough. */
219  case QVariant::LongLong:
221  case QVariant::ULongLong:
223  case QVariant::Date:
224  return BuiltinTypes::xsDate;
225  case QVariant::DateTime:
226  /* Fallthrough. */
227  case QVariant::Time:
229  case QMetaType::Float:
230  return BuiltinTypes::xsFloat;
231  case QVariant::Double:
232  return BuiltinTypes::xsDouble;
233  default:
234  return ItemType::Ptr();
235  }
236 }
237 
The QVariant class acts like a union for the most common Qt data types.
Definition: qvariant.h:92
static const AtomicType::Ptr xsBase64Binary
QExplicitlySharedDataPointer< AtomicValue > Ptr
Definition: qitem_p.h:127
virtual NamePool::Ptr namePool() const =0
#define QT_END_NAMESPACE
This macro expands to.
Definition: qglobal.h:90
Base class for classes implementing values related to time, date or both.
QString toString(FormattingOptions options=None) const
Returns the human-displayable string representation of the URL.
Definition: qurl.cpp:5896
static QVariant toQt(const AtomicValue *const value)
virtual bool hasError() const
static Date::Ptr fromDateTime(const QDateTime &date)
Definition: qdate.cpp:88
QString formatType(const NamePool::Ptr &np, const T &type)
Formats ItemType and SequenceType.
Due to strong interdependencies, this file contains the definitions for the classes Item...
The QXmlItem class contains either an XML node or an atomic value.
QString toString() const
Returns the variant as a QString if the variant has type() String , Bool , ByteArray ...
Definition: qvariant.cpp:2270
QDateTime toDateTime() const
Returns the variant as a QDateTime if the variant has type() DateTime , Date , or String ; otherwise ...
Definition: qvariant.cpp:2349
StorageType storedValue() const
QLatin1String(DBUS_INTERFACE_DBUS))) Q_GLOBAL_STATIC_WITH_ARGS(QString
bool toBool() const
Returns the variant as a bool if the variant has type() Bool.
Definition: qvariant.cpp:2691
static DateTime::Ptr fromDateTime(const QDateTime &dt)
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
Contains class DateTime. This file was originally called qdatetime_p.h, but various build systems can...
static Item fromValue(const xsInteger num)
Definition: qinteger.cpp:52
static AtomicString::Ptr fromValue(const QString &value)
QByteArray toByteArray() const
Returns the variant as a QByteArray if the variant has type() ByteArray or String (converted using QS...
Definition: qvariant.cpp:2383
static const AtomicType::Ptr xsString
QXmlName qName() const
Definition: qqnamevalue_p.h:96
The QTime class provides clock time functions.
Definition: qdatetime.h:148
#define QT_BEGIN_NAMESPACE
This macro expands to.
Definition: qglobal.h:89
qlonglong toLongLong(bool *ok=0) const
Returns the variant as a long long int if the variant has type() LongLong , Bool , ByteArray , Char , Double , Int , String , UInt , or ULongLong ; otherwise returns 0.
Definition: qvariant.cpp:2659
const TCastTarget * as() const
void error(const QString &message, const ReportContext::ErrorCode errorCode, const QSourceLocation &sourceLocation)
bool isNode() const
Returns true if this item is a Node.
virtual bool evaluateEBV(const QExplicitlySharedDataPointer< DynamicContext > &context) const
Base class for all classes representing atomic values.
Definition: qitem_p.h:118
static const AtomicType::Ptr xsDateTime
The namespace for the internal API of QtXmlPatterns.
virtual ItemType::Ptr type() const =0
qulonglong toULongLong(bool *ok=0) const
Returns the variant as as an unsigned long long int if the variant has type() ULongLong ...
Definition: qvariant.cpp:2675
static const AtomicType::Ptr xsDouble
The QSourceLocation class identifies a location in a resource by URI, line, and column.
virtual QString stringValue() const =0
QVariant toAtomicValue() const
If this QXmlItem represents an atomic value, it is converted to an appropriate QVariant and returned...
const QDateTime & toDateTime() const
static Boolean::Ptr fromValue(const bool value)
Definition: qboolean.cpp:115
bool value() const
Definition: qboolean_p.h:109
static QVariant fromValue(const T &value)
Returns a QVariant containing a copy of value.
Definition: qvariant.h:336
const char * typeName() const
Returns the name of the type stored in the variant.
Definition: qvariant.cpp:1984
QUrl toUrl() const
Returns the variant as a QUrl if the variant has type() Url ; otherwise returns an invalid QUrl...
Definition: qvariant.cpp:2528
static const AnyNodeType::Ptr node
QDateTime toUTC() const
Returns a datetime containing the date and time information in this datetime, but specified using the...
Definition: qdatetime.h:251
static const AtomicType::Ptr xsUntypedAtomic
Implements the value instance of the xs:boolean type.
Definition: qboolean_p.h:69
QDate date() const
Returns the date part of the datetime.
Definition: qdatetime.cpp:2357
QExplicitlySharedDataPointer< ItemType > Ptr
Definition: qitemtype_p.h:88
QDate toDate() const
Returns the variant as a QDate if the variant has type() Date , DateTime , or String ; otherwise retu...
Definition: qvariant.cpp:2311
#define Q_ASSERT_X(cond, where, what)
Definition: qglobal.h:1837
int userType() const
Returns the storage type of the value stored in the variant.
Definition: qvariant.cpp:1913
Contains functions used for formatting arguments, such as keywords and paths, in translated strings...
The QDateTime class provides date and time functions.
Definition: qdatetime.h:216
Represents an item in the XPath 2.0 Data Model.
Definition: qitem_p.h:182
static const AtomicType::Ptr xsQName
Base class for all numeric values.
virtual xsInteger toInteger() const =0
static QString fromLatin1(const char *, int size=-1)
Returns a QString initialized with the first size characters of the Latin-1 string str...
Definition: qstring.cpp:4188
bool isAtomicValue() const
Returns true if this item is an atomic value.
static const AtomicType::Ptr xsFloat
Implements the value instance of the xs:QName type.
Definition: qqnamevalue_p.h:73
virtual xsDouble toDouble() const =0
static Numeric::Ptr fromValue(const xsDouble num)
float toFloat(bool *ok=0) const
Returns the variant as a float if the variant has type() Double , QMetaType::Float ...
Definition: qvariant.cpp:2725
static SchemaTime::Ptr fromDateTime(const QDateTime &dt)
Definition: qschematime.cpp:87
static const AtomicType::Ptr xsInteger
double toDouble(bool *ok=0) const
Returns the variant as a double if the variant has type() Double , QMetaType::Float ...
Definition: qvariant.cpp:2710
static HexBinary::Ptr fromValue(const QByteArray &data)
Definition: qhexbinary.cpp:123
const QByteArray & asByteArray() const
static const AtomicType::Ptr xsDecimal
static AtomicValue::Ptr fromValueUnchecked(const TemporaryStorageType num)
static const AtomicType::Ptr xsBoolean
Represents instances of derived xs:integer types, such as xs:byte.
static const AtomicType::Ptr xsDate
T value() const
Returns the stored value converted to the template type T.
Definition: qvariant.h:332
bool isValid() const
Returns true if the storage type of this variant is not QVariant::Invalid; otherwise returns false...
Definition: qvariant.h:485
static ItemType::Ptr qtToXDMType(const QXmlItem &item)
Implements the value instance of the xs:base64Binary type.
#define qPrintable(string)
Definition: qglobal.h:1750
static Item toXDM(const QVariant &value)
static const AtomicType::Ptr xsHexBinary
static const AtomicType::Ptr xsUnsignedLong
static const AtomicType::Ptr xsAnyURI
bool isNull() const
Returns true if this QXmlItem is neither a node nor an atomic value.
#define Q_FUNC_INFO
Definition: qglobal.h:1871