source: icXML/icXML-devel/src/xercesc/util/XMLAbstractDoubleFloat.hpp @ 2722

Last change on this file since 2722 was 2722, checked in by cameron, 6 years ago

Original Xerces files with import mods for icxercesc

File size: 6.4 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: XMLAbstractDoubleFloat.hpp 605828 2007-12-20 08:05:47Z amassari $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_XML_ABSTRACT_DOUBLE_FLOAT_HPP)
23#define XERCESC_INCLUDE_GUARD_XML_ABSTRACT_DOUBLE_FLOAT_HPP
24
25
26#include <xercesc/util/XMLNumber.hpp>
27#include <icxercesc/util/PlatformUtils.hpp>
28
29XERCES_CPP_NAMESPACE_BEGIN
30
31/***
32 * 3.2.5.1 Lexical representation
33 *
34 *   double values have a lexical representation consisting of a mantissa followed,
35 *   optionally, by the character "E" or "e", followed by an exponent.
36 *
37 *   The exponent must be an integer.
38 *   The mantissa must be a decimal number.
39 *   The representations for exponent and mantissa must follow the lexical rules
40 *   for integer and decimal.
41 *
42 *   If the "E" or "e" and the following exponent are omitted,
43 *   an exponent value of 0 is assumed.
44***/
45
46/***
47 * 3.2.4.1 Lexical representation
48 *
49 *   float values have a lexical representation consisting of a mantissa followed,
50 *   optionally, by the character "E" or "e", followed by an exponent.
51 *
52 *   The exponent must be an integer.
53 *   The mantissa must be a decimal number.
54 *   The representations for exponent and mantissa must follow the lexical rules
55 *   for integer and decimal.
56 *
57 *   If the "E" or "e" and the following exponent are omitted,
58 *   an exponent value of 0 is assumed.
59***/
60
61class XMLUTIL_EXPORT XMLAbstractDoubleFloat : public XMLNumber
62{
63public:
64
65    enum LiteralType
66    {
67        NegINF,
68        PosINF,
69        NaN,
70        SpecialTypeNum,
71        Normal
72    };
73
74    virtual ~XMLAbstractDoubleFloat();
75
76    static XMLCh* getCanonicalRepresentation
77                        (
78                          const XMLCh*         const rawData
79                        ,       MemoryManager* const memMgr = XMLPlatformUtils::fgMemoryManager
80                        );
81   
82    virtual XMLCh*        getRawData() const;
83
84    virtual const XMLCh*  getFormattedString() const;
85
86    virtual int           getSign() const;
87
88    MemoryManager*        getMemoryManager() const;
89
90    inline  bool          isDataConverted()  const;
91
92    inline  bool          isDataOverflowed()  const;
93
94    inline  double        getValue() const;
95
96    inline  LiteralType   getType() const;
97
98    /***
99     *
100     * The decimal point delimiter for the schema double/float type is
101     * defined to be a period and is not locale-specific. So, it must
102     * be replaced with the local-specific delimiter before converting
103     * from string to double/float.
104     *
105     ***/
106    static void            normalizeDecimalPoint(char* const toNormal);
107
108    /***
109     * Support for Serialization/De-serialization
110     ***/
111    DECL_XSERIALIZABLE(XMLAbstractDoubleFloat)
112
113protected:
114
115    //
116    // To be used by derived class exclusively
117    //
118    XMLAbstractDoubleFloat(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
119
120    void                  init(const XMLCh* const strValue);
121
122    /**
123         * Compares this object to the specified object.
124         * The result is <code>true</code> if and only if the argument is not
125         * <code>null</code> and is an <code>XMLAbstractDoubleFloat</code> object that contains
126         * the same <code>int</code> value as this object.
127         *
128         * @param   lValue the object to compare with.
129         * @param   rValue the object to compare against.
130     * @param manager The MemoryManager to use to allocate objects
131         * @return  <code>true</code> if the objects are the same;
132         *          <code>false</code> otherwise.
133         */
134
135    static int            compareValues(const XMLAbstractDoubleFloat* const lValue
136                                      , const XMLAbstractDoubleFloat* const rValue
137                                      , MemoryManager* const manager);
138
139    //
140    // to be overridden by derived class
141    //
142    virtual void          checkBoundary(char* const strValue) = 0;
143
144    void
145    convert(char* const strValue);
146
147private:
148    //
149    // Unimplemented
150    //
151    // copy ctor
152    // assignment ctor
153    //
154    XMLAbstractDoubleFloat(const XMLAbstractDoubleFloat& toCopy);
155    XMLAbstractDoubleFloat& operator=(const XMLAbstractDoubleFloat& toAssign);
156
157        void                  normalizeZero(XMLCh* const);
158
159    inline bool           isSpecialValue() const;
160
161    static int            compareSpecial(const XMLAbstractDoubleFloat* const specialValue                                       
162                                       , MemoryManager* const manager);
163
164    void                  formatString();
165
166protected:
167    double                  fValue;
168    LiteralType             fType;
169    bool                    fDataConverted;
170    bool                    fDataOverflowed;
171
172private:
173    int                     fSign;
174    XMLCh*                  fRawData;
175
176    //
177    // If the original string is not lexcially the same as the five
178    // special value notations, and the value is converted to
179    // special value due underlying platform restriction on data
180    // representation, then this string is constructed and
181    // takes the form "original_string (special_value_notation)",
182    // otherwise it is empty.
183    //
184    XMLCh*                  fFormattedString;
185    MemoryManager*          fMemoryManager;
186
187};
188
189inline bool XMLAbstractDoubleFloat::isSpecialValue() const
190{
191    return (fType < SpecialTypeNum);
192}
193
194inline MemoryManager* XMLAbstractDoubleFloat::getMemoryManager() const
195{
196    return fMemoryManager;
197}
198
199inline bool XMLAbstractDoubleFloat::isDataConverted() const
200{
201    return fDataConverted;
202}
203
204inline bool XMLAbstractDoubleFloat::isDataOverflowed() const
205{
206    return fDataOverflowed;
207}
208
209inline double XMLAbstractDoubleFloat::getValue() const
210{
211    return fValue;
212}
213
214inline  XMLAbstractDoubleFloat::LiteralType   XMLAbstractDoubleFloat::getType() const
215{
216    return fType;
217}
218
219XERCES_CPP_NAMESPACE_END
220
221#endif
Note: See TracBrowser for help on using the repository browser.