source: icXML/icXML-devel/src/icxercesc/validators/datatype/DatatypeValidatorFactory.cpp @ 2720

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

Initial check-in of icXML 0.8 source files

File size: 36.3 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: DatatypeValidatorFactory.cpp 932887 2010-04-11 13:04:59Z borisk $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include <xercesc/validators/datatype/DatatypeValidatorFactory.hpp>
27#include <xercesc/validators/schema/SchemaSymbols.hpp>
28#include <xercesc/util/XMLUniDefs.hpp>
29#include <xercesc/util/Janitor.hpp>
30#include <xercesc/validators/datatype/StringDatatypeValidator.hpp>
31#include <xercesc/validators/datatype/BooleanDatatypeValidator.hpp>
32#include <xercesc/validators/datatype/DecimalDatatypeValidator.hpp>
33#include <xercesc/validators/datatype/HexBinaryDatatypeValidator.hpp>
34#include <xercesc/validators/datatype/Base64BinaryDatatypeValidator.hpp>
35#include <xercesc/validators/datatype/IDDatatypeValidator.hpp>
36#include <xercesc/validators/datatype/IDREFDatatypeValidator.hpp>
37#include <xercesc/validators/datatype/NOTATIONDatatypeValidator.hpp>
38#include <xercesc/validators/datatype/ENTITYDatatypeValidator.hpp>
39#include <xercesc/validators/datatype/QNameDatatypeValidator.hpp>
40#include <xercesc/validators/datatype/NameDatatypeValidator.hpp>
41#include <xercesc/validators/datatype/NCNameDatatypeValidator.hpp>
42#include <xercesc/validators/datatype/ListDatatypeValidator.hpp>
43#include <xercesc/validators/datatype/UnionDatatypeValidator.hpp>
44#include <xercesc/validators/datatype/DoubleDatatypeValidator.hpp>
45#include <xercesc/validators/datatype/FloatDatatypeValidator.hpp>
46#include <xercesc/validators/datatype/AnyURIDatatypeValidator.hpp>
47#include <xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.hpp>
48#include <xercesc/validators/datatype/DateTimeDatatypeValidator.hpp>
49#include <xercesc/validators/datatype/DateDatatypeValidator.hpp>
50#include <xercesc/validators/datatype/TimeDatatypeValidator.hpp>
51#include <xercesc/validators/datatype/DayDatatypeValidator.hpp>
52#include <xercesc/validators/datatype/MonthDatatypeValidator.hpp>
53#include <xercesc/validators/datatype/MonthDayDatatypeValidator.hpp>
54#include <xercesc/validators/datatype/YearDatatypeValidator.hpp>
55#include <xercesc/validators/datatype/YearMonthDatatypeValidator.hpp>
56#include <xercesc/validators/datatype/DurationDatatypeValidator.hpp>
57#include <xercesc/util/PlatformUtils.hpp>
58#include <xercesc/util/XMLInitializer.hpp>
59
60#include <xercesc/internal/XTemplateSerializer.hpp>
61
62XERCES_CPP_NAMESPACE_BEGIN
63
64
65// ---------------------------------------------------------------------------
66//  DatatypeValidatorFactory: Local const data
67// ---------------------------------------------------------------------------
68const XMLCh fgTokPattern[] =
69{
70    chBackSlash, chLatin_c, chPlus, chNull
71};
72
73//E2-43
74//[+\-]?[0-9]+
75const XMLCh fgIntegerPattern[] =
76{
77    chOpenSquare, chPlus, chBackSlash, chDash, chCloseSquare, chQuestion,
78    chOpenSquare, chDigit_0, chDash, chDigit_9, chCloseSquare, chPlus, chNull
79};
80
81//"\\i\\c*"
82const XMLCh fgNamePattern[] =
83{
84    chBackSlash, chLatin_i, chBackSlash, chLatin_c, chAsterisk, chNull
85};
86
87//"[\\i-[:]][\\c-[:]]*"
88const XMLCh fgNCNamePattern[] =
89{
90    chOpenSquare, chBackSlash, chLatin_i, chDash, chOpenSquare, chColon, chCloseSquare,
91    chCloseSquare, chOpenSquare, chBackSlash, chLatin_c, chDash, chOpenSquare,
92    chColon, chCloseSquare, chCloseSquare, chAsterisk, chNull
93};
94
95
96
97const XMLCh fgP0Y[] =
98{
99    chLatin_P, chDigit_0, chLatin_Y, chNull
100};
101
102const XMLCh fgP1Y[] =
103{
104    chLatin_P, chDigit_1, chLatin_Y, chNull
105};
106
107const XMLCh fgP100Y[] =
108{
109    chLatin_P, chDigit_1, chDigit_0, chDigit_0, chLatin_Y, chNull
110};
111
112const XMLCh fgPT24H[] =
113{
114    chLatin_P, chLatin_T, chDigit_2, chDigit_4, chLatin_H, chNull
115};
116
117const XMLCh fgP1M[] =
118{
119    chLatin_P, chDigit_1, chLatin_M, chNull
120};
121
122// ---------------------------------------------------------------------------
123//  DatatypeValidatorFactory: Static member data
124// ---------------------------------------------------------------------------
125RefHashTableOf<DatatypeValidator>* DatatypeValidatorFactory::fBuiltInRegistry = 0;
126RefHashTableOf<XMLCanRepGroup, PtrHasher>* DatatypeValidatorFactory::fCanRepRegistry = 0;
127
128void XMLInitializer::initializeDatatypeValidatorFactory()
129{
130    // @@ This is ugly. Need to make expandRegistryToFullSchemaSet
131    // static.
132    //
133    DatatypeValidatorFactory *dvFactory = new DatatypeValidatorFactory();
134    if (dvFactory) {
135        dvFactory->expandRegistryToFullSchemaSet();
136        delete dvFactory;
137    }
138}
139
140void XMLInitializer::terminateDatatypeValidatorFactory()
141{
142    delete DatatypeValidatorFactory::fBuiltInRegistry;
143    DatatypeValidatorFactory::fBuiltInRegistry = 0;
144
145    delete DatatypeValidatorFactory::fCanRepRegistry;
146    DatatypeValidatorFactory::fCanRepRegistry = 0;
147}
148
149// ---------------------------------------------------------------------------
150//  DatatypeValidatorFactory: Constructors and Destructor
151// ---------------------------------------------------------------------------
152DatatypeValidatorFactory::DatatypeValidatorFactory(MemoryManager* const manager)
153    : fUserDefinedRegistry(0)
154    , fMemoryManager(manager)
155{
156}
157
158DatatypeValidatorFactory::~DatatypeValidatorFactory()
159{
160    cleanUp();
161}
162
163
164// ---------------------------------------------------------------------------
165//  DatatypeValidatorFactory: Reset methods
166// ---------------------------------------------------------------------------
167void DatatypeValidatorFactory::resetRegistry() {
168
169    if (fUserDefinedRegistry != 0) {
170        fUserDefinedRegistry->removeAll();
171    }
172}
173
174// ---------------------------------------------------------------------------
175//  DatatypeValidatorFactory: Registry initialization methods
176// ---------------------------------------------------------------------------
177void DatatypeValidatorFactory::expandRegistryToFullSchemaSet()
178{
179    //Initialize common Schema/DTD Datatype validator set
180    fBuiltInRegistry = new RefHashTableOf<DatatypeValidator>(29);
181
182    DatatypeValidator *dv = new StringDatatypeValidator();
183    dv->setTypeName(SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
184    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_STRING, dv);
185
186    dv = new NOTATIONDatatypeValidator();
187    dv->setTypeName(XMLUni::fgNotationString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
188    fBuiltInRegistry->put((void*) XMLUni::fgNotationString, dv);
189
190    dv = new AnySimpleTypeDatatypeValidator();
191    dv->setTypeName(SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
192    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYSIMPLETYPE, dv);
193
194    dv = new BooleanDatatypeValidator();
195    dv->setTypeName(SchemaSymbols::fgDT_BOOLEAN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
196    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BOOLEAN, dv);
197
198    dv = new DecimalDatatypeValidator();
199    dv->setTypeName(SchemaSymbols::fgDT_DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
200    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DECIMAL, dv);
201
202    dv = new HexBinaryDatatypeValidator();
203    dv->setTypeName(SchemaSymbols::fgDT_HEXBINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
204    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_HEXBINARY, dv);
205
206    dv = new Base64BinaryDatatypeValidator();
207    dv->setTypeName(SchemaSymbols::fgDT_BASE64BINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
208    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BASE64BINARY, dv);
209
210    dv = new DoubleDatatypeValidator();
211    dv->setTypeName(SchemaSymbols::fgDT_DOUBLE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
212    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DOUBLE, dv);
213
214    dv = new FloatDatatypeValidator();
215    dv->setTypeName(SchemaSymbols::fgDT_FLOAT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
216    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_FLOAT, dv);
217
218    dv = new AnyURIDatatypeValidator();
219    dv->setTypeName(SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
220    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYURI, dv);
221
222    dv = new QNameDatatypeValidator();
223    dv->setTypeName(SchemaSymbols::fgDT_QNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
224    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_QNAME, dv);
225
226    dv = new DateTimeDatatypeValidator();
227    dv->setTypeName(SchemaSymbols::fgDT_DATETIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
228    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATETIME, dv);
229
230    dv = new DateDatatypeValidator();
231    dv->setTypeName(SchemaSymbols::fgDT_DATE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
232    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATE, dv);
233
234    dv = new TimeDatatypeValidator();
235    dv->setTypeName(SchemaSymbols::fgDT_TIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
236    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_TIME, dv);
237
238    dv = new DayDatatypeValidator();
239    dv->setTypeName(SchemaSymbols::fgDT_DAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
240    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DAY, dv);
241
242    dv = new MonthDatatypeValidator();
243    dv->setTypeName(SchemaSymbols::fgDT_MONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
244    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTH, dv);
245
246    dv = new MonthDayDatatypeValidator();
247    dv->setTypeName(SchemaSymbols::fgDT_MONTHDAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
248    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTHDAY, dv);
249
250    dv = new YearDatatypeValidator();
251    dv->setTypeName(SchemaSymbols::fgDT_YEAR, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
252    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEAR, dv);
253
254    dv = new YearMonthDatatypeValidator();
255    dv->setTypeName(SchemaSymbols::fgDT_YEARMONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
256    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEARMONTH, dv);
257
258    dv = new DurationDatatypeValidator();
259    dv->setTypeName(SchemaSymbols::fgDT_DURATION, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
260    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DURATION, dv);
261
262    // REVISIT
263    // We are creating a lot of Hashtables for the facets of the different
264    // validators. It's better to have some kind of a memory pool and ask
265    // the pool to give us a new instance of the hashtable.
266    RefHashTableOf<KVStringPair>* facets = new RefHashTableOf<KVStringPair>(3);
267
268    // Create 'normalizedString' datatype validator
269    facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
270                new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_REPLACE));
271
272    createDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING,
273                            getDatatypeValidator(SchemaSymbols::fgDT_STRING),
274                            facets, 0, false, 0, false);
275
276    // Create 'token' datatype validator
277    facets = new RefHashTableOf<KVStringPair>(3);
278    facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
279                new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
280
281    createDatatypeValidator(SchemaSymbols::fgDT_TOKEN,
282                            getDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING),
283                            facets, 0, false, 0, false);
284
285
286    dv = new NameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_TOKEN), 0, 0, 0);
287    dv->setTypeName(SchemaSymbols::fgDT_NAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
288    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NAME, dv);
289
290
291    dv = new NCNameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NAME), 0, 0, 0);
292    dv->setTypeName(SchemaSymbols::fgDT_NCNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
293    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NCNAME, dv);
294
295    // Create 'NMTOKEN' datatype validator
296    facets = new RefHashTableOf<KVStringPair>(3);
297
298    facets->put((void*) SchemaSymbols::fgELT_PATTERN ,
299                new KVStringPair(SchemaSymbols::fgELT_PATTERN,fgTokPattern));
300    facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
301                new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
302
303    DatatypeValidator * temp =
304    createDatatypeValidator(XMLUni::fgNmTokenString,
305                            getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),facets, 0, false, 0, false);
306
307    assert (temp);
308
309    // Create 'NMTOKENS' datatype validator
310    facets = new RefHashTableOf<KVStringPair>(2);
311    facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
312                new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
313
314    temp =
315    createDatatypeValidator(XMLUni::fgNmTokensString,
316                            getDatatypeValidator(XMLUni::fgNmTokenString), facets, 0, true, 0, false);
317
318    assert (temp);
319
320    // Create 'language' datatype validator
321    facets = new RefHashTableOf<KVStringPair>(3);
322
323    facets->put((void*) SchemaSymbols::fgELT_PATTERN,
324                new KVStringPair(SchemaSymbols::fgELT_PATTERN, XMLUni::fgLangPattern));
325
326    createDatatypeValidator(SchemaSymbols::fgDT_LANGUAGE,
327                            getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),
328                            facets, 0, false, 0, false);
329
330    // Create 'integer' datatype validator
331    facets = new RefHashTableOf<KVStringPair>(3);
332
333    facets->put((void*) SchemaSymbols::fgELT_FRACTIONDIGITS,
334                new KVStringPair(SchemaSymbols::fgELT_FRACTIONDIGITS, XMLUni::fgValueZero));
335
336    facets->put((void*) SchemaSymbols::fgELT_PATTERN,
337                new KVStringPair(SchemaSymbols::fgELT_PATTERN, fgIntegerPattern));
338
339    createDatatypeValidator(SchemaSymbols::fgDT_INTEGER,
340                            getDatatypeValidator(SchemaSymbols::fgDT_DECIMAL),
341                            facets, 0, false, 0, false);
342
343    // Create 'nonPositiveInteger' datatype validator
344    facets = new RefHashTableOf<KVStringPair>(2);
345
346    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
347                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgValueZero));
348
349    createDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER,
350                            getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
351                            facets, 0, false, 0, false);
352
353    // Create 'negativeInteger' datatype validator
354    facets = new RefHashTableOf<KVStringPair>(2);
355
356    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
357                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgNegOne));
358
359    createDatatypeValidator(SchemaSymbols::fgDT_NEGATIVEINTEGER,
360                            getDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER),
361                            facets, 0, false, 0, false);
362
363    // Create 'long' datatype validator
364    facets = new RefHashTableOf<KVStringPair>(2);
365
366    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
367                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgLongMaxInc));
368    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
369                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgLongMinInc));
370
371    createDatatypeValidator(SchemaSymbols::fgDT_LONG,
372                            getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
373                            facets, 0, false, 0, false);
374
375    // Create 'int' datatype validator
376    facets = new RefHashTableOf<KVStringPair>(2);
377
378    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
379                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgIntMaxInc));
380    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
381                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgIntMinInc));
382
383    createDatatypeValidator(SchemaSymbols::fgDT_INT,
384                            getDatatypeValidator(SchemaSymbols::fgDT_LONG),
385                            facets, 0, false, 0, false);
386
387    // Create 'short' datatype validator
388    facets = new RefHashTableOf<KVStringPair>(2);
389
390    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
391                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgShortMaxInc));
392    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
393                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgShortMinInc));
394
395    createDatatypeValidator(SchemaSymbols::fgDT_SHORT,
396                            getDatatypeValidator(SchemaSymbols::fgDT_INT),
397                            facets, 0, false, 0 ,false);
398
399    // Create 'byte' datatype validator
400    facets = new RefHashTableOf<KVStringPair>(2);
401
402    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
403                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgByteMaxInc));
404    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
405                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgByteMinInc));
406
407    createDatatypeValidator(SchemaSymbols::fgDT_BYTE,
408                            getDatatypeValidator(SchemaSymbols::fgDT_SHORT),
409                            facets, 0, false, 0, false);
410
411    // Create 'nonNegativeInteger' datatype validator
412    facets = new RefHashTableOf<KVStringPair>(2);
413
414    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
415                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueZero));
416
417    createDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER,
418                            getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
419                            facets, 0, false, 0, false);
420
421    // Create 'unsignedLong' datatype validator
422    facets = new RefHashTableOf<KVStringPair>(2);
423
424    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
425                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgULongMaxInc));
426
427    createDatatypeValidator(SchemaSymbols::fgDT_ULONG,
428                            getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
429                            facets, 0, false, 0, false);
430
431    // Create 'unsignedInt' datatype validator
432    facets = new RefHashTableOf<KVStringPair>(2);
433
434    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
435                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUIntMaxInc));
436
437    createDatatypeValidator(SchemaSymbols::fgDT_UINT,
438                            getDatatypeValidator(SchemaSymbols::fgDT_ULONG),
439                            facets, 0, false, 0, false);
440
441    // Create 'unsignedShort' datatypeValidator
442    facets = new RefHashTableOf<KVStringPair>(2);
443
444    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
445                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUShortMaxInc));
446
447    createDatatypeValidator(SchemaSymbols::fgDT_USHORT,
448                            getDatatypeValidator(SchemaSymbols::fgDT_UINT),
449                            facets, 0, false, 0, false);
450
451    // Create 'unsignedByte' datatype validator
452    facets = new RefHashTableOf<KVStringPair>(2);
453
454    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
455                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUByteMaxInc));
456
457    createDatatypeValidator(SchemaSymbols::fgDT_UBYTE,
458                            getDatatypeValidator(SchemaSymbols::fgDT_USHORT),
459                            facets, 0, false, 0, false);
460
461    // Create 'positiveInteger' datatype validator
462    facets = new RefHashTableOf<KVStringPair>(2);
463
464    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
465                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueOne));
466
467    createDatatypeValidator(SchemaSymbols::fgDT_POSITIVEINTEGER,
468                            getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
469                            facets, 0, false, 0, false);
470
471    // Create 'ID', 'IDREF' and 'ENTITY' datatype validator
472    dv = new IDDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
473    dv->setTypeName(XMLUni::fgIDString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
474    fBuiltInRegistry->put((void*) XMLUni::fgIDString, dv);
475
476    dv = new IDREFDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
477    dv->setTypeName(XMLUni::fgIDRefString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
478    fBuiltInRegistry->put((void*) XMLUni::fgIDRefString, dv);
479
480    dv = new ENTITYDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
481    dv->setTypeName(XMLUni::fgEntityString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
482    fBuiltInRegistry->put((void*) XMLUni::fgEntityString, dv);
483
484    facets = new RefHashTableOf<KVStringPair>(2);
485    facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
486                new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
487
488    // Create 'IDREFS' datatype validator
489    createDatatypeValidator
490      (
491        XMLUni::fgIDRefsString
492        , getDatatypeValidator(XMLUni::fgIDRefString)
493        , facets
494        , 0
495        , true
496        , 0
497        , false
498      );
499
500    facets = new RefHashTableOf<KVStringPair>(2);
501
502    facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
503                new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
504
505    // Create 'ENTITIES' datatype validator
506    createDatatypeValidator
507      (
508        XMLUni::fgEntitiesString
509        , getDatatypeValidator(XMLUni::fgEntityString)
510        , facets
511        , 0
512        , true
513        , 0
514        , false
515      );
516
517    initCanRepRegistory();
518}
519
520
521/***
522 *
523 *   For Decimal-derivated, an instance of DecimalDatatypeValidator
524 *   can be used by the primitive datatype, decimal, or any one of
525 *   the derivated datatypes, such as int, long, unsighed short, just
526 *   name a few, or any user-defined datatypes, which may derivate from
527 *   either the primitive datatype, decimal, or from any one of those
528 *   decimal derivated datatypes, or other user-defined datatypes, which
529 *   in turn, indirectly derivate from decimal or decimal-derived.
530 *
531 *   fCanRepRegisty captures deciaml dv and its derivatives.
532 *
533 ***/
534void DatatypeValidatorFactory::initCanRepRegistory()
535{
536
537     /***
538      * key:  dv
539      * data: XMLCanRepGroup
540      ***/
541     fCanRepRegistry  = new RefHashTableOf<XMLCanRepGroup, PtrHasher>(29, true);
542
543     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_DECIMAL),
544                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal));
545
546     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
547                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
548     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_LONG),
549                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
550     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_INT),
551                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
552     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_SHORT),
553                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
554     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_BYTE),
555                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
556     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
557                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
558     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_POSITIVEINTEGER),
559                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
560
561     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_NEGATIVEINTEGER),
562                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
563     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_ULONG),
564                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
565     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_UINT),
566                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
567     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_USHORT),
568                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
569     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_UBYTE),
570                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
571
572     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER),
573                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_npi));
574}
575
576/***
577 *
578 *   For any dv other than Decimaldv, return String only.
579 *   Later on if support to dv other than Decimaldv arise, we may
580 *   add them fCanRepRegistry during DatatypeValidatorFactory::initCanRepRegistory()
581 *
582 ***/
583XMLCanRepGroup::CanRepGroup DatatypeValidatorFactory::getCanRepGroup(const DatatypeValidator* const dv)
584{
585    if (!dv)
586        return XMLCanRepGroup::String;
587
588    DatatypeValidator *curdv = (DatatypeValidator*) dv;
589
590    while (curdv)
591    {
592        if (fCanRepRegistry->containsKey(curdv))
593            return fCanRepRegistry->get(curdv)->getGroup();
594        else
595            curdv = curdv->getBaseValidator();
596    }
597
598    return XMLCanRepGroup::String;
599}
600
601DatatypeValidator* DatatypeValidatorFactory::getBuiltInBaseValidator(const DatatypeValidator* const dv)
602{
603    DatatypeValidator *curdv = (DatatypeValidator*)dv;
604
605    while (curdv)
606    {
607        if (curdv == getBuiltInRegistry()->get(curdv->getTypeLocalName()))
608            return curdv;
609        else
610            curdv = curdv->getBaseValidator();
611     }
612
613     return 0;
614}
615
616// ---------------------------------------------------------------------------
617//  DatatypeValidatorFactory: factory methods
618// ---------------------------------------------------------------------------
619DatatypeValidator* DatatypeValidatorFactory::createDatatypeValidator
620(
621      const XMLCh* const                  typeName
622    , DatatypeValidator* const            baseValidator
623    , RefHashTableOf<KVStringPair>* const facets
624    , RefArrayVectorOf<XMLCh>* const      enums
625    , const bool                          isDerivedByList
626    , const int                           finalSet
627    , const bool                          isUserDefined
628    , MemoryManager* const                userManager
629)
630{
631
632    assert(typeName);
633
634    if (baseValidator == 0)
635    {
636        if (facets)
637        {
638            Janitor<KVStringPairHashTable> janFacets(facets);
639        }
640
641        if (enums)
642        {
643            Janitor<XMLChRefVector> janEnums(enums);
644        }
645
646        return 0;
647    }
648
649        DatatypeValidator* datatypeValidator = 0;
650    MemoryManager* const manager = (isUserDefined)
651        ? userManager : XMLPlatformUtils::fgMemoryManager;
652
653    if (isDerivedByList) {
654        datatypeValidator = new (manager) ListDatatypeValidator(baseValidator, facets, enums, finalSet, manager);
655
656        // Set PSVI information for Ordered, Numeric, Bounded & Finite
657        datatypeValidator->setOrdered(XSSimpleTypeDefinition::ORDERED_FALSE);
658        datatypeValidator->setNumeric(false);
659        if (facets &&
660             ((facets->get(SchemaSymbols::fgELT_LENGTH) ||
661              (facets->get(SchemaSymbols::fgELT_MINLENGTH) && facets->get(SchemaSymbols::fgELT_MAXLENGTH)))))
662        {
663            datatypeValidator->setBounded(true);
664            datatypeValidator->setFinite(true);
665        }
666        else
667        {
668            datatypeValidator->setBounded(false);
669            datatypeValidator->setFinite(false);
670        }
671    }
672    else {
673
674        if ((baseValidator->getType() != DatatypeValidator::String) && facets) {
675
676            KVStringPair* value = facets->get(SchemaSymbols::fgELT_WHITESPACE);
677
678            if (value != 0) {
679                facets->removeKey(SchemaSymbols::fgELT_WHITESPACE);
680            }
681        }
682
683        datatypeValidator = baseValidator->newInstance
684        (
685            facets
686            , enums
687            , finalSet
688            , manager
689        );
690
691        // Set PSVI information for Ordered, Numeric, Bounded & Finite
692        datatypeValidator->setOrdered(baseValidator->getOrdered());
693        datatypeValidator->setNumeric(baseValidator->getNumeric());
694        RefHashTableOf<KVStringPair>* baseFacets = baseValidator->getFacets();
695        if (facets  &&
696            ((facets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
697              facets->get(SchemaSymbols::fgELT_MINEXCLUSIVE) ||
698              (baseFacets && (baseFacets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
699                              baseFacets->get(SchemaSymbols::fgELT_MINEXCLUSIVE))))) &&
700             (facets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
701              facets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE) ||
702              (baseFacets && ((baseFacets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
703                               baseFacets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE))))))
704        {
705            datatypeValidator->setBounded(true);
706        }
707        else
708        {
709            datatypeValidator->setBounded(false);
710        }
711        if (baseValidator->getFinite())
712        {
713            datatypeValidator->setFinite(true);
714        }
715        else if (!facets)
716        {
717            datatypeValidator->setFinite(false);
718        }
719        else if (facets->get(SchemaSymbols::fgELT_LENGTH) || facets->get(SchemaSymbols::fgELT_MAXLENGTH) ||
720                 facets->get(SchemaSymbols::fgELT_TOTALDIGITS))
721        {
722            datatypeValidator->setFinite(true);
723        }
724        //for efficiency use this instead of rechecking...
725        //else if ((facets->get(SchemaSymbols::fgELT_MININCLUSIVE) || facets->get(SchemaSymbols::fgELT_MINEXCLUSIVE)) &&
726        //         (facets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) || facets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE)))
727        else if (datatypeValidator->getBounded() ||
728                 datatypeValidator->getType() == DatatypeValidator::Date      ||
729                 datatypeValidator->getType() == DatatypeValidator::YearMonth ||
730                 datatypeValidator->getType() == DatatypeValidator::Year      ||
731                 datatypeValidator->getType() == DatatypeValidator::MonthDay  ||
732                 datatypeValidator->getType() == DatatypeValidator::Day       ||
733                 datatypeValidator->getType() == DatatypeValidator::Month)
734        {
735            if (facets->get(SchemaSymbols::fgELT_FRACTIONDIGITS))
736            {
737                datatypeValidator->setFinite(true);
738            }
739            else
740            {
741                datatypeValidator->setFinite(false);
742            }
743        }
744        else
745        {
746            datatypeValidator->setFinite(false);
747        }
748    }
749
750    if (datatypeValidator)
751    {
752        if (isUserDefined)
753        {
754            if (!fUserDefinedRegistry)
755            {
756                fUserDefinedRegistry = new (userManager) RefHashTableOf<DatatypeValidator>(29, userManager);
757            }
758            fUserDefinedRegistry->put((void *)typeName, datatypeValidator);
759            assert (fUserDefinedRegistry->containsKey((void *)typeName));
760        }
761        else
762        {
763            fBuiltInRegistry->put((void *)typeName, datatypeValidator);
764            assert (fBuiltInRegistry->containsKey((void *)typeName));
765        }
766        datatypeValidator->setTypeName(typeName);
767    }
768
769    return datatypeValidator;
770}
771
772static DatatypeValidator::ValidatorType getPrimitiveDV(DatatypeValidator::ValidatorType validationDV)
773{
774    if (validationDV == DatatypeValidator::ID    ||
775        validationDV == DatatypeValidator::IDREF ||
776        validationDV == DatatypeValidator::ENTITY)
777    {
778        return DatatypeValidator::String;
779    }
780    return validationDV;
781}
782
783DatatypeValidator* DatatypeValidatorFactory::createDatatypeValidator
784(
785      const XMLCh* const                    typeName
786    , RefVectorOf<DatatypeValidator>* const validators
787    , const int                             finalSet
788    , const bool                            userDefined
789    , MemoryManager* const                  userManager
790)
791{
792    if (validators == 0)
793        return 0;
794
795    DatatypeValidator* datatypeValidator = 0;
796    MemoryManager* const manager = (userDefined)
797        ? userManager : XMLPlatformUtils::fgMemoryManager;
798
799    datatypeValidator = new (manager) UnionDatatypeValidator(validators, finalSet, manager);
800
801    if (datatypeValidator != 0) {
802
803        if (userDefined) {
804
805            if (!fUserDefinedRegistry) {
806                fUserDefinedRegistry = new (userManager) RefHashTableOf<DatatypeValidator>(29, userManager);
807            }
808
809            fUserDefinedRegistry->put((void *)typeName, datatypeValidator);
810        }
811        else {
812            fBuiltInRegistry->put((void *)typeName, datatypeValidator);
813        }
814        datatypeValidator->setTypeName(typeName);
815
816        // Set PSVI information for Ordered, Numeric, Bounded & Finite
817        XMLSize_t valSize = validators->size();
818        if (valSize)
819        {
820            DatatypeValidator::ValidatorType ancestorId = getPrimitiveDV(validators->elementAt(0)->getType());
821
822            // For a union the ORDERED {value} is partial unless one of the following:
823            // 1. If every member of {member type definitions} is derived from a common ancestor other than the simple ur-type, then {value} is the same as that ancestor's ordered facet.
824            // 2. If every member of {member type definitions} has a {value} of false for the ordered facet, then {value} is false.
825            bool allOrderedFalse = true;
826            bool commonAnc = ancestorId != DatatypeValidator::AnySimpleType;
827            bool allNumeric = true;
828            bool allBounded = true;
829            bool allFinite  = true;
830
831            for(XMLSize_t i = 0 ; (i < valSize) && (commonAnc || allOrderedFalse || allNumeric || allBounded || allFinite); i++)
832            {
833                // for the other member types, check whether the value is false
834                // and whether they have the same ancestor as the first one
835                if (commonAnc)
836                    commonAnc = ancestorId == getPrimitiveDV(validators->elementAt(i)->getType());
837                if (allOrderedFalse)
838                    allOrderedFalse = validators->elementAt(i)->getOrdered() == XSSimpleTypeDefinition::ORDERED_FALSE;
839
840                if (allNumeric && !validators->elementAt(i)->getNumeric())
841                {
842                    allNumeric = false;
843                }
844                if (allBounded && (!validators->elementAt(i)->getBounded() ||
845                                   ancestorId != getPrimitiveDV(validators->elementAt(i)->getType())))
846                {
847                    allBounded = false;
848                }
849                if (allFinite && !validators->elementAt(i)->getFinite())
850                {
851                    allFinite = false;
852                }
853            }
854            if (commonAnc)
855            {
856                datatypeValidator->setOrdered(validators->elementAt(0)->getOrdered());
857            }
858            else if (allOrderedFalse)
859            {
860                datatypeValidator->setOrdered(XSSimpleTypeDefinition::ORDERED_FALSE);
861            }
862            else
863            {
864                datatypeValidator->setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
865            }
866            datatypeValidator->setNumeric(allNumeric);
867            datatypeValidator->setBounded(allBounded);
868            datatypeValidator->setFinite(allFinite);
869        }
870        else // size = 0
871        {
872            datatypeValidator->setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
873            datatypeValidator->setNumeric(true);
874            datatypeValidator->setBounded(true);
875            datatypeValidator->setFinite(true);
876        }
877    }
878    return datatypeValidator;
879}
880
881/***
882 * Support for Serialization/De-serialization
883 ***/
884
885IMPL_XSERIALIZABLE_TOCREATE(DatatypeValidatorFactory)
886
887void DatatypeValidatorFactory::serialize(XSerializeEngine& serEng)
888{
889
890    // Need not to serialize static data member, fBuiltInRegistry
891
892    if (serEng.isStoring())
893    {
894        /***
895         * Serialize RefHashTableOf<DatatypeValidator>
896         ***/
897        XTemplateSerializer::storeObject(fUserDefinedRegistry, serEng);
898    }
899    else
900    {
901        /***
902         * Deserialize RefHashTableOf<DatatypeValidator>
903         ***/
904        XTemplateSerializer::loadObject(&fUserDefinedRegistry, 29, true, serEng);
905    }
906
907}
908
909XERCES_CPP_NAMESPACE_END
910
911/**
912  * End of file DatatypeValidatorFactory.cpp
913  */
Note: See TracBrowser for help on using the repository browser.