1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 //

    43 //  W A R N I N G

    44 //  -------------

    45 //

    46 // This file is not part of the Qt API.  It exists purely as an

    47 // implementation detail.  This header file may change from version to

    48 // version without notice, or even be removed.

    49 //

    50 // We mean it.

    51 

    52 #ifndef Patternist_Numeric_H

    53 #define Patternist_Numeric_H

    54 

    55 #include "qitem_p.h"

    56 #include "qprimitives_p.h"

    57 

    58 QT_BEGIN_HEADER

    59 

    60 QT_BEGIN_NAMESPACE

    61 

    62 /**

    63  * @file

    64  * @short Contains class Numeric. This file was originally called qnumeric_p.h,

    65  * but various build systems cannot handle that that name happens to be

    66  * identical to another one, the one in QtCore.

    67  */

    68 

    69 namespace QPatternist

    70 {

    71     /**

    72      * @short Base class for all numeric values.

    73      *

    74      * @section creation Creating Instances

    75      *

    76      * @todo

    77      * - Depending on what type of val

    78      * - Numeric::createFromString

    79      * - Various classes has ::Zero(), ::PosINF(), ::NaN(), NegINF()

    80      * - Never use constructor, use createFromNative, or createFromString.

    81      *

    82      * @see <a href="http://www.w3.org/TR/xquery-operators/#numeric-functions">XQuery 1.0

    83      * and XPath 2.0 Functions and Operators, 6 Functions and Operators on Numerics</a>

    84      * @see <a href="http://www.w3.org/TR/xquery-operators/#func-overloading">XQuery 1.0

    85      * and XPath 2.0 Functions and Operators, 1.2 Function Overloading</a>

    86      * @author Frans Englich <frans.englich@nokia.com>

    87      * @ingroup Patternist_xdm

    88      * @todo discuss data hierarchy the non existatnt number data type

    89      */

    90     class Numeric : public AtomicValue

    91     {

    92     public:

    93 

    94         typedef QExplicitlySharedDataPointer<Numeric> Ptr;

    95 

    96         /**

    97          * Creates a Numeric sub-class that is appropriate for @p number.

    98          *

    99          * @note usages of e/E is not handled; Double::fromLexical should

   100          * be used in that case. There is no function similar to fromLexical that also

   101          * takes double values into account(because that distinction is done in the scanner).

   102          *

   103          * Currently used in the parser to create appropriate expressions.

   104          */

   105         static AtomicValue::Ptr fromLexical(const QString &number);

   106 

   107         /**

   108          * @returns the particular number's value as a native representation of

   109          * the type xs:double. This can be considered that the value is cast to

   110          * xs:double.

   111          */

   112         virtual xsDouble toDouble() const = 0;

   113 

   114         /**

   115          * @returns the particular number's value as a native representation of

   116          * the type xs:integer. This can be considered that the value is cast to

   117          * xs:integer.

   118          */

   119         virtual xsInteger toInteger() const = 0;

   120 

   121         /**

   122          * @returns the number as an unsigned integer. If the value is not

   123          * unsigned, the code asserts and behavior is undefined.

   124          */

   125         virtual qulonglong toUnsignedInteger() const = 0;

   126 

   127         /**

   128          * @returns the particular number's value as a native representation of

   129          * the type xs:float. This can be considered that the value is cast to

   130          * xs:float.

   131          */

   132         virtual xsFloat toFloat() const = 0;

   133 

   134         /**

   135          * @returns the particular number's value as a native representation of

   136          * the type xs:decimal. This can be considered that the value is cast to

   137          * xs:decimal.

   138          */

   139         virtual xsFloat toDecimal() const = 0;

   140 

   141         /**

   142          * Performs the algorithm specified for the function fn:round on this Numeric,

   143          * and whose result is returned.

   144          *

   145          * @see <a href="http://www.w3.org/TR/xpath-functions/#func-round">XQuery 1.0

   146          * and XPath 2.0 Functions and Operators, 6.4.4 fn:round</a>

   147          */

   148         virtual Numeric::Ptr round() const = 0;

   149 

   150         /**

   151          * Performs rounding as defined for the fn:round-half-to-even  on this Numeric,

   152          * and whose result is returned.

   153          *

   154          * @see <a href="http://www.w3.org/TR/xpath-functions/#func-round-half-to-even">XQuery 1.0

   155          * and XPath 2.0 Functions and Operators, 6.4.5 fn:round-half-to-even</a>

   156          */

   157         virtual Numeric::Ptr roundHalfToEven(const xsInteger scale) const = 0;

   158 

   159         /**

   160          * Performs the algorithm specified for the function fn:floor on this Numeric,

   161          * and whose result is returned.

   162          *

   163          * @see <a href="http://www.w3.org/TR/xpath-functions/#func-floor">XQuery 1.0

   164          * and XPath 2.0 Functions and Operators, 6.4.3 fn:floor</a>

   165          */

   166         virtual Numeric::Ptr floor() const = 0;

   167 

   168         /**

   169          * Performs the algorithm specified for the function fn:ceiling on this Numeric,

   170          * and whose result is returned.

   171          *

   172          * @see <a href="http://www.w3.org/TR/xpath-functions/#func-ceiling">XQuery 1.0

   173          * and XPath 2.0 Functions and Operators, 6.4.2 fn:ceiling</a>

   174          */

   175         virtual Numeric::Ptr ceiling() const = 0;

   176 

   177         /**

   178          * Performs the algorithm specified for the function fn:abs on this Numeric,

   179          * and whose result is returned.

   180          *

   181          * @see <a href="http://www.w3.org/TR/xpath-functions/#func-ceiling">XQuery 1.0

   182          * and XPath 2.0 Functions and Operators, 6.4.1 fn:abs</a>

   183          */

   184         virtual Numeric::Ptr abs() const = 0;

   185 

   186         /**

   187          * Determines whether this Numeric is not-a-number, @c NaN. For numeric types

   188          * that cannot represent @c NaN, this function should return @c false.

   189          *

   190          * @returns @c true if this Numeric is @c NaN

   191          */

   192         virtual bool isNaN() const = 0;

   193 

   194         /**

   195          * Determines whether this Numeric is an infinite number. Signedness

   196          * is irrelevant, -INF as well as INF is considered infinity.

   197          *

   198          * For numeric types that cannot represent infinity, such as xs:integer

   199          * , this function should return @c false.

   200          *

   201          * @returns @c true if this Numeric is an infinite number

   202          */

   203         virtual bool isInf() const = 0;

   204 

   205         /**

   206          * Unary minus.

   207          */

   208         virtual Item toNegated() const = 0;

   209 

   210         /**

   211          * @short Returns @c true if this value is signed. If @c false is

   212          * returned, the value is unsigned.

   213          *

   214          * For float and decimal values, @c xs:double, @c xs:float and @c

   215          * xs:decimal, the code asserts and behavior is undefined.

   216          */

   217         virtual bool isSigned() const = 0;

   218 

   219     protected:

   220         /**

   221          * @short Implements @c fn:round() for types implemented with floating

   222          * point.

   223          *

   224          * MS Windows and at least IRIX does not have C99's nearbyint() function(see the man

   225          * page), so we reinvent it.

   226          */

   227         static xsDouble roundFloat(const xsDouble val);

   228     };

   229 }

   230 

   231 QT_END_NAMESPACE

   232 

   233 QT_END_HEADER

   234 

   235 #endif