src/xmlpatterns/data/qatomicvalue.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  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
  64 QT_BEGIN_NAMESPACE
  65
  66 /**
  67  * @file
  68  * @short Contains the implementation for AtomicValue. The definition is in qitem_p.h.
  69  */
  70
  71 using namespace QPatternist;
  72
  73 AtomicValue::~AtomicValue()
  74 {
  75 }
  76
  77 bool AtomicValue::evaluateEBV(const QExplicitlySharedDataPointer<DynamicContext> &context) const
  78 {
  79     context->error(QtXmlPatterns::tr("A value of type %1 cannot have an "
  80                                      "Effective Boolean Value.")
  81                       .arg(formatType(context->namePool(), type())),
  82                       ReportContext::FORG0006,
  83                       QSourceLocation());
  84     return false; /* Silence GCC warning. */
  85 }
  86
  87 bool AtomicValue::hasError() const
  88 {
  89     return false;
  90 }
  91
  92 QVariant AtomicValue::toQt(const AtomicValue *const value)
  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)
 106         return QVariant(value->as<DerivedInteger<TypeUnsignedLong> >()->storedValue());
 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
 132 Item AtomicValue::toXDM(const QVariant &value)
 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(QString::fromLatin1(value.toUrl().toEncoded()));
 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:
 160             return DerivedInteger<TypeUnsignedLong>::fromValueUnchecked(value.toULongLong());
 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,
 182                            qPrintable(QString::fromLatin1(
 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
 192 ItemType::Ptr AtomicValue::qtToXDMType(const QXmlItem &item)
 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:
 214             return BuiltinTypes::xsBoolean;
 215         case QVariant::ByteArray:
 216             return BuiltinTypes::xsBase64Binary;
 217         case QVariant::Int:
 218         /* Fallthrough. */
 219         case QVariant::LongLong:
 220             return BuiltinTypes::xsInteger;
 221         case QVariant::ULongLong:
 222             return BuiltinTypes::xsUnsignedLong;
 223         case QVariant::Date:
 224             return BuiltinTypes::xsDate;
 225         case QVariant::DateTime:
 226         /* Fallthrough. */
 227         case QVariant::Time:
 228             return BuiltinTypes::xsDateTime;
 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
 238 QT_END_NAMESPACE