Qt 4.8
qxsdschemacontext.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
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 Digia. For licensing terms and
14 ** conditions see http://qt.digia.com/licensing. For further information
15 ** use the contact form at http://qt.digia.com/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 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights. These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file. Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41 
42 #include "qxsdschemacontext_p.h"
43 
44 #include "qderivedinteger_p.h"
45 #include "qderivedstring_p.h"
47 
49 
50 using namespace QPatternist;
51 
53  : m_namePool(namePool)
54  , m_networkAccessManager(0)
55  , m_uriResolver(0)
56  , m_messageHandler(0)
57 {
58 }
59 
61 {
62  return m_namePool;
63 }
64 
66 {
67  return m_baseURI;
68 }
69 
71 {
72  m_baseURI = uri;
73 }
74 
76 {
77  m_networkAccessManager = accessManager;
78 }
79 
81 {
83 }
84 
86 {
88 }
89 
91 {
92  return m_messageHandler;
93 }
94 
96 {
97  return QSourceLocation();
98 }
99 
101 {
103 }
104 
106 {
107  return m_uriResolver;
108 }
109 
111 {
112  if (type->isDefinedBySchema())
113  return XsdSimpleType::Ptr(type)->facets();
114  else {
115  if (m_builtinTypesFacetList.isEmpty())
117 
118  return m_builtinTypesFacetList.value(type);
119  }
120 }
121 
123 {
124  if (!m_schemaTypeFactory)
126 
127  return m_schemaTypeFactory;
128 }
129 
131 {
133 
134  const XsdFacet::Ptr fixedCollapseWhiteSpace(new XsdFacet());
135  fixedCollapseWhiteSpace->setType(XsdFacet::WhiteSpace);
137  fixedCollapseWhiteSpace->setFixed(true);
138 
139  const XsdFacet::Ptr collapseWhiteSpace(new XsdFacet());
140  collapseWhiteSpace->setType(XsdFacet::WhiteSpace);
142  collapseWhiteSpace->setFixed(false);
143 
144  const XsdFacet::Ptr preserveWhiteSpace(new XsdFacet());
145  preserveWhiteSpace->setType(XsdFacet::WhiteSpace);
147  preserveWhiteSpace->setFixed(false);
148 
149  const XsdFacet::Ptr replaceWhiteSpace(new XsdFacet());
150  replaceWhiteSpace->setType(XsdFacet::WhiteSpace);
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  {
186  facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
187  }
188 
189  {
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  {
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  {
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  {
231  facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
232  }
233 
234  {
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  {
251  facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
252  }
253 
254  {
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  {
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);
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);
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  {
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);
347  facets.insert(maxInclusive->type(), maxInclusive);
348  }
349 
350  {
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);
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);
422  facets.insert(maxInclusive->type(), maxInclusive);
423 
424  const XsdFacet::Ptr minInclusive(new XsdFacet());
425  minInclusive->setType(XsdFacet::MinimumInclusive);
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  {
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  {
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  {
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  {
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  {
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);
491  facets.insert(maxInclusive->type(), maxInclusive);
492  }
493 
494  {
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);
502  facets.insert(minInclusive->type(), minInclusive);
503  }
504 
505  {
507  facets.insert(fixedCollapseWhiteSpace->type(), fixedCollapseWhiteSpace);
508 
509  const XsdFacet::Ptr pattern(new XsdFacet());
510  pattern->setType(XsdFacet::Pattern);
512  facets.insert(pattern->type(), pattern);
513  }
514 
515  {
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 
static uint hash(const uchar *p, int n)
Definition: qhash.cpp:68
Represents a XSD facet object.
Definition: qxsdfacet_p.h:93
static const AtomicType::Ptr xsBase64Binary
static const AtomicType::Ptr xsID
virtual QNetworkAccessManager * networkAccessManager() const
int type
Definition: qmetatype.cpp:239
virtual QSourceLocation locationFor(const SourceLocationReflection *const reflection) const
static const AtomicType::Ptr xsDayTimeDuration
QAbstractMessageHandler * m_messageHandler
static const AtomicType::Ptr xsInt
#define QT_END_NAMESPACE
This macro expands to.
Definition: qglobal.h:90
Match a minimum inclusive (Minimum Inclusive Definition)
Definition: qxsdfacet_p.h:111
static const AtomicType::Ptr xsShort
static const AtomicType::Ptr xsNegativeInteger
static const AtomicType::Ptr xsByte
static const AtomicType::Ptr xsDuration
QNetworkAccessManager * m_networkAccessManager
static const AtomicType::Ptr xsGYearMonth
static const AtomicType::Ptr xsNormalizedString
static const AtomicType::Ptr xsGMonthDay
virtual NamePool::Ptr namePool() const
The QUrl class provides a convenient interface for working with URLs.
Definition: qurl.h:61
static QString toString(NodeName token)
static const AtomicType::Ptr xsYearMonthDuration
static const AtomicType::Ptr xsName
SchemaTypeFactory::Ptr m_schemaTypeFactory
static const AtomicType::Ptr xsUnsignedByte
virtual void setBaseURI(const QUrl &uri)
iterator insert(const Key &key, const T &value)
Inserts a new item with the key and a value of value.
Definition: qhash.h:753
static const AtomicType::Ptr xsIDREF
static const AtomicType::Ptr xsString
void setMessageHandler(QAbstractMessageHandler *handler)
static const AtomicType::Ptr xsNMTOKEN
static const AtomicType::Ptr xsGDay
The QAbstractUriResolver class is a callback interface for resolving Uniform Resource Identifiers...
#define QT_BEGIN_NAMESPACE
This macro expands to.
Definition: qglobal.h:89
SchemaTypeFactory::Ptr schemaTypeFactory() const
virtual const QAbstractUriResolver * uriResolver() const
static const AtomicType::Ptr xsDateTime
virtual QAbstractMessageHandler * messageHandler() const
static const AtomicType::Ptr xsUnsignedInt
The namespace for the internal API of QtXmlPatterns.
static const AtomicType::Ptr xsDouble
The QSourceLocation class identifies a location in a resource by URI, line, and column.
QExplicitlySharedDataPointer< SchemaTypeFactory > Ptr
static const AtomicType::Ptr xsENTITY
static const AtomicType::Ptr xsGYear
XsdSchemaContext(const NamePool::Ptr &namePool)
The QNetworkAccessManager class allows the application to send network requests and receive replies...
Match a whitespace rule (White Space Definition)
Definition: qxsdfacet_p.h:108
Match a maximum inclusive (Maximum Inclusive Definition)
Definition: qxsdfacet_p.h:109
static const AtomicType::Ptr xsNonNegativeInteger
Match some double digits (Fraction Digits Definition)
Definition: qxsdfacet_p.h:114
Represents instances of derived xs:string types, such as xs:normalizedString.
void setUriResolver(const QAbstractUriResolver *resolver)
QHash< SchemaType::Ptr, XsdFacet::Hash > setupBuiltinTypesFacetList() const
void setNetworkAccessManager(QNetworkAccessManager *accessManager)
static const AtomicType::Ptr xsQName
The QAbstractMessageHandler class provides a callback interface for handling messages.
static const AtomicType::Ptr xsNonPositiveInteger
XsdFacet::Hash facets() const
static QString fromLatin1(const char *, int size=-1)
Returns a QString initialized with the first size characters of the Latin-1 string str...
Definition: qstring.cpp:4188
Match a regular expression (Pattern Definition)
Definition: qxsdfacet_p.h:107
static const AtomicType::Ptr xsFloat
XsdFacet::Hash facetsForType(const AnySimpleType::Ptr &type) const
static const AtomicType::Ptr xsInteger
static const AtomicType::Ptr xsTime
QHash< SchemaType::Ptr, XsdFacet::Hash > m_builtinTypesFacetList
static const AtomicType::Ptr xsUnsignedShort
static const AtomicType::Ptr xsDecimal
static const AtomicType::Ptr xsBoolean
static const AtomicType::Ptr xsNCName
static const AtomicType::Ptr xsPositiveInteger
Represents instances of derived xs:integer types, such as xs:byte.
static const AtomicType::Ptr xsDate
static const AtomicType::Ptr xsLanguage
static const AtomicType::Ptr xsLong
Factory for creating schema types for the types defined in XSD.
QImageIOHandler * handler
virtual bool isDefinedBySchema() const
Definition: qschematype.cpp:75
static const AtomicType::Ptr xsNOTATION
static const AtomicType::Ptr xsGMonth
const QAbstractUriResolver * m_uriResolver
static const AtomicType::Ptr xsHexBinary
static const AtomicType::Ptr xsUnsignedLong
static const AtomicType::Ptr xsAnyURI
static const AtomicType::Ptr xsToken
Base class for all instances that represents something at a certain location.