/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** 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$

**

****************************************************************************/

/**

 * @file

 * @short This file is included by qabstractfloat_p.h.

 * If you need includes in this file, put them in qabstractfloat_p.h, outside of the namespace.

 */

template <const bool isDouble>

AbstractFloat<isDouble>::AbstractFloat(const xsDouble num) : m_value(num)

{

}

template <const bool isDouble>

Numeric::Ptr AbstractFloat<isDouble>::fromValue(const xsDouble num)

{

    return Numeric::Ptr(new AbstractFloat<isDouble>(num));

}

template <const bool isDouble>

AtomicValue::Ptr AbstractFloat<isDouble>::fromLexical(const QString &strNumeric)

{

    /* QString::toDouble() handles the whitespace facet. */

    if(strNumeric == QLatin1String("NaN"))

        return isDouble ? CommonValues::DoubleNaN : CommonValues::FloatNaN;

    else if(strNumeric == QLatin1String("-INF"))

        return isDouble ? CommonValues::NegativeInfDouble : CommonValues::NegativeInfFloat;

    else if(strNumeric == QLatin1String("INF"))

        return isDouble ? CommonValues::InfDouble : CommonValues::InfFloat;

    /* QString::toDouble() supports any case as well as +INF, but we don't. */

    const QString toUpper(strNumeric.toUpper());

    if(toUpper == QLatin1String("-INF") ||

       toUpper == QLatin1String("INF")  ||

       toUpper == QLatin1String("+INF") ||

       toUpper == QLatin1String("NAN"))

    {

        return ValidationError::createError();

    }

    bool conversionOk = false;

    const xsDouble num = strNumeric.toDouble(&conversionOk);

    if(conversionOk)

        return AtomicValue::Ptr(new AbstractFloat<isDouble>(num));

    else

        return ValidationError::createError();

}

template <const bool isDouble>

int AbstractFloat<isDouble>::internalSignbit(const xsDouble num)

{

    Q_ASSERT_X(sizeof(xsDouble) == 8 || sizeof(xsDouble) == 4, Q_FUNC_INFO,

               "This implementation of signbit assumes xsDouble, that is qreal, is 64 bits large.");

    union

    {

        xsDouble asDouble;

        qint64 asInt;

    } value;

    value.asDouble = num;

    /* The highest bit, the 64'th for those who have 64bit floats, is the sign bit. So we pull it down until that bit is the

     * only one left. */

    if(sizeof(xsDouble) == 8)

        return value.asInt >> 63;

    else

        return value.asInt >> 31;

}

template <const bool isDouble>

bool AbstractFloat<isDouble>::isEqual(const xsDouble a, const xsDouble b)

{

    if(qIsInf(a))

        return qIsInf(b) && internalSignbit(a) == internalSignbit(b);

    else if(qIsInf(b))

        return qIsInf(a) && internalSignbit(a) == internalSignbit(b);

    else

    {

        /* Preferrably, we would use std::numeric_limits<xsDouble>::espilon(), but

         * we cannot since we cannot depend on the STL. The small xs:double value below,

         * was extracted by printing the std::numeric_limits<xsDouble>::epsilon() using

         * gdb. */

        return qAbs(a - b) <= 2.2204460492503131e-16 * qAbs(a);

    }

}

template <const bool isDouble>

bool AbstractFloat<isDouble>::isZero() const

{

    return AbstractFloat<isDouble>::isEqual(m_value, 0.0);

}

template <const bool isDouble>

bool AbstractFloat<isDouble>::evaluateEBV(const QExplicitlySharedDataPointer<DynamicContext> &) const

{

    if(isZero() || qIsNaN(m_value))

        return false;

    else

        return true;

}

template <const bool isDouble>

QString AbstractFloat<isDouble>::stringValue() const

{

    if(qIsNaN(m_value))

        return QLatin1String("NaN");

    else if(qIsInf(m_value))

        return internalSignbit(m_value) == 0 ? QLatin1String("INF") : QLatin1String("-INF");

    /*

     * If SV has an absolute value that is greater than or equal to 0.000001

     * (one millionth) and less than 1000000 (one million),

     * then the value is converted to an xs:decimal and the resulting xs:decimal

     * is converted to an xs:string according to the rules above.

     */

    else if(0.000001 <= qAbs(m_value) && qAbs(m_value) < 1000000.0)

        return Decimal::toString(toDecimal());

    /*

     * If SV has the value positive or negative zero, TV is "0" or "-0" respectively.

     */

    else if(isZero())

        return internalSignbit(m_value) == 0 ? QLatin1String("0") : QLatin1String("-0");

    else

    {

        /*

         * Besides these special values, the general form of the canonical form for

         * xs:float and xs:double is a mantissa, which is a xs:decimal, followed by

         * the letter "E", followed by an exponent which is an xs:integer.

         */

        int sign;

        int decimalPoint;

        char *result = 0;

        static_cast<void>(qdtoa(m_value, -1, 0, &decimalPoint, &sign, 0, &result));

        /* If the copy constructor is used instead of QString::operator=(),

         * it doesn't compile. I have no idea why. */

        const QString qret(QString::fromLatin1(result));

        /* We use free() instead of delete here, because qlocale.cpp use malloc(). Spotted

         * by valgrind. */

        free(result);

        QString valueAsString;

        if(sign)

            valueAsString += QLatin1Char('-');

        valueAsString += qret.at(0);

        valueAsString += QLatin1Char('.');

        if(1 == qret.size())

            valueAsString += QLatin1Char('0');

        else

            valueAsString += qret.mid(1);

        valueAsString += QLatin1Char('E');

        decimalPoint--;

        valueAsString += QString::number(decimalPoint);

        return valueAsString;

    }

}

template <const bool isDouble>

xsDouble AbstractFloat<isDouble>::toDouble() const

{

    return m_value;

}

template <const bool isDouble>

xsInteger AbstractFloat<isDouble>::toInteger() const

{

    return static_cast<xsInteger>(m_value);

}

template <const bool isDouble>

xsFloat AbstractFloat<isDouble>::toFloat() const

{

    /* No cast, since xsFloat and xsDouble are typedef'ed with the same type. */

    return m_value;

}

template <const bool isDouble>

xsDecimal AbstractFloat<isDouble>::toDecimal() const

{

    return static_cast<xsDecimal>(m_value);

}

template <const bool isDouble>

Numeric::Ptr AbstractFloat<isDouble>::round() const

{

    return AbstractFloat<isDouble>::fromValue(static_cast<xsDouble>(roundFloat(m_value)));

}

template <const bool isDouble>

Numeric::Ptr AbstractFloat<isDouble>::roundHalfToEven(const xsInteger precision) const

{

    if(isNaN() || isInf() || isZero())

        return Numeric::Ptr(const_cast<AbstractFloat<isDouble> *>(this));

    else

    {

        /* The cast to double helps finding the correct pow() version on irix-cc. */

        const xsDouble powered = pow(double(10), double(precision));

        xsDouble val = powered * m_value;

        bool isHalf = false;

        if(val - 0.5 == ::floor(val))

            isHalf = true;

        val = m_value * powered + 0.5;

        val = ::floor(val);

        if(isHalf /*&& isOdd(val) or? TODO */)

            val -= 1;

        val /= powered;

        return fromValue(val);

    }

}

template <const bool isDouble>

Numeric::Ptr AbstractFloat<isDouble>::floor() const

{

    return AbstractFloat<isDouble>::fromValue(static_cast<xsDouble>(::floor(m_value)));

}

template <const bool isDouble>

Numeric::Ptr AbstractFloat<isDouble>::ceiling() const

{

    return AbstractFloat<isDouble>::fromValue(static_cast<xsDouble>(ceil(m_value)));

}

template <const bool isDouble>

Numeric::Ptr AbstractFloat<isDouble>::abs() const

{

    /* We must use fabs() instead of qAbs() because qAbs()

     * doesn't return 0 for -0.0. */

    return AbstractFloat<isDouble>::fromValue(static_cast<xsDouble>(fabs(m_value)));

}

template <const bool isDouble>

bool AbstractFloat<isDouble>::isNaN() const

{

    return qIsNaN(m_value);

}

template <const bool isDouble>

bool AbstractFloat<isDouble>::isInf() const

{

    return qIsInf(m_value);

}

template <const bool isDouble>

ItemType::Ptr AbstractFloat<isDouble>::type() const

{

    return isDouble ? BuiltinTypes::xsDouble : BuiltinTypes::xsFloat;

}

template <const bool isDouble>

Item AbstractFloat<isDouble>::toNegated() const

{

    return fromValue(-m_value).data();

}

template <const bool isDouble>

bool AbstractFloat<isDouble>::isSigned() const

{

    Q_ASSERT_X(false, Q_FUNC_INFO,

               "It makes no sense to call this function, see Numeric::isSigned().");

    return false;

}

template <const bool isDouble>

qulonglong AbstractFloat<isDouble>::toUnsignedInteger() const

{

    Q_ASSERT_X(false, Q_FUNC_INFO,

               "It makes no sense to call this function, see Numeric::toUnsignedInteger().");

    return 0;

}