diff options
Diffstat (limited to 'src/xmlpatterns/data/qderivedinteger_p.h')
| -rw-r--r-- | src/xmlpatterns/data/qderivedinteger_p.h | 624 |
1 files changed, 624 insertions, 0 deletions
diff --git a/src/xmlpatterns/data/qderivedinteger_p.h b/src/xmlpatterns/data/qderivedinteger_p.h new file mode 100644 index 0000000..4a394b3 --- /dev/null +++ b/src/xmlpatterns/data/qderivedinteger_p.h @@ -0,0 +1,624 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@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_DerivedInteger_H +#define Patternist_DerivedInteger_H + +#include "qbuiltintypes_p.h" +#include "qinteger_p.h" +#include "qpatternistlocale_p.h" +#include "qvalidationerror_p.h" + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +namespace QPatternist +{ + /** + * @relates DerivedInteger + */ + enum DerivedIntegerLimitsUsage + { + None = 1, + LimitUpwards = 2, + LimitDownwards = 4, + LimitBoth = LimitUpwards | LimitDownwards + }; + + enum + { + IgnorableSignedValue = 0, + IgnorableUnsignedValue = 0 + }; + + template<TypeOfDerivedInteger DerivedType> class DerivedInteger; + + template<TypeOfDerivedInteger DerivedType> class DerivedIntegerDetails; + + template<> + class DerivedIntegerDetails<TypeByte> + { + private: + friend class DerivedInteger<TypeByte>; + typedef qint8 StorageType; + typedef xsInteger TemporaryStorageType; + static const StorageType maxInclusive = 127; + static const StorageType minInclusive = -128; + static const DerivedIntegerLimitsUsage limitsUsage = LimitBoth; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeInt> + { + private: + friend class DerivedInteger<TypeInt>; + typedef qint32 StorageType; + typedef xsInteger TemporaryStorageType; + static const StorageType maxInclusive = Q_INT64_C(2147483647); + static const StorageType minInclusive = Q_INT64_C(-2147483648); + static const DerivedIntegerLimitsUsage limitsUsage = LimitBoth; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeLong> + { + private: + friend class DerivedInteger<TypeLong>; + typedef qint64 StorageType; + typedef StorageType TemporaryStorageType; + static const StorageType maxInclusive = Q_INT64_C(9223372036854775807); + + /** + * This messy arithmetic expression ensures that we don't get a warning + * on neither GCC nor MSVC. + */ + static const StorageType minInclusive = -(Q_INT64_C(9223372036854775807)) - 1; + + static const DerivedIntegerLimitsUsage limitsUsage = LimitBoth; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeNegativeInteger> + { + private: + friend class DerivedInteger<TypeNegativeInteger>; + typedef xsInteger StorageType; + typedef StorageType TemporaryStorageType; + static const StorageType maxInclusive = -1; + static const StorageType minInclusive = IgnorableSignedValue; + static const DerivedIntegerLimitsUsage limitsUsage = LimitUpwards; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeNonNegativeInteger> + { + private: + friend class DerivedInteger<TypeNonNegativeInteger>; + typedef xsInteger StorageType; + typedef StorageType TemporaryStorageType; + static const StorageType maxInclusive = IgnorableSignedValue; + static const StorageType minInclusive = 0; + static const DerivedIntegerLimitsUsage limitsUsage = LimitDownwards; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeNonPositiveInteger> + { + private: + friend class DerivedInteger<TypeNonPositiveInteger>; + typedef xsInteger StorageType; + typedef StorageType TemporaryStorageType; + static const StorageType maxInclusive = 0; + static const StorageType minInclusive = IgnorableSignedValue; + static const DerivedIntegerLimitsUsage limitsUsage = LimitUpwards; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypePositiveInteger> + { + private: + friend class DerivedInteger<TypePositiveInteger>; + typedef xsInteger StorageType; + typedef StorageType TemporaryStorageType; + static const StorageType maxInclusive = IgnorableSignedValue; + static const StorageType minInclusive = 1; + static const DerivedIntegerLimitsUsage limitsUsage = LimitDownwards; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeShort> + { + private: + friend class DerivedInteger<TypeShort>; + typedef qint16 StorageType; + typedef xsInteger TemporaryStorageType; + static const StorageType maxInclusive = 32767; + static const StorageType minInclusive = -32768; + static const DerivedIntegerLimitsUsage limitsUsage = LimitBoth; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeUnsignedByte> + { + private: + friend class DerivedInteger<TypeUnsignedByte>; + typedef quint8 StorageType; + typedef qint64 TemporaryStorageType; + static const StorageType maxInclusive = 255; + static const StorageType minInclusive = 0; + static const DerivedIntegerLimitsUsage limitsUsage = LimitBoth; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeUnsignedInt> + { + private: + friend class DerivedInteger<TypeUnsignedInt>; + typedef quint32 StorageType; + typedef qint64 TemporaryStorageType; + static const StorageType maxInclusive = Q_UINT64_C(4294967295); + static const StorageType minInclusive = 0; + static const DerivedIntegerLimitsUsage limitsUsage = LimitBoth; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeUnsignedLong> + { + private: + friend class DerivedInteger<TypeUnsignedLong>; + typedef quint64 StorageType; + typedef StorageType TemporaryStorageType; + static const StorageType maxInclusive = Q_UINT64_C(18446744073709551615); + static const StorageType minInclusive = 0; + static const DerivedIntegerLimitsUsage limitsUsage = LimitBoth; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + template<> + class DerivedIntegerDetails<TypeUnsignedShort> + { + private: + friend class DerivedInteger<TypeUnsignedShort>; + typedef quint16 StorageType; + typedef qint64 TemporaryStorageType; + static const StorageType maxInclusive = 65535; + static const StorageType minInclusive = 0; + static const DerivedIntegerLimitsUsage limitsUsage = LimitBoth; + + /** + * Disable the default constructor. + */ + DerivedIntegerDetails() {} + + Q_DISABLE_COPY(DerivedIntegerDetails) + }; + + /** + * @short Represents instances of derived @c xs:integer types, such as @c + * xs:byte. + * + * @author Frans Englich <fenglich@trolltech.com> + * @ingroup Patternist_xdm + */ + template<TypeOfDerivedInteger DerivedType> + class DerivedInteger : public Numeric + { + private: + typedef typename DerivedIntegerDetails<DerivedType>::StorageType StorageType; + typedef typename DerivedIntegerDetails<DerivedType>::TemporaryStorageType TemporaryStorageType; + + static const StorageType maxInclusive = DerivedIntegerDetails<DerivedType>::maxInclusive; + static const StorageType minInclusive = DerivedIntegerDetails<DerivedType>::minInclusive; + static const DerivedIntegerLimitsUsage limitsUsage = DerivedIntegerDetails<DerivedType>::limitsUsage; + + const StorageType m_value; + + inline DerivedInteger(const StorageType num) : m_value(num) + { + } + + /** + * By refactoring out the simple comparison below into a template + * function, we avoid the warning "warning: comparison of unsigned expression < 0 is always false" with gcc + * when the class is instantiated with TypeUnsignedLong. The warning is + * a false positive since we check wehther LimitUpwards is set before + * instantiating. + * + * This template function exists for no other reason. */ + template<typename A, typename B> + static bool lessThan(const A &a, const B &b) + { + return a < b; + } + + /** + * This function exists for the same reason that lessThan() do. + */ + template<typename A, typename B> + static bool largerOrEqual(const A &a, const B &b) + { + return qint64(a) >= b; + } + + public: + + static ItemType::Ptr itemType() + { + switch(DerivedType) + { + case TypeByte: return BuiltinTypes::xsByte; + case TypeInt: return BuiltinTypes::xsInt; + case TypeLong: return BuiltinTypes::xsLong; + case TypeNegativeInteger: return BuiltinTypes::xsNegativeInteger; + case TypeNonNegativeInteger: return BuiltinTypes::xsNonNegativeInteger; + case TypeNonPositiveInteger: return BuiltinTypes::xsNonPositiveInteger; + case TypePositiveInteger: return BuiltinTypes::xsPositiveInteger; + case TypeShort: return BuiltinTypes::xsShort; + case TypeUnsignedByte: return BuiltinTypes::xsUnsignedByte; + case TypeUnsignedInt: return BuiltinTypes::xsUnsignedInt; + case TypeUnsignedLong: return BuiltinTypes::xsUnsignedLong; + case TypeUnsignedShort: return BuiltinTypes::xsUnsignedShort; + } + + Q_ASSERT(false); + return ItemType::Ptr(); + } + + static AtomicValue::Ptr fromValue(const NamePool::Ptr &np, const TemporaryStorageType num) + { + /* If we use minInclusive when calling lessThan(), we for some + * reason get a linker error with GCC. Using this temporary + * variable solves it. */ + const StorageType minimum = minInclusive; + + if((limitsUsage & LimitUpwards) && + num > maxInclusive) + { + return ValidationError::createError(QtXmlPatterns::tr( + "Value %1 of type %2 exceeds maximum (%3).") + .arg(formatData(static_cast<xsInteger>(num))) + .arg(formatType(np, itemType())) + .arg(formatData(static_cast<xsInteger>(maxInclusive)))); + } + else if((limitsUsage & LimitDownwards) && + lessThan(num, minimum)) + { + return ValidationError::createError(QtXmlPatterns::tr( + "Value %1 of type %2 is below minimum (%3).") + .arg(formatData(static_cast<xsInteger>(num))) + .arg(formatType(np, itemType())) + .arg(formatData(static_cast<xsInteger>(minInclusive)))); + } + else + return AtomicValue::Ptr(new DerivedInteger(num)); + } + + static AtomicValue::Ptr fromValueUnchecked(const TemporaryStorageType num) + { + return AtomicValue::Ptr(new DerivedInteger(num)); + } + + /** + * Constructs an instance from the lexical + * representation @p strNumeric. + */ + static AtomicValue::Ptr fromLexical(const NamePool::Ptr &np, const QString &strNumeric) + { + bool conversionOk = false; + TemporaryStorageType num; + + /* Depending on the type, we need to call different conversion + * functions on QString. */ + switch(DerivedType) + { + case TypeUnsignedLong: + { + /* Qt decides to flag '-' as invalid, so remove it before. */ + if(strNumeric.contains(QLatin1Char('-'))) + { + num = QString(strNumeric).remove(QLatin1Char('-')).toULongLong(&conversionOk); + + if(num != 0) + conversionOk = false; + } + else + num = strNumeric.toULongLong(&conversionOk); + + break; + } + default: + { + num = strNumeric.toLongLong(&conversionOk); + break; + } + } + + if(conversionOk) + return fromValue(np, num); + else + return ValidationError::createError(); + } + + inline StorageType storedValue() const + { + return m_value; + } + + /** + * Determines the Effective %Boolean Value of this number. + * + * @returns @c false if the number is 0, otherwise @c true. + */ + bool evaluateEBV(const QExplicitlySharedDataPointer<DynamicContext> &) const + { + return m_value != 0; + } + + virtual QString stringValue() const + { + return QString::number(m_value); + } + + virtual ItemType::Ptr type() const + { + return itemType(); + } + + virtual xsDouble toDouble() const + { + return static_cast<xsDouble>(m_value); + } + + virtual xsInteger toInteger() const + { + return m_value; + } + + virtual xsFloat toFloat() const + { + return static_cast<xsFloat>(m_value); + } + + virtual xsDecimal toDecimal() const + { + return static_cast<xsDecimal>(m_value); + } + + virtual Numeric::Ptr round() const + { + /* xs:integerS never have a mantissa. */ + return Numeric::Ptr(static_cast<Numeric *>(const_cast<AtomicValue *>(Integer::fromValue(m_value).asAtomicValue()))); + } + + virtual Numeric::Ptr roundHalfToEven(const xsInteger) const + { + return Numeric::Ptr(static_cast<Numeric *>(const_cast<AtomicValue *>(Integer::fromValue(m_value).asAtomicValue()))); + } + + virtual Numeric::Ptr floor() const + { + return Numeric::Ptr(static_cast<Numeric *>(const_cast<AtomicValue *>(Integer::fromValue(m_value).asAtomicValue()))); + } + + virtual Numeric::Ptr ceiling() const + { + return Numeric::Ptr(static_cast<Numeric *>(const_cast<AtomicValue *>(Integer::fromValue(m_value).asAtomicValue()))); + } + + virtual Numeric::Ptr abs() const + { + /* We unconditionally create an Integer even if we're a positive + * value, because one part of this is the type change to + * xs:integer. + * + * We've manually inlined qAbs() and invoke xsInteger's + * constructor. The reason being that we other gets truncation down + * to StorageType. See for instance XQTS test case absint1args-1. */ + return Numeric::Ptr(static_cast<Numeric *>(const_cast<AtomicValue *>(Integer::fromValue(largerOrEqual(m_value, 0) ? xsInteger(m_value) : -xsInteger(m_value)).asAtomicValue()))); + } + + /** + * @returns always @c false, @c xs:DerivedInteger doesn't have + * not-a-number in its value space. + */ + virtual bool isNaN() const + { + return false; + } + + /** + * @returns always @c false, @c xs:DerivedInteger doesn't have + * infinity in its value space. + */ + virtual bool isInf() const + { + return false; + } + + virtual Item toNegated() const + { + return Integer::fromValue(-xsInteger(m_value)); + } + + virtual bool isSigned() const + { + switch(DerivedType) + { + /* Fallthrough all these. */ + case TypeByte: + case TypeInt: + case TypeLong: + case TypeNegativeInteger: + case TypeNonNegativeInteger: + case TypeNonPositiveInteger: + case TypePositiveInteger: + case TypeShort: + return true; + /* Fallthrough all these. */ + case TypeUnsignedByte: + case TypeUnsignedInt: + case TypeUnsignedLong: + case TypeUnsignedShort: + return false; + } + return false; + } + + virtual qulonglong toUnsignedInteger() const + { + switch(DerivedType) + { + /* Fallthrough all these. */ + case TypeByte: + case TypeInt: + case TypeLong: + case TypeNegativeInteger: + case TypeNonNegativeInteger: + case TypeNonPositiveInteger: + case TypePositiveInteger: + case TypeShort: + Q_ASSERT_X(false, Q_FUNC_INFO, + "It makes no sense to call this function, see Numeric::toUnsignedInteger()."); + /* Fallthrough all these. */ + case TypeUnsignedByte: + case TypeUnsignedInt: + case TypeUnsignedLong: + case TypeUnsignedShort: + return m_value; + } + return 0; + } + + }; +} + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif |