1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
5 **
6 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file.  Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41 
42 #include "qxsdschemacontext_p.h"
43 
44 #include "qderivedinteger_p.h"
45 #include "qderivedstring_p.h"
46 #include "qxsdschematypesfactory_p.h"
47 
48 QT_BEGIN_NAMESPACE
49 
50 using namespace QPatternist;
51 
XsdSchemaContext(const NamePool::Ptr & namePool)52 XsdSchemaContext::XsdSchemaContext(const NamePool::Ptr &namePool)
53     : m_namePool(namePool)
54     , m_networkAccessManager(0)
55     , m_uriResolver(0)
56     , m_messageHandler(0)
57 {
58 }
59 
namePool() const60 NamePool::Ptr XsdSchemaContext::namePool() const
61 {
62     return m_namePool;
63 }
64 
baseURI() const65 QUrl XsdSchemaContext::baseURI() const
66 {
67     return m_baseURI;
68 }
69 
setBaseURI(const QUrl & uri)70 void XsdSchemaContext::setBaseURI(const QUrl &uri)
71 {
72     m_baseURI = uri;
73 }
74 
setNetworkAccessManager(QNetworkAccessManager * accessManager)75 void XsdSchemaContext::setNetworkAccessManager(QNetworkAccessManager *accessManager)
76 {
77     m_networkAccessManager = accessManager;
78 }
79 
networkAccessManager() const80 QNetworkAccessManager* XsdSchemaContext::networkAccessManager() const
81 {
82     return m_networkAccessManager;
83 }
84 
setMessageHandler(QAbstractMessageHandler * handler)85 void XsdSchemaContext::setMessageHandler(QAbstractMessageHandler *handler)
86 {
87     m_messageHandler = handler;
88 }
89 
messageHandler() const90 QAbstractMessageHandler* XsdSchemaContext::messageHandler() const
91 {
92     return m_messageHandler;
93 }
94 
locationFor(const SourceLocationReflection * const) const95 QSourceLocation XsdSchemaContext::locationFor(const SourceLocationReflection *const) const
96 {
97     return QSourceLocation();
98 }
99 
setUriResolver(const QAbstractUriResolver * uriResolver)100 void XsdSchemaContext::setUriResolver(const QAbstractUriResolver *uriResolver)
101 {
102     m_uriResolver = uriResolver;
103 }
104 
uriResolver() const105 const QAbstractUriResolver* XsdSchemaContext::uriResolver() const
106 {
107     return m_uriResolver;
108 }
109 
facetsForType(const AnySimpleType::Ptr & type) const110 XsdFacet::Hash XsdSchemaContext::facetsForType(const AnySimpleType::Ptr &type) const
111 {
112     if (type->isDefinedBySchema())
113         return XsdSimpleType::Ptr(type)->facets();
114     else {
115         if (m_builtinTypesFacetList.isEmpty())
116             m_builtinTypesFacetList = setupBuiltinTypesFacetList();
117 
118         return m_builtinTypesFacetList.value(type);
119     }
120 }
121 
schemaTypeFactory() const122 SchemaTypeFactory::Ptr XsdSchemaContext::schemaTypeFactory() const
123 {
124     if (!m_schemaTypeFactory)
125         m_schemaTypeFactory = SchemaTypeFactory::Ptr(new XsdSchemaTypesFactory(m_namePool));
126 
127     return m_schemaTypeFactory;
128 }
129 
setupBuiltinTypesFacetList() const130 QHash<SchemaType::Ptr, XsdFacet::Hash> XsdSchemaContext::setupBuiltinTypesFacetList() const
131 {
132     QHash<SchemaType::Ptr, XsdFacet::Hash> hash;
133 
134     const XsdFacet::Ptr fixedCollapseWhiteSpace(new XsdFacet());
135     fixedCollapseWhiteSpace->setType(XsdFacet::WhiteSpace);
136     fixedCollapseWhiteSpace->setValue(DerivedString<TypeString>::fromLexical(m_namePool, XsdSchemaToken::toString(XsdSchemaToken::Collapse)));
137     fixedCollapseWhiteSpace->setFixed(true);
138 
139     const XsdFacet::Ptr collapseWhiteSpace(new XsdFacet());
140     collapseWhiteSpace->setType(XsdFacet::WhiteSpace);
141     collapseWhiteSpace->setValue(DerivedString<TypeString>::fromLexical(m_namePool, XsdSchemaToken::toString(XsdSchemaToken::Collapse)));
142     collapseWhiteSpace->setFixed(false);
143 
144     const XsdFacet::Ptr preserveWhiteSpace(new XsdFacet());
145     preserveWhiteSpace->setType(XsdFacet::WhiteSpace);
146     preserveWhiteSpace->setValue(DerivedString<TypeString>::fromLexical(m_namePool, XsdSchemaToken::toString(XsdSchemaToken::Preserve)));
147     preserveWhiteSpace->setFixed(false);
148 
149     const XsdFacet::Ptr replaceWhiteSpace(new XsdFacet());
150     replaceWhiteSpace->setType(XsdFacet::WhiteSpace);
151     replaceWhiteSpace->setValue(DerivedString<TypeString>::fromLexical(m_namePool, XsdSchemaToken::toString(XsdSchemaToken::Replace)));
152     replaceWhiteSpace->setFixed(false);
153 
154     const XsdFacet::Ptr fixedZeroFractionDigits(new XsdFacet());
155     fixedZeroFractionDigits->setType(XsdFacet::FractionDigits);
156     fixedZeroFractionDigits->setValue(DerivedInteger<TypeNonNegativeInteger>::fromValue(m_namePool, 0));
157     fixedZeroFractionDigits->setFixed(true);
158 
159     {
160         XsdFacet::Hash &facets = hash[BuiltinTypes::xsString];
161         facets.insert(preserveWhiteSpace->type(), preserveWhiteSpace);
162     }
163 
164     {
165         XsdFacet::Hash &facets = hash[BuiltinTypes::xsBoolean];
166         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
167     }
168 
169     {
170         XsdFacet::Hash &facets = hash[BuiltinTypes::xsDecimal];
171         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
172     }
173 
174     {
175         XsdFacet::Hash &facets = hash[BuiltinTypes::xsFloat];
176         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
177     }
178 
179     {
180         XsdFacet::Hash &facets = hash[BuiltinTypes::xsDouble];
181         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
182     }
183 
184     {
185         XsdFacet::Hash &facets = hash[BuiltinTypes::xsDuration];
186         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
187     }
188 
189     {
190         XsdFacet::Hash &facets = hash[BuiltinTypes::xsDateTime];
191         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
192     }
193 
194     {
195         XsdFacet::Hash &facets = hash[BuiltinTypes::xsTime];
196         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
197     }
198 
199     {
200         XsdFacet::Hash &facets = hash[BuiltinTypes::xsDate];
201         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
202     }
203 
204     {
205         XsdFacet::Hash &facets = hash[BuiltinTypes::xsGYearMonth];
206         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
207     }
208 
209     {
210         XsdFacet::Hash &facets = hash[BuiltinTypes::xsGYear];
211         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
212     }
213 
214     {
215         XsdFacet::Hash &facets = hash[BuiltinTypes::xsGMonthDay];
216         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
217     }
218 
219     {
220         XsdFacet::Hash &facets = hash[BuiltinTypes::xsGDay];
221         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
222     }
223 
224     {
225         XsdFacet::Hash &facets = hash[BuiltinTypes::xsGMonth];
226         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
227     }
228 
229     {
230         XsdFacet::Hash &facets = hash[BuiltinTypes::xsHexBinary];
231         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
232     }
233 
234     {
235         XsdFacet::Hash &facets = hash[BuiltinTypes::xsBase64Binary];
236         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
237     }
238 
239     {
240         XsdFacet::Hash &facets = hash[BuiltinTypes::xsAnyURI];
241         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
242     }
243 
244     {
245         XsdFacet::Hash &facets = hash[BuiltinTypes::xsQName];
246         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
247     }
248 
249     {
250         XsdFacet::Hash &facets = hash[BuiltinTypes::xsNOTATION];
251         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
252     }
253 
254     {
255         XsdFacet::Hash &facets = hash[BuiltinTypes::xsNormalizedString];
256         facets.insert(replaceWhiteSpace->type(), replaceWhiteSpace);
257     }
258 
259     {
260         XsdFacet::Hash &facets = hash[BuiltinTypes::xsToken];
261         facets.insert(collapseWhiteSpace->type(), collapseWhiteSpace);
262     }
263 
264     {
265         XsdFacet::Hash &facets = hash[BuiltinTypes::xsLanguage];
266         facets.insert(collapseWhiteSpace->type(), collapseWhiteSpace);
267 
268         const XsdFacet::Ptr pattern(new XsdFacet());
269         pattern->setType(XsdFacet::Pattern);
270         pattern->setMultiValue(AtomicValue::List() << DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*")));
271         facets.insert(pattern->type(), pattern);
272     }
273 
274     {
275         XsdFacet::Hash &facets = hash[BuiltinTypes::xsNMTOKEN];
276         facets.insert(collapseWhiteSpace->type(), collapseWhiteSpace);
277 
278         const XsdFacet::Ptr pattern(new XsdFacet());
279         pattern->setType(XsdFacet::Pattern);
280         pattern->setMultiValue(AtomicValue::List() << DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("\\c+")));
281         facets.insert(pattern->type(), pattern);
282     }
283 
284     {
285         XsdFacet::Hash &facets = hash[BuiltinTypes::xsName];
286         facets.insert(collapseWhiteSpace->type(), collapseWhiteSpace);
287 
288         const XsdFacet::Ptr pattern(new XsdFacet());
289         pattern->setType(XsdFacet::Pattern);
290         pattern->setMultiValue(AtomicValue::List() << DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("\\i\\c*")));
291         facets.insert(pattern->type(), pattern);
292     }
293 
294     const XsdFacet::Ptr ncNamePattern(new XsdFacet());
295     {
296         ncNamePattern->setType(XsdFacet::Pattern);
297         AtomicValue::List patterns;
298         patterns << DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("\\i\\c*"));
299         patterns << DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("[\\i-[:]][\\c-[:]]*"));
300         ncNamePattern->setMultiValue(patterns);
301     }
302 
303     {
304         XsdFacet::Hash &facets = hash[BuiltinTypes::xsNCName];
305         facets.insert(collapseWhiteSpace->type(), collapseWhiteSpace);
306         facets.insert(ncNamePattern->type(), ncNamePattern);
307     }
308 
309     {
310         XsdFacet::Hash &facets = hash[BuiltinTypes::xsID];
311         facets.insert(collapseWhiteSpace->type(), collapseWhiteSpace);
312         facets.insert(ncNamePattern->type(), ncNamePattern);
313     }
314 
315     {
316         XsdFacet::Hash &facets = hash[BuiltinTypes::xsIDREF];
317         facets.insert(collapseWhiteSpace->type(), collapseWhiteSpace);
318         facets.insert(ncNamePattern->type(), ncNamePattern);
319     }
320 
321     {
322         XsdFacet::Hash &facets = hash[BuiltinTypes::xsENTITY];
323         facets.insert(collapseWhiteSpace->type(), collapseWhiteSpace);
324         facets.insert(ncNamePattern->type(), ncNamePattern);
325     }
326 
327     const XsdFacet::Ptr integerPattern(new XsdFacet());
328     integerPattern->setType(XsdFacet::Pattern);
329     integerPattern->setMultiValue(AtomicValue::List() << DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("[\\-+]?[0-9]+")));
330 
331     {
332         XsdFacet::Hash &facets = hash[BuiltinTypes::xsInteger];
333         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
334         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
335         facets.insert(integerPattern->type(), integerPattern);
336     }
337 
338     {
339         XsdFacet::Hash &facets = hash[BuiltinTypes::xsNonPositiveInteger];
340         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
341         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
342         facets.insert(integerPattern->type(), integerPattern);
343 
344         const XsdFacet::Ptr maxInclusive(new XsdFacet());
345         maxInclusive->setType(XsdFacet::MaximumInclusive);
346         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("0")));
347         facets.insert(maxInclusive->type(), maxInclusive);
348     }
349 
350     {
351         XsdFacet::Hash &facets = hash[BuiltinTypes::xsNegativeInteger];
352         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
353         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
354         facets.insert(integerPattern->type(), integerPattern);
355 
356         const XsdFacet::Ptr maxInclusive(new XsdFacet());
357         maxInclusive->setType(XsdFacet::MaximumInclusive);
358         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("-1")));
359         facets.insert(maxInclusive->type(), maxInclusive);
360     }
361 
362     {
363         XsdFacet::Hash &facets = hash[BuiltinTypes::xsLong];
364         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
365         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
366         facets.insert(integerPattern->type(), integerPattern);
367 
368         const XsdFacet::Ptr maxInclusive(new XsdFacet());
369         maxInclusive->setType(XsdFacet::MaximumInclusive);
370         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("9223372036854775807")));
371         facets.insert(maxInclusive->type(), maxInclusive);
372 
373         const XsdFacet::Ptr minInclusive(new XsdFacet());
374         minInclusive->setType(XsdFacet::MinimumInclusive);
375         minInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("-9223372036854775808")));
376         facets.insert(minInclusive->type(), minInclusive);
377     }
378 
379     {
380         XsdFacet::Hash &facets = hash[BuiltinTypes::xsInt];
381         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
382         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
383         facets.insert(integerPattern->type(), integerPattern);
384 
385         const XsdFacet::Ptr maxInclusive(new XsdFacet());
386         maxInclusive->setType(XsdFacet::MaximumInclusive);
387         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("2147483647")));
388         facets.insert(maxInclusive->type(), maxInclusive);
389 
390         const XsdFacet::Ptr minInclusive(new XsdFacet());
391         minInclusive->setType(XsdFacet::MinimumInclusive);
392         minInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("-2147483648")));
393         facets.insert(minInclusive->type(), minInclusive);
394     }
395 
396     {
397         XsdFacet::Hash &facets = hash[BuiltinTypes::xsShort];
398         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
399         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
400         facets.insert(integerPattern->type(), integerPattern);
401 
402         const XsdFacet::Ptr maxInclusive(new XsdFacet());
403         maxInclusive->setType(XsdFacet::MaximumInclusive);
404         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("32767")));
405         facets.insert(maxInclusive->type(), maxInclusive);
406 
407         const XsdFacet::Ptr minInclusive(new XsdFacet());
408         minInclusive->setType(XsdFacet::MinimumInclusive);
409         minInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("-32768")));
410         facets.insert(minInclusive->type(), minInclusive);
411     }
412 
413     {
414         XsdFacet::Hash &facets = hash[BuiltinTypes::xsByte];
415         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
416         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
417         facets.insert(integerPattern->type(), integerPattern);
418 
419         const XsdFacet::Ptr maxInclusive(new XsdFacet());
420         maxInclusive->setType(XsdFacet::MaximumInclusive);
421         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("127")));
422         facets.insert(maxInclusive->type(), maxInclusive);
423 
424         const XsdFacet::Ptr minInclusive(new XsdFacet());
425         minInclusive->setType(XsdFacet::MinimumInclusive);
426         minInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("-128")));
427         facets.insert(minInclusive->type(), minInclusive);
428     }
429 
430     const XsdFacet::Ptr unsignedMinInclusive(new XsdFacet());
431     unsignedMinInclusive->setType(XsdFacet::MinimumInclusive);
432     unsignedMinInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("0")));
433 
434     {
435         XsdFacet::Hash &facets = hash[BuiltinTypes::xsNonNegativeInteger];
436         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
437         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
438         facets.insert(integerPattern->type(), integerPattern);
439         facets.insert(unsignedMinInclusive->type(), unsignedMinInclusive);
440     }
441 
442     {
443         XsdFacet::Hash &facets = hash[BuiltinTypes::xsUnsignedLong];
444         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
445         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
446         facets.insert(integerPattern->type(), integerPattern);
447         facets.insert(unsignedMinInclusive->type(), unsignedMinInclusive);
448 
449         const XsdFacet::Ptr maxInclusive(new XsdFacet());
450         maxInclusive->setType(XsdFacet::MaximumInclusive);
451         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("18446744073709551615")));
452         facets.insert(maxInclusive->type(), maxInclusive);
453     }
454 
455     {
456         XsdFacet::Hash &facets = hash[BuiltinTypes::xsUnsignedInt];
457         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
458         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
459         facets.insert(integerPattern->type(), integerPattern);
460         facets.insert(unsignedMinInclusive->type(), unsignedMinInclusive);
461 
462         const XsdFacet::Ptr maxInclusive(new XsdFacet());
463         maxInclusive->setType(XsdFacet::MaximumInclusive);
464         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("4294967295")));
465         facets.insert(maxInclusive->type(), maxInclusive);
466     }
467 
468     {
469         XsdFacet::Hash &facets = hash[BuiltinTypes::xsUnsignedShort];
470         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
471         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
472         facets.insert(integerPattern->type(), integerPattern);
473         facets.insert(unsignedMinInclusive->type(), unsignedMinInclusive);
474 
475         const XsdFacet::Ptr maxInclusive(new XsdFacet());
476         maxInclusive->setType(XsdFacet::MaximumInclusive);
477         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("65535")));
478         facets.insert(maxInclusive->type(), maxInclusive);
479     }
480 
481     {
482         XsdFacet::Hash &facets = hash[BuiltinTypes::xsUnsignedByte];
483         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
484         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
485         facets.insert(integerPattern->type(), integerPattern);
486         facets.insert(unsignedMinInclusive->type(), unsignedMinInclusive);
487 
488         const XsdFacet::Ptr maxInclusive(new XsdFacet());
489         maxInclusive->setType(XsdFacet::MaximumInclusive);
490         maxInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("255")));
491         facets.insert(maxInclusive->type(), maxInclusive);
492     }
493 
494     {
495         XsdFacet::Hash &facets = hash[BuiltinTypes::xsPositiveInteger];
496         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
497         facets.insert(fixedZeroFractionDigits->type(), fixedZeroFractionDigits);
498 
499         const XsdFacet::Ptr minInclusive(new XsdFacet());
500         minInclusive->setType(XsdFacet::MinimumInclusive);
501         minInclusive->setValue(DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("1")));
502         facets.insert(minInclusive->type(), minInclusive);
503     }
504 
505     {
506         XsdFacet::Hash &facets = hash[BuiltinTypes::xsYearMonthDuration];
507         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
508 
509         const XsdFacet::Ptr pattern(new XsdFacet());
510         pattern->setType(XsdFacet::Pattern);
511         pattern->setMultiValue(AtomicValue::List() << DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("[^DT]*")));
512         facets.insert(pattern->type(), pattern);
513     }
514 
515     {
516         XsdFacet::Hash &facets = hash[BuiltinTypes::xsDayTimeDuration];
517         facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
518 
519         const XsdFacet::Ptr pattern(new XsdFacet());
520         pattern->setType(XsdFacet::Pattern);
521         pattern->setMultiValue(AtomicValue::List() << DerivedString<TypeString>::fromLexical(m_namePool, QString::fromLatin1("[^YM]*(T.*)?")));
522         facets.insert(pattern->type(), pattern);
523     }
524 
525     return hash;
526 }
527 
528 QT_END_NAMESPACE
529