src/xmlpatterns/data/qdecimal.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 <math.h>
  43
  44 #include "qabstractfloat_p.h"
  45 #include "qatomictype_p.h"
  46 #include "qbuiltintypes_p.h"
  47 #include "qvalidationerror_p.h"
  48
  49 #include "qdecimal_p.h"
  50
  51 QT_BEGIN_NAMESPACE
  52
  53 using namespace QPatternist;
  54
  55 Decimal::Decimal(const xsDecimal num) : m_value(num)
  56 {
  57 }
  58
  59 Decimal::Ptr Decimal::fromValue(const xsDecimal num)
  60 {
  61     return Decimal::Ptr(new Decimal(num));
  62 }
  63
  64 AtomicValue::Ptr Decimal::fromLexical(const QString &strNumeric)
  65 {
  66     /* QString::toDouble() handles the whitespace facet. */
  67     const QString strNumericTrimmed(strNumeric.trimmed());
  68
  69     /* Block these out, as QString::toDouble() supports them. */
  70     if(strNumericTrimmed.compare(QLatin1String("-INF"), Qt::CaseInsensitive) == 0
  71        || strNumericTrimmed.compare(QLatin1String("INF"), Qt::CaseInsensitive)  == 0
  72        || strNumericTrimmed.compare(QLatin1String("+INF"), Qt::CaseInsensitive)  == 0
  73        || strNumericTrimmed.compare(QLatin1String("nan"), Qt::CaseInsensitive)  == 0
  74        || strNumericTrimmed.contains(QLatin1Char('e'))
  75        || strNumericTrimmed.contains(QLatin1Char('E')))
  76     {
  77         return ValidationError::createError();
  78     }
  79
  80     bool conversionOk = false;
  81     const xsDecimal num = strNumericTrimmed.toDouble(&conversionOk);
  82
  83     if(conversionOk)
  84         return AtomicValue::Ptr(new Decimal(num));
  85     else
  86         return ValidationError::createError();
  87 }
  88
  89 bool Decimal::evaluateEBV(const QExplicitlySharedDataPointer<DynamicContext> &) const
  90 {
  91     return !Double::isEqual(m_value, 0.0);
  92 }
  93
  94 QString Decimal::stringValue() const
  95 {
  96     return toString(m_value);
  97 }
  98
  99 QString Decimal::toString(const xsDecimal value)
 100 {
 101     /*
 102      * If SV is in the value space of xs:integer, that is, if there are no
 103      * significant digits after the decimal point, then the value is converted
 104      * from an xs:decimal to an xs:integer and the resulting xs:integer is
 105      * converted to an xs:string using the rule above.
 106      */
 107     if(Double::isEqual(::floor(value), value))
 108     {
 109         /* The static_cast is identical to Integer::toInteger(). */
 110         return QString::number(static_cast<xsInteger>(value));
 111     }
 112     else
 113     {
 114         int sign;
 115         int decimalPoint;
 116         char *result = 0;
 117         static_cast<void>(qdtoa(value, 0, 0, &decimalPoint, &sign, 0, &result));
 118         /* If the copy constructor is used instead of QString::operator=(),
 119          * it doesn't compile. I have no idea why. */
 120         const QString qret(QString::fromLatin1(result));
 121         free(result);
 122
 123         QString valueAsString;
 124
 125         if(sign)
 126             valueAsString += QLatin1Char('-');
 127
 128         if(0 < decimalPoint)
 129         {
 130             valueAsString += qret.left(decimalPoint);
 131             valueAsString += QLatin1Char('.');
 132             if (qret.size() <= decimalPoint)
 133                 valueAsString += QLatin1Char('0');
 134             else
 135                 valueAsString += qret.mid(decimalPoint);
 136         }
 137         else
 138         {
 139             valueAsString += QLatin1Char('0');
 140             valueAsString += QLatin1Char('.');
 141
 142             for(int d = decimalPoint; d < 0; d++)
 143                 valueAsString += QLatin1Char('0');
 144
 145             valueAsString += qret;
 146         }
 147
 148         return valueAsString;
 149     }
 150 }
 151
 152 ItemType::Ptr Decimal::type() const
 153 {
 154     return BuiltinTypes::xsDecimal;
 155 }
 156
 157 xsDouble Decimal::toDouble() const
 158 {
 159     return static_cast<xsDouble>(m_value);
 160 }
 161
 162 xsInteger Decimal::toInteger() const
 163 {
 164     return static_cast<xsInteger>(m_value);
 165 }
 166
 167 xsFloat Decimal::toFloat() const
 168 {
 169     return static_cast<xsFloat>(m_value);
 170 }
 171
 172 xsDecimal Decimal::toDecimal() const
 173 {
 174     return m_value;
 175 }
 176
 177 qulonglong Decimal::toUnsignedInteger() const
 178 {
 179     Q_ASSERT_X(false, Q_FUNC_INFO,
 180                "It makes no sense to call this function, see Numeric::toUnsignedInteger().");
 181     return 0;
 182 }
 183
 184 Numeric::Ptr Decimal::round() const
 185 {
 186     return Numeric::Ptr(new Decimal(roundFloat(m_value)));
 187 }
 188
 189 Numeric::Ptr Decimal::roundHalfToEven(const xsInteger /*scale*/) const
 190 {
 191     return Numeric::Ptr();
 192 }
 193
 194 Numeric::Ptr Decimal::floor() const
 195 {
 196     return Numeric::Ptr(new Decimal(static_cast<xsDecimal>(::floor(m_value))));
 197 }
 198
 199 Numeric::Ptr Decimal::ceiling() const
 200 {
 201     return Numeric::Ptr(new Decimal(static_cast<xsDecimal>(ceil(m_value))));
 202 }
 203
 204 Numeric::Ptr Decimal::abs() const
 205 {
 206     return Numeric::Ptr(new Decimal(static_cast<xsDecimal>(fabs(m_value))));
 207 }
 208
 209 bool Decimal::isNaN() const
 210 {
 211     return false;
 212 }
 213
 214 bool Decimal::isInf() const
 215 {
 216     return false;
 217 }
 218
 219 Item Decimal::toNegated() const
 220 {
 221     if(AbstractFloat<true>::isEqual(m_value, 0.0))
 222         return fromValue(0).data();
 223     else
 224         return fromValue(-m_value).data();
 225 }
 226
 227 bool Decimal::isSigned() const
 228 {
 229     Q_ASSERT_X(false, Q_FUNC_INFO,
 230                "It makes no sense to call this function, see Numeric::isSigned().");
 231     return false;
 232 }
 233
 234 QT_END_NAMESPACE