source: icXML/icXML-devel/src/xercesc/validators/datatype/DatatypeValidator.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: 15.2 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: DatatypeValidator.cpp 555320 2007-07-11 16:05:13Z amassari $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include <xercesc/validators/datatype/DatatypeValidator.hpp>
27#include <xercesc/framework/MemoryManager.hpp>
28
29//since we need to dynamically created each and every derivatives
30//during deserialization by XSerializeEngine>>Derivative, we got
31//to include all hpp
32
33#include <xercesc/validators/datatype/StringDatatypeValidator.hpp>
34#include <xercesc/validators/datatype/AnyURIDatatypeValidator.hpp>
35#include <icxercesc/validators/datatype/QNameDatatypeValidator.hpp>
36#include <xercesc/validators/datatype/NameDatatypeValidator.hpp>
37#include <xercesc/validators/datatype/NCNameDatatypeValidator.hpp>
38#include <xercesc/validators/datatype/BooleanDatatypeValidator.hpp>
39#include <xercesc/validators/datatype/FloatDatatypeValidator.hpp>
40#include <xercesc/validators/datatype/DoubleDatatypeValidator.hpp>
41#include <xercesc/validators/datatype/DecimalDatatypeValidator.hpp>
42#include <xercesc/validators/datatype/HexBinaryDatatypeValidator.hpp>
43#include <xercesc/validators/datatype/Base64BinaryDatatypeValidator.hpp>
44#include <xercesc/validators/datatype/DurationDatatypeValidator.hpp>
45#include <xercesc/validators/datatype/DateTimeDatatypeValidator.hpp>
46#include <xercesc/validators/datatype/DateDatatypeValidator.hpp>
47#include <xercesc/validators/datatype/TimeDatatypeValidator.hpp>
48#include <xercesc/validators/datatype/MonthDayDatatypeValidator.hpp>
49#include <xercesc/validators/datatype/YearMonthDatatypeValidator.hpp>
50#include <xercesc/validators/datatype/YearDatatypeValidator.hpp>
51#include <xercesc/validators/datatype/MonthDatatypeValidator.hpp>
52#include <xercesc/validators/datatype/DayDatatypeValidator.hpp>
53#include <xercesc/validators/datatype/IDDatatypeValidator.hpp>
54#include <xercesc/validators/datatype/IDREFDatatypeValidator.hpp>
55#include <xercesc/validators/datatype/ENTITYDatatypeValidator.hpp>
56#include <xercesc/validators/datatype/NOTATIONDatatypeValidator.hpp>
57#include <xercesc/validators/datatype/ListDatatypeValidator.hpp>
58#include <xercesc/validators/datatype/UnionDatatypeValidator.hpp>
59#include <xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.hpp>
60
61#include <xercesc/internal/XTemplateSerializer.hpp>
62
63XERCES_CPP_NAMESPACE_BEGIN
64
65static const int DV_BUILTIN = -1;
66static const int DV_NORMAL  = -2;
67static const int DV_ZERO    = -3;
68
69static const int TYPENAME_ZERO    = -1;
70static const int TYPENAME_S4S     = -2;
71static const int TYPENAME_NORMAL  = -3;
72
73// ---------------------------------------------------------------------------
74//  DatatypeValidator: Constructors and Destructor
75// ---------------------------------------------------------------------------
76DatatypeValidator::DatatypeValidator(DatatypeValidator* const baseValidator,
77                                     RefHashTableOf<KVStringPair>* const facets,
78                                     const int finalSet,
79                                     const ValidatorType type,
80                                     MemoryManager* const manager)
81    : fAnonymous(false)
82    , fFinite(false)
83    , fBounded(false)
84    , fNumeric(false)
85    , fWhiteSpace(COLLAPSE)
86    , fFinalSet(finalSet)
87    , fFacetsDefined(0)
88    , fFixed(0)
89    , fType(type)
90    , fOrdered(XSSimpleTypeDefinition::ORDERED_FALSE)
91    , fBaseValidator(baseValidator)
92    , fFacets(facets)
93    , fPattern(0)
94    , fRegex(0)
95    , fTypeName(0)
96    , fTypeLocalName(XMLUni::fgZeroLenString)
97    , fTypeUri(XMLUni::fgZeroLenString)
98    , fMemoryManager(manager)
99{
100}
101
102DatatypeValidator::~DatatypeValidator()
103{
104        cleanUp();
105}
106
107const XMLCh* DatatypeValidator::getWSstring(const short theType) const
108{
109    switch (theType)
110    {
111    case PRESERVE:
112         return SchemaSymbols::fgWS_PRESERVE;
113    case REPLACE:
114         return SchemaSymbols::fgWS_REPLACE;
115    case COLLAPSE:
116         return SchemaSymbols::fgWS_COLLAPSE;
117    default:
118         return SchemaSymbols::fgWS_PRESERVE;
119    }
120
121}
122
123void DatatypeValidator::setTypeName(const XMLCh* const name, const XMLCh* const uri)
124{
125    if (fTypeName) {
126
127        fMemoryManager->deallocate(fTypeName);
128        fTypeName = 0;
129    }
130
131    if (name || uri) {
132
133        XMLSize_t nameLen = XMLString::stringLen(name);
134        XMLSize_t uriLen = XMLString::stringLen(uri);
135
136        fTypeName = (XMLCh*) fMemoryManager->allocate
137        (
138            (nameLen + uriLen + 2)*sizeof(XMLCh)
139        );
140        fTypeUri = fTypeName;
141        fTypeLocalName = &fTypeName[uriLen+1];
142
143        if (uri)
144                        XMLString::moveChars(fTypeName, uri, uriLen+1);
145        else
146                        fTypeName[0] = chNull;
147
148        if (name)
149            XMLString::moveChars(&fTypeName[uriLen+1], name, nameLen+1);
150        else
151            fTypeName[uriLen+1] = chNull;
152    }
153    else
154    {
155        fTypeUri = fTypeLocalName = XMLUni::fgZeroLenString;
156    }
157}
158
159void DatatypeValidator::setTypeName(const XMLCh* const typeName)
160{
161    if (fTypeName)
162    {
163        fMemoryManager->deallocate(fTypeName);
164        fTypeName = 0;
165    }
166
167    if (typeName)
168    {
169        XMLSize_t nameLen = XMLString::stringLen(typeName);
170        int commaOffset = XMLString::indexOf(typeName, chComma);
171
172        fTypeName = (XMLCh*) fMemoryManager->allocate
173        (
174            (nameLen + 1) * sizeof(XMLCh)
175        );
176            XMLString::moveChars(fTypeName, typeName, nameLen+1);
177
178        if ( commaOffset == -1) {
179            fTypeUri = SchemaSymbols::fgURI_SCHEMAFORSCHEMA;
180            fTypeLocalName = fTypeName;
181        }
182        else {
183            fTypeUri = fTypeName;
184            fTypeLocalName = &fTypeName[commaOffset+1];
185            fTypeName[commaOffset] = chNull;
186        }
187    }
188    else
189    {
190        fTypeUri = fTypeLocalName = XMLUni::fgZeroLenString;
191    }
192}
193
194// ---------------------------------------------------------------------------
195//  DatatypeValidator: CleanUp methods
196// ---------------------------------------------------------------------------
197void DatatypeValidator::cleanUp() {
198
199        delete fFacets;
200    delete fRegex;
201    if (fPattern)
202        fMemoryManager->deallocate(fPattern);//delete [] fPattern;
203    if (fTypeName)
204        fMemoryManager->deallocate(fTypeName);
205}
206
207/***
208 * Support for Serialization/De-serialization
209 ***/
210
211IMPL_XSERIALIZABLE_NOCREATE(DatatypeValidator)
212
213void DatatypeValidator::serialize(XSerializeEngine& serEng)
214{
215
216    if (serEng.isStoring())
217    {
218        serEng<<fAnonymous;
219        serEng<<fFinite;
220        serEng<<fBounded;
221        serEng<<fNumeric;
222
223        serEng<<fWhiteSpace;
224        serEng<<fFinalSet;
225        serEng<<fFacetsDefined;
226        serEng<<fFixed;
227
228        serEng<<(int)fType;
229        serEng<<(int)fOrdered;
230
231        storeDV(serEng, fBaseValidator);
232
233        /***
234         *  Serialize RefHashTableOf<KVStringPair>
235         ***/
236        XTemplateSerializer::storeObject(fFacets, serEng);
237
238        serEng.writeString(fPattern);
239
240        if (fTypeUri==XMLUni::fgZeroLenString)
241        {
242            serEng<<TYPENAME_ZERO;
243        }
244        else if (fTypeUri == SchemaSymbols::fgURI_SCHEMAFORSCHEMA)
245        {
246            serEng<<TYPENAME_S4S;
247            serEng.writeString(fTypeLocalName);
248        }
249        else
250        {       
251            serEng<<TYPENAME_NORMAL;
252            serEng.writeString(fTypeLocalName);
253            serEng.writeString(fTypeUri);
254        }
255
256        /***
257         * don't serialize
258         *       fRegex
259         ***/   
260    }
261    else
262    {
263        serEng>>fAnonymous;
264        serEng>>fFinite;
265        serEng>>fBounded;
266        serEng>>fNumeric;
267
268        serEng>>fWhiteSpace;
269        serEng>>fFinalSet;
270        serEng>>fFacetsDefined;
271        serEng>>fFixed;
272
273        int type;
274        serEng>>type;
275        fType=(ValidatorType)type;
276
277        serEng>>type;
278        fOrdered = (XSSimpleTypeDefinition::ORDERING)type;
279
280
281        fBaseValidator = loadDV(serEng);
282
283        /***
284         *
285         *  Deserialize RefHashTableOf<KVStringPair>
286         *
287         ***/
288        XTemplateSerializer::loadObject(&fFacets, 29, true, serEng);
289        serEng.readString(fPattern);       
290
291        /***
292         *   Recreate through setTypeName()
293         *       fTypeName
294         ***/
295
296        int flag;
297        serEng>>flag;
298
299        if ( TYPENAME_ZERO == flag )
300        {
301            setTypeName(0);
302        }
303        else if ( TYPENAME_S4S == flag )
304        {
305            XMLCh* typeLocalName;
306            serEng.readString(typeLocalName);
307            ArrayJanitor<XMLCh> janName(typeLocalName, fMemoryManager);
308
309            setTypeName(typeLocalName);
310        }
311        else // TYPENAME_NORMAL
312        {
313            XMLCh* typeLocalName;
314            serEng.readString(typeLocalName);
315            ArrayJanitor<XMLCh> janName(typeLocalName, fMemoryManager);
316
317            XMLCh* typeUri;
318            serEng.readString(typeUri);
319            ArrayJanitor<XMLCh> janUri(typeUri, fMemoryManager);
320
321            setTypeName(typeLocalName, typeUri);
322        }
323
324        /***
325         * don't serialize fRegex
326         ***/
327        fRegex = new (fMemoryManager) RegularExpression(fPattern, SchemaSymbols::fgRegEx_XOption, fMemoryManager);
328
329    }
330
331}
332
333/***
334 *
335 *  When deserialized, we need to know, exactly what
336 *  validator was serialized here.
337 *
338 *  Design Issue:
339 *   
340 *    This extra type information is only necessary when
341 *  we need to create and deserialize an DatatypeValidator
342 *  derivative by operator >>, but not by object.serialize().
343 *  Therefore it is appropriate to save this type info by
344 *  hosting object rather than by derivative.serialize().
345 *
346 *
347 ***/
348void DatatypeValidator::storeDV(XSerializeEngine&        serEng
349                              , DatatypeValidator* const dv)
350{
351    if (dv)
352    {
353        //builtIndv
354        if (dv == DatatypeValidatorFactory::getBuiltInRegistry()->get(dv->getTypeLocalName()))
355        {
356            serEng<<DV_BUILTIN;
357            serEng.writeString(dv->getTypeLocalName());
358        }
359        else
360        {
361            serEng<<DV_NORMAL;
362            serEng<<(int) dv->getType();
363            serEng<<dv;
364        }
365    }
366    else
367    {
368        serEng<<DV_ZERO;
369    }
370
371}
372
373DatatypeValidator* DatatypeValidator::loadDV(XSerializeEngine& serEng)
374{
375
376    int flag;
377    serEng>>flag;
378
379    if (DV_BUILTIN == flag)
380    {
381        XMLCh* dvName;
382        serEng.readString(dvName);
383        ArrayJanitor<XMLCh> janName(dvName, serEng.getMemoryManager());
384
385        return DatatypeValidatorFactory::getBuiltInRegistry()->get(dvName);
386    }
387    else if (DV_ZERO == flag)
388    {
389        return 0;
390    }
391
392    int type;
393    serEng>>type;
394
395    switch((ValidatorType)type)
396    {
397    case String:
398        StringDatatypeValidator* stringdv;
399        serEng>>stringdv;
400        return stringdv;       
401    case AnyURI:
402        AnyURIDatatypeValidator* anyuridv;
403        serEng>>anyuridv;
404        return anyuridv;       
405    case QName:
406        QNameDatatypeValidator* qnamedv;
407        serEng>>qnamedv;
408        return qnamedv;       
409    case Name:
410        NameDatatypeValidator* namedv;
411        serEng>>namedv;
412        return namedv;       
413    case NCName: 
414        NCNameDatatypeValidator* ncnamedv;
415        serEng>>ncnamedv;
416        return ncnamedv;       
417    case Boolean:
418        BooleanDatatypeValidator* booleandv;
419        serEng>>booleandv;
420        return booleandv;       
421    case Float:
422        FloatDatatypeValidator* floatdv;
423        serEng>>floatdv;
424        return floatdv;       
425    case Double:
426        DoubleDatatypeValidator* doubledv;
427        serEng>>doubledv;
428        return doubledv;       
429    case Decimal:
430        DecimalDatatypeValidator* decimaldv;
431        serEng>>decimaldv;
432        return decimaldv;       
433    case HexBinary: 
434        HexBinaryDatatypeValidator* hexbinarydv;
435        serEng>>hexbinarydv;
436        return hexbinarydv;       
437    case Base64Binary:
438        Base64BinaryDatatypeValidator* base64binarydv;
439        serEng>>base64binarydv;
440        return base64binarydv;     
441    case Duration:     
442        DurationDatatypeValidator* durationdv;
443        serEng>>durationdv;
444        return durationdv;
445    case DateTime:       
446        DateTimeDatatypeValidator* datetimedv;
447        serEng>>datetimedv;
448        return datetimedv; 
449    case Date:         
450        DateDatatypeValidator* datedv;
451        serEng>>datedv;
452        return datedv;
453    case Time:         
454        TimeDatatypeValidator* timedv;
455        serEng>>timedv;
456        return timedv;
457    case MonthDay:     
458        MonthDayDatatypeValidator* monthdaydv;
459        serEng>>monthdaydv;
460        return monthdaydv;
461    case YearMonth:     
462        YearMonthDatatypeValidator* yearmonthdv;
463        serEng>>yearmonthdv;
464        return yearmonthdv;
465    case Year:         
466        YearDatatypeValidator* yeardv;
467        serEng>>yeardv;
468        return yeardv;
469    case Month:       
470        MonthDatatypeValidator* monthdv;
471        serEng>>monthdv;
472        return monthdv;
473    case Day:           
474        DayDatatypeValidator* daydv;
475        serEng>>daydv;
476        return daydv;
477    case ID:           
478        IDDatatypeValidator* iddv;
479        serEng>>iddv;
480        return iddv;
481    case IDREF:         
482        IDREFDatatypeValidator* idrefdv;
483        serEng>>idrefdv;
484        return idrefdv;
485    case ENTITY:       
486        ENTITYDatatypeValidator* entitydv;
487        serEng>>entitydv;
488        return entitydv;
489    case NOTATION:     
490        NOTATIONDatatypeValidator* notationdv;
491        serEng>>notationdv;
492        return notationdv;
493    case List:         
494        ListDatatypeValidator* listdv;
495        serEng>>listdv;
496        return listdv;
497    case Union:         
498        UnionDatatypeValidator* uniondv;
499        serEng>>uniondv;
500        return uniondv;
501    case AnySimpleType: 
502        AnySimpleTypeDatatypeValidator* anysimpletypedv;
503        serEng>>anysimpletypedv;
504        return anysimpletypedv;
505    case UnKnown:
506        return 0;
507    default: //we treat this same as UnKnown
508        return 0;
509    }
510
511}
512
513/**
514 * Canonical Representation
515 *
516 */
517const XMLCh* DatatypeValidator::getCanonicalRepresentation(const XMLCh*         const rawData
518                                                          ,      MemoryManager* const memMgr
519                                                          ,      bool                 toValidate) const
520{
521    MemoryManager* toUse = memMgr? memMgr : fMemoryManager;
522
523    if (toValidate)
524    {
525        DatatypeValidator *temp = (DatatypeValidator*) this;
526
527        try
528        {
529            temp->validate(rawData, 0, toUse);   
530        }
531        catch (...)
532        {
533            return 0;
534        }
535    }
536
537    return XMLString::replicate(rawData, toUse);
538}
539
540
541XERCES_CPP_NAMESPACE_END
542
543/**
544  * End of file DatatypeValidator.cpp
545  */
546
Note: See TracBrowser for help on using the repository browser.