1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    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"

    46 #include "qxsdschematypesfactory_p.h"

    47 

    48 QT_BEGIN_NAMESPACE

    49 

    50 using namespace QPatternist;

    51 

    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 

    60 NamePool::Ptr XsdSchemaContext::namePool() const

    61 {

    62     return m_namePool;

    63 }

    64 

    65 QUrl XsdSchemaContext::baseURI() const

    66 {

    67     return m_baseURI;

    68 }

    69 

    70 void XsdSchemaContext::setBaseURI(const QUrl &uri)

    71 {

    72     m_baseURI = uri;

    73 }

    74 

    75 void XsdSchemaContext::setNetworkAccessManager(QNetworkAccessManager *accessManager)

    76 {

    77     m_networkAccessManager = accessManager;

    78 }

    79 

    80 QNetworkAccessManager* XsdSchemaContext::networkAccessManager() const

    81 {

    82     return m_networkAccessManager;

    83 }

    84 

    85 void XsdSchemaContext::setMessageHandler(QAbstractMessageHandler *handler)

    86 {

    87     m_messageHandler = handler;

    88 }

    89 

    90 QAbstractMessageHandler* XsdSchemaContext::messageHandler() const

    91 {

    92     return m_messageHandler;

    93 }

    94 

    95 QSourceLocation XsdSchemaContext::locationFor(const SourceLocationReflection *const) const

    96 {

    97     return QSourceLocation();

    98 }

    99 

   100 void XsdSchemaContext::setUriResolver(const QAbstractUriResolver *uriResolver)

   101 {

   102     m_uriResolver = uriResolver;

   103 }

   104 

   105 const QAbstractUriResolver* XsdSchemaContext::uriResolver() const

   106 {

   107     return m_uriResolver;

   108 }

   109 

   110 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 

   122 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 

   130 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