source: icXML/icXML-devel/src/xercesc/validators/datatype/FloatDatatypeValidator.cpp @ 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: 8.7 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: FloatDatatypeValidator.cpp 676911 2008-07-15 13:27:32Z amassari $
20 */
21
22// ---------------------------------------------------------------------------
23//  Includes
24// ---------------------------------------------------------------------------
25#include <xercesc/validators/datatype/FloatDatatypeValidator.hpp>
26#include <xercesc/validators/schema/SchemaSymbols.hpp>
27#include <xercesc/validators/datatype/InvalidDatatypeFacetException.hpp>
28#include <xercesc/validators/datatype/InvalidDatatypeValueException.hpp>
29
30XERCES_CPP_NAMESPACE_BEGIN
31
32// ---------------------------------------------------------------------------
33//  Constructors and Destructor
34// ---------------------------------------------------------------------------
35FloatDatatypeValidator::FloatDatatypeValidator(MemoryManager* const manager)
36:AbstractNumericValidator(0, 0, 0, DatatypeValidator::Float, manager)
37{
38    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
39    setBounded(true);
40    setFinite(true);
41    setNumeric(true);
42}
43
44FloatDatatypeValidator::FloatDatatypeValidator(
45                          DatatypeValidator*            const baseValidator
46                        , RefHashTableOf<KVStringPair>* const facets
47                        , RefArrayVectorOf<XMLCh>*      const enums
48                        , const int                           finalSet
49                        , MemoryManager* const                manager)
50:AbstractNumericValidator(baseValidator, facets, finalSet, DatatypeValidator::Float, manager)
51{
52    init(enums, manager);
53}
54
55FloatDatatypeValidator::~FloatDatatypeValidator()
56{}
57
58// -----------------------------------------------------------------------
59// Compare methods
60// -----------------------------------------------------------------------
61int FloatDatatypeValidator::compare(const XMLCh* const lValue
62                                  , const XMLCh* const rValue
63                                  , MemoryManager* const manager)
64{
65    XMLFloat lObj(lValue, manager);
66    XMLFloat rObj(rValue, manager);
67
68    return compareValues(&lObj, &rObj);
69}
70
71DatatypeValidator* FloatDatatypeValidator::newInstance
72(
73      RefHashTableOf<KVStringPair>* const facets
74    , RefArrayVectorOf<XMLCh>* const      enums
75    , const int                           finalSet
76    , MemoryManager* const                manager
77)
78{
79    return (DatatypeValidator*) new (manager) FloatDatatypeValidator(this, facets, enums, finalSet, manager);
80}
81
82// -----------------------------------------------------------------------
83// ctor provided to be used by derived classes
84// -----------------------------------------------------------------------
85FloatDatatypeValidator::FloatDatatypeValidator(DatatypeValidator*            const baseValidator
86                                             , RefHashTableOf<KVStringPair>* const facets
87                                             , const int                           finalSet
88                                             , const ValidatorType                 type
89                                             , MemoryManager* const                manager)
90:AbstractNumericValidator(baseValidator, facets, finalSet, type, manager)
91{
92    //do not invoke init here !!!
93}
94
95int  FloatDatatypeValidator::compareValues(const XMLNumber* const lValue
96                                         , const XMLNumber* const rValue)
97{
98    return XMLFloat::compareValues((XMLFloat*) lValue, (XMLFloat*) rValue);
99}
100
101void  FloatDatatypeValidator::setMaxInclusive(const XMLCh* const value)
102{
103    fMaxInclusive = new (fMemoryManager) XMLFloat(value, fMemoryManager);
104}
105
106void  FloatDatatypeValidator::setMaxExclusive(const XMLCh* const value)
107{
108    fMaxExclusive = new (fMemoryManager) XMLFloat(value, fMemoryManager);
109}
110
111void  FloatDatatypeValidator::setMinInclusive(const XMLCh* const value)
112{
113    fMinInclusive = new (fMemoryManager) XMLFloat(value, fMemoryManager);
114}
115
116void  FloatDatatypeValidator::setMinExclusive(const XMLCh* const value)
117{
118    fMinExclusive = new (fMemoryManager) XMLFloat(value, fMemoryManager);
119}
120
121void  FloatDatatypeValidator::setEnumeration(MemoryManager* const manager)
122{
123    // check 4.3.5.c0 must: enumeration values from the value space of base
124    //
125    // 1. shall be from base value space
126    // 2. shall be from current value space as well ( shall go through boundsCheck() )
127    //
128    if (!fStrEnumeration)
129        return;
130
131    XMLSize_t i = 0;
132    XMLSize_t enumLength = fStrEnumeration->size();
133
134    FloatDatatypeValidator *numBase = (FloatDatatypeValidator*) getBaseValidator();
135    if (numBase)
136    {
137        try
138        {
139            for ( i = 0; i < enumLength; i++)
140            {
141                numBase->checkContent(fStrEnumeration->elementAt(i), (ValidationContext*)0, false, manager);
142            }
143        }
144        catch (XMLException&)
145        {
146            ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
147                , XMLExcepts::FACET_enum_base
148                , fStrEnumeration->elementAt(i)
149                , manager);
150
151        }
152    }
153#if 0
154// spec says that only base has to checkContent         
155    // We put the this->checkContent in a separate loop
156    // to not block original message with in that method.
157    //
158    for ( i = 0; i < enumLength; i++)
159    {
160        checkContent(fStrEnumeration->elementAt(i), (ValidationContext*)0, false, manager);
161    }
162#endif   
163
164    fEnumeration = new (fMemoryManager) RefVectorOf<XMLNumber>(enumLength, true,  fMemoryManager);
165    fEnumerationInherited = false;
166
167    for ( i = 0; i < enumLength; i++)
168    {
169        fEnumeration->insertElementAt(new (fMemoryManager) XMLFloat(fStrEnumeration->elementAt(i), fMemoryManager), i);
170    }
171}
172
173// -----------------------------------------------------------------------
174// Abstract interface from AbstractNumericValidator
175// -----------------------------------------------------------------------
176void FloatDatatypeValidator::checkContent(const XMLCh*             const content
177                                         ,      ValidationContext* const context
178                                         ,      bool                     asBase
179                                         ,      MemoryManager*     const manager)
180{
181
182    //validate against base validator if any
183    FloatDatatypeValidator *pBase = (FloatDatatypeValidator*) this->getBaseValidator();
184    if (pBase)
185        pBase->checkContent(content, context, true, manager);
186
187    // we check pattern first
188    if ( (getFacetsDefined() & DatatypeValidator::FACET_PATTERN ) != 0 )
189    {
190        if (getRegex()->matches(content, manager) ==false)
191        {
192            ThrowXMLwithMemMgr2(InvalidDatatypeValueException
193                    , XMLExcepts::VALUE_NotMatch_Pattern
194                    , content
195                    , getPattern()
196                    , manager);
197        }
198    }
199
200    // if this is a base validator, we only need to check pattern facet
201    // all other facet were inherited by the derived type
202    if (asBase)
203        return;
204
205    XMLFloat theValue(content, manager);
206    XMLFloat *theData = &theValue;
207
208    if (getEnumeration() != 0)
209    {
210        XMLSize_t i=0;
211        XMLSize_t enumLength = getEnumeration()->size();
212        for ( ; i < enumLength; i++)
213        {
214            if (compareValues(theData, (XMLFloat*) getEnumeration()->elementAt(i))==0)
215                break;
216        }
217
218        if (i == enumLength)
219            ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, content, manager);
220    }
221
222    boundsCheck(theData, manager);
223}
224
225/***
226 * Support for Serialization/De-serialization
227 ***/
228
229IMPL_XSERIALIZABLE_TOCREATE(FloatDatatypeValidator)
230
231void FloatDatatypeValidator::serialize(XSerializeEngine& serEng)
232{
233    /***
234     * Note:
235     *
236     *     During storing, we need write the specific number
237     *     type info before calling base::serialize().
238     *
239     *     While loading, we do nothing here
240     ***/
241
242    if (serEng.isStoring())
243    {
244        serEng<<(int) (XMLNumber::Float);
245    }
246
247    AbstractNumericValidator::serialize(serEng);
248
249}
250
251XERCES_CPP_NAMESPACE_END
252
253/**
254  * End of file FloatDatatypeValidator::cpp
255  */
Note: See TracBrowser for help on using the repository browser.