Qt 4.8
Public Types | Static Public Functions | Static Private Functions | List of all members
XsdSchemaToken Class Reference

#include <qxsdschematoken_p.h>

Inheritance diagram for XsdSchemaToken:
QPatternist::MaintainingReader< XsdSchemaToken, XsdTagScope::Type > QPatternist::XsdSchemaParser

Public Types

enum  NodeName {
  NoKeyword, Abstract, All, Alternative,
  Annotation, Any, AnyAttribute, Appinfo,
  AppliesToEmpty, Assert, Assertion, Attribute,
  AttributeFormDefault, AttributeGroup, Base, Block,
  BlockDefault, Choice, Collapse, ComplexContent,
  ComplexType, Default, DefaultAttributes, DefaultAttributesApply,
  DefaultOpenContent, Documentation, Element, ElementFormDefault,
  Enumeration, Extension, Field, Final,
  FinalDefault, Fixed, Form, FractionDigits,
  Group, Id, Import, Include,
  ItemType, Key, Keyref, Length,
  List, MaxExclusive, MaxInclusive, MaxLength,
  MaxOccurs, MemberTypes, MinExclusive, MinInclusive,
  MinLength, MinOccurs, Mixed, Mode,
  Name, Namespace, Nillable, NotNamespace,
  NotQName, Notation, OpenContent, Override,
  Pattern, Preserve, ProcessContents, Public,
  Redefine, Ref, Refer, Replace,
  Restriction, Schema, SchemaLocation, Selector,
  Sequence, SimpleContent, SimpleType, Source,
  SubstitutionGroup, System, TargetNamespace, Test,
  TotalDigits, Type, Union, Unique,
  Use, Value, Version, WhiteSpace,
  XML_NS_SCHEMA_URI, XPathDefaultNamespace, XmlLanguage, Xpath
}
 

Static Public Functions

static QString toString (NodeName token)
 
static NodeName toToken (const QString &value)
 
static NodeName toToken (const QStringRef &value)
 
static NodeName toToken (const QChar *data, int length)
 

Static Private Functions

static NodeName classifier10 (const QChar *data)
 
static NodeName classifier11 (const QChar *data)
 
static NodeName classifier12 (const QChar *data)
 
static NodeName classifier13 (const QChar *data)
 
static NodeName classifier14 (const QChar *data)
 
static NodeName classifier15 (const QChar *data)
 
static NodeName classifier17 (const QChar *data)
 
static NodeName classifier18 (const QChar *data)
 
static NodeName classifier2 (const QChar *data)
 
static NodeName classifier20 (const QChar *data)
 
static NodeName classifier21 (const QChar *data)
 
static NodeName classifier22 (const QChar *data)
 
static NodeName classifier3 (const QChar *data)
 
static NodeName classifier32 (const QChar *data)
 
static NodeName classifier4 (const QChar *data)
 
static NodeName classifier5 (const QChar *data)
 
static NodeName classifier6 (const QChar *data)
 
static NodeName classifier7 (const QChar *data)
 
static NodeName classifier8 (const QChar *data)
 
static NodeName classifier9 (const QChar *data)
 

Detailed Description

Definition at line 62 of file qxsdschematoken_p.h.

Enumerations

◆ NodeName

enum XsdSchemaToken::NodeName
Enumerator
NoKeyword 
Abstract 
All 
Alternative 
Annotation 
Any 
AnyAttribute 
Appinfo 
AppliesToEmpty 
Assert 
Assertion 
Attribute 
AttributeFormDefault 
AttributeGroup 
Base 
Block 
BlockDefault 
Choice 
Collapse 
ComplexContent 
ComplexType 
Default 
DefaultAttributes 
DefaultAttributesApply 
DefaultOpenContent 
Documentation 
Element 
ElementFormDefault 
Enumeration 
Extension 
Field 
Final 
FinalDefault 
Fixed 
Form 
FractionDigits 
Group 
Id 
Import 
Include 
ItemType 
Key 
Keyref 
Length 
List 
MaxExclusive 
MaxInclusive 
MaxLength 
MaxOccurs 
MemberTypes 
MinExclusive 
MinInclusive 
MinLength 
MinOccurs 
Mixed 
Mode 
Name 
Namespace 
Nillable 
NotNamespace 
NotQName 
Notation 
OpenContent 
Override 
Pattern 
Preserve 
ProcessContents 
Public 
Redefine 
Ref 
Refer 
Replace 
Restriction 
Schema 
SchemaLocation 
Selector 
Sequence 
SimpleContent 
SimpleType 
Source 
SubstitutionGroup 
System 
TargetNamespace 
Test 
TotalDigits 
Type 
Union 
Unique 
Use 
Value 
Version 
WhiteSpace 
XML_NS_SCHEMA_URI 
XPathDefaultNamespace 
XmlLanguage 
Xpath 

Definition at line 65 of file qxsdschematoken_p.h.

67  {
68  NoKeyword,
69 Abstract,
70 All,
71 Alternative,
72 Annotation,
73 Any,
74 AnyAttribute,
75 Appinfo,
76 AppliesToEmpty,
77 Assert,
78 Assertion,
79 Attribute,
80 AttributeFormDefault,
81 AttributeGroup,
82 Base,
83 Block,
84 BlockDefault,
85 Choice,
86 Collapse,
87 ComplexContent,
88 ComplexType,
89 Default,
90 DefaultAttributes,
91 DefaultAttributesApply,
92 DefaultOpenContent,
93 Documentation,
94 Element,
95 ElementFormDefault,
96 Enumeration,
97 Extension,
98 Field,
99 Final,
100 FinalDefault,
101 Fixed,
102 Form,
103 FractionDigits,
104 Group,
105 Id,
106 Import,
107 Include,
108 ItemType,
109 Key,
110 Keyref,
111 Length,
112 List,
113 MaxExclusive,
114 MaxInclusive,
115 MaxLength,
116 MaxOccurs,
117 MemberTypes,
118 MinExclusive,
119 MinInclusive,
120 MinLength,
121 MinOccurs,
122 Mixed,
123 Mode,
124 Name,
125 Namespace,
126 Nillable,
127 NotNamespace,
128 NotQName,
129 Notation,
130 OpenContent,
131 Override,
132 Pattern,
133 Preserve,
134 ProcessContents,
135 Public,
136 Redefine,
137 Ref,
138 Refer,
139 Replace,
140 Restriction,
141 Schema,
142 SchemaLocation,
143 Selector,
144 Sequence,
145 SimpleContent,
146 SimpleType,
147 Source,
148 SubstitutionGroup,
149 System,
150 TargetNamespace,
151 Test,
152 TotalDigits,
153 Type,
154 Union,
155 Unique,
156 Use,
157 Value,
158 Version,
159 WhiteSpace,
160 XML_NS_SCHEMA_URI,
161 XPathDefaultNamespace,
162 XmlLanguage,
163 Xpath
164  };

Functions

◆ classifier10()

XsdSchemaToken::NodeName XsdSchemaToken::classifier10 ( const QChar *  data)
inlinestaticprivate

Definition at line 1161 of file qxsdschematoken.cpp.

Referenced by toToken().

1163  {
1164  if (data[0] == 97)
1165 
1166 
1167  {
1168 
1169  static const unsigned short string[] =
1170  {
1171  110, 110, 111, 116, 97, 116, 105, 111, 110
1172  };
1173  if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
1174 
1175 
1176  return Annotation;
1177 
1178  }
1179 
1180  else if (data[0] == 115)
1181 
1182 
1183  {
1184 
1185  static const unsigned short string[] =
1186  {
1187  105, 109, 112, 108, 101, 84, 121, 112, 101
1188  };
1189  if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
1190 
1191 
1192  return SimpleType;
1193 
1194  }
1195 
1196  else if (data[0] == 119)
1197 
1198 
1199  {
1200 
1201  static const unsigned short string[] =
1202  {
1203  104, 105, 116, 101, 83, 112, 97, 99, 101
1204  };
1205  if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
1206 
1207 
1208  return WhiteSpace;
1209 
1210  }
1211 
1212 
1213 
1214  return NoKeyword;
1215  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier11()

XsdSchemaToken::NodeName XsdSchemaToken::classifier11 ( const QChar *  data)
inlinestaticprivate

Definition at line 1216 of file qxsdschematoken.cpp.

Referenced by toToken().

1218  {
1219  if (data[0] == 97)
1220 
1221 
1222  {
1223 
1224  static const unsigned short string[] =
1225  {
1226  108, 116, 101, 114, 110, 97, 116, 105, 118, 101
1227  };
1228  if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
1229 
1230 
1231  return Alternative;
1232 
1233  }
1234 
1235  else if (data[0] == 99)
1236 
1237 
1238  {
1239 
1240  static const unsigned short string[] =
1241  {
1242  111, 109, 112, 108, 101, 120, 84, 121, 112, 101
1243  };
1244  if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
1245 
1246 
1247  return ComplexType;
1248 
1249  }
1250 
1251  else if (data[0] == 101)
1252 
1253 
1254  {
1255 
1256  static const unsigned short string[] =
1257  {
1258  110, 117, 109, 101, 114, 97, 116, 105, 111, 110
1259  };
1260  if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
1261 
1262 
1263  return Enumeration;
1264 
1265  }
1266 
1267  else if (data[0] == 109)
1268 
1269 
1270  {
1271 
1272  static const unsigned short string[] =
1273  {
1274  101, 109, 98, 101, 114, 84, 121, 112, 101, 115
1275  };
1276  if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
1277 
1278 
1279  return MemberTypes;
1280 
1281  }
1282 
1283  else if (data[0] == 111)
1284 
1285 
1286  {
1287 
1288  static const unsigned short string[] =
1289  {
1290  112, 101, 110, 67, 111, 110, 116, 101, 110, 116
1291  };
1292  if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
1293 
1294 
1295  return OpenContent;
1296 
1297  }
1298 
1299  else if (data[0] == 114)
1300 
1301 
1302  {
1303 
1304  static const unsigned short string[] =
1305  {
1306  101, 115, 116, 114, 105, 99, 116, 105, 111, 110
1307  };
1308  if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
1309 
1310 
1311  return Restriction;
1312 
1313  }
1314 
1315  else if (data[0] == 116)
1316 
1317 
1318  {
1319 
1320  static const unsigned short string[] =
1321  {
1322  111, 116, 97, 108, 68, 105, 103, 105, 116, 115
1323  };
1324  if(memcmp(&data[1], &string, sizeof(QChar) * 10) == 0)
1325 
1326 
1327  return TotalDigits;
1328 
1329  }
1330 
1331 
1332 
1333  return NoKeyword;
1334  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier12()

XsdSchemaToken::NodeName XsdSchemaToken::classifier12 ( const QChar *  data)
inlinestaticprivate

Definition at line 1335 of file qxsdschematoken.cpp.

Referenced by toToken().

1337  {
1338  if (data[0] == 97)
1339 
1340 
1341  {
1342 
1343  static const unsigned short string[] =
1344  {
1345  110, 121, 65, 116, 116, 114, 105, 98, 117, 116, 101
1346  };
1347  if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0)
1348 
1349 
1350  return AnyAttribute;
1351 
1352  }
1353 
1354  else if (data[0] == 98)
1355 
1356 
1357  {
1358 
1359  static const unsigned short string[] =
1360  {
1361  108, 111, 99, 107, 68, 101, 102, 97, 117, 108, 116
1362  };
1363  if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0)
1364 
1365 
1366  return BlockDefault;
1367 
1368  }
1369 
1370  else if (data[0] == 102)
1371 
1372 
1373  {
1374 
1375  static const unsigned short string[] =
1376  {
1377  105, 110, 97, 108, 68, 101, 102, 97, 117, 108, 116
1378  };
1379  if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0)
1380 
1381 
1382  return FinalDefault;
1383 
1384  }
1385 
1386  else if (data[0] == 109)
1387 
1388 
1389  {
1390  if (data[1] == 97)
1391 
1392 
1393  {
1394  if (data[2] == 120)
1395 
1396 
1397  {
1398  if (data[3] == 69)
1399 
1400 
1401  {
1402 
1403  static const unsigned short string[] =
1404  {
1405  120, 99, 108, 117, 115, 105, 118, 101
1406  };
1407  if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0)
1408 
1409 
1410  return MaxExclusive;
1411 
1412  }
1413 
1414  else if (data[3] == 73)
1415 
1416 
1417  {
1418 
1419  static const unsigned short string[] =
1420  {
1421  110, 99, 108, 117, 115, 105, 118, 101
1422  };
1423  if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0)
1424 
1425 
1426  return MaxInclusive;
1427 
1428  }
1429 
1430 
1431  }
1432 
1433 
1434  }
1435 
1436  else if (data[1] == 105)
1437 
1438 
1439  {
1440  if (data[2] == 110)
1441 
1442 
1443  {
1444  if (data[3] == 69)
1445 
1446 
1447  {
1448 
1449  static const unsigned short string[] =
1450  {
1451  120, 99, 108, 117, 115, 105, 118, 101
1452  };
1453  if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0)
1454 
1455 
1456  return MinExclusive;
1457 
1458  }
1459 
1460  else if (data[3] == 73)
1461 
1462 
1463  {
1464 
1465  static const unsigned short string[] =
1466  {
1467  110, 99, 108, 117, 115, 105, 118, 101
1468  };
1469  if(memcmp(&data[4], &string, sizeof(QChar) * 8) == 0)
1470 
1471 
1472  return MinInclusive;
1473 
1474  }
1475 
1476 
1477  }
1478 
1479 
1480  }
1481 
1482 
1483  }
1484 
1485  else if (data[0] == 110)
1486 
1487 
1488  {
1489 
1490  static const unsigned short string[] =
1491  {
1492  111, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101
1493  };
1494  if(memcmp(&data[1], &string, sizeof(QChar) * 11) == 0)
1495 
1496 
1497  return NotNamespace;
1498 
1499  }
1500 
1501 
1502 
1503  return NoKeyword;
1504  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier13()

XsdSchemaToken::NodeName XsdSchemaToken::classifier13 ( const QChar *  data)
inlinestaticprivate

Definition at line 1505 of file qxsdschematoken.cpp.

Referenced by toToken().

1507  {
1508  if (data[0] == 100)
1509 
1510 
1511  {
1512 
1513  static const unsigned short string[] =
1514  {
1515  111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110
1516  };
1517  if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
1518 
1519 
1520  return Documentation;
1521 
1522  }
1523 
1524  else if (data[0] == 115)
1525 
1526 
1527  {
1528 
1529  static const unsigned short string[] =
1530  {
1531  105, 109, 112, 108, 101, 67, 111, 110, 116, 101, 110, 116
1532  };
1533  if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
1534 
1535 
1536  return SimpleContent;
1537 
1538  }
1539 
1540 
1541 
1542  return NoKeyword;
1543  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier14()

XsdSchemaToken::NodeName XsdSchemaToken::classifier14 ( const QChar *  data)
inlinestaticprivate

Definition at line 1544 of file qxsdschematoken.cpp.

Referenced by toToken().

1546  {
1547  if (data[0] == 97)
1548 
1549 
1550  {
1551  if (data[1] == 112)
1552 
1553 
1554  {
1555 
1556  static const unsigned short string[] =
1557  {
1558  112, 108, 105, 101, 115, 84, 111, 69, 109, 112, 116, 121
1559  };
1560  if(memcmp(&data[2], &string, sizeof(QChar) * 12) == 0)
1561 
1562 
1563  return AppliesToEmpty;
1564 
1565  }
1566 
1567  else if (data[1] == 116)
1568 
1569 
1570  {
1571 
1572  static const unsigned short string[] =
1573  {
1574  116, 114, 105, 98, 117, 116, 101, 71, 114, 111, 117, 112
1575  };
1576  if(memcmp(&data[2], &string, sizeof(QChar) * 12) == 0)
1577 
1578 
1579  return AttributeGroup;
1580 
1581  }
1582 
1583 
1584  }
1585 
1586  else if (data[0] == 99)
1587 
1588 
1589  {
1590 
1591  static const unsigned short string[] =
1592  {
1593  111, 109, 112, 108, 101, 120, 67, 111, 110, 116, 101, 110, 116
1594  };
1595  if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
1596 
1597 
1598  return ComplexContent;
1599 
1600  }
1601 
1602  else if (data[0] == 102)
1603 
1604 
1605  {
1606 
1607  static const unsigned short string[] =
1608  {
1609  114, 97, 99, 116, 105, 111, 110, 68, 105, 103, 105, 116, 115
1610  };
1611  if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
1612 
1613 
1614  return FractionDigits;
1615 
1616  }
1617 
1618  else if (data[0] == 115)
1619 
1620 
1621  {
1622 
1623  static const unsigned short string[] =
1624  {
1625  99, 104, 101, 109, 97, 76, 111, 99, 97, 116, 105, 111, 110
1626  };
1627  if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
1628 
1629 
1630  return SchemaLocation;
1631 
1632  }
1633 
1634 
1635 
1636  return NoKeyword;
1637  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier15()

XsdSchemaToken::NodeName XsdSchemaToken::classifier15 ( const QChar *  data)
inlinestaticprivate

Definition at line 1638 of file qxsdschematoken.cpp.

Referenced by toToken().

1640  {
1641  if (data[0] == 112)
1642 
1643 
1644  {
1645 
1646  static const unsigned short string[] =
1647  {
1648  114, 111, 99, 101, 115, 115, 67, 111, 110, 116, 101, 110, 116, 115
1649  };
1650  if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
1651 
1652 
1653  return ProcessContents;
1654 
1655  }
1656 
1657  else if (data[0] == 116)
1658 
1659 
1660  {
1661 
1662  static const unsigned short string[] =
1663  {
1664  97, 114, 103, 101, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101
1665  };
1666  if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
1667 
1668 
1669  return TargetNamespace;
1670 
1671  }
1672 
1673 
1674 
1675  return NoKeyword;
1676  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier17()

XsdSchemaToken::NodeName XsdSchemaToken::classifier17 ( const QChar *  data)
inlinestaticprivate

Definition at line 1677 of file qxsdschematoken.cpp.

Referenced by toToken().

1679  {
1680  if (data[0] == 100)
1681 
1682 
1683  {
1684 
1685  static const unsigned short string[] =
1686  {
1687  101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115
1688  };
1689  if(memcmp(&data[1], &string, sizeof(QChar) * 16) == 0)
1690 
1691 
1692  return DefaultAttributes;
1693 
1694  }
1695 
1696  else if (data[0] == 115)
1697 
1698 
1699  {
1700 
1701  static const unsigned short string[] =
1702  {
1703  117, 98, 115, 116, 105, 116, 117, 116, 105, 111, 110, 71, 114, 111, 117, 112
1704  };
1705  if(memcmp(&data[1], &string, sizeof(QChar) * 16) == 0)
1706 
1707 
1708  return SubstitutionGroup;
1709 
1710  }
1711 
1712 
1713 
1714  return NoKeyword;
1715  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier18()

XsdSchemaToken::NodeName XsdSchemaToken::classifier18 ( const QChar *  data)
inlinestaticprivate

Definition at line 1716 of file qxsdschematoken.cpp.

Referenced by toToken().

1718  {
1719  if (data[0] == 100)
1720 
1721 
1722  {
1723 
1724  static const unsigned short string[] =
1725  {
1726  101, 102, 97, 117, 108, 116, 79, 112, 101, 110, 67, 111, 110, 116, 101, 110, 116
1727  };
1728  if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
1729 
1730 
1731  return DefaultOpenContent;
1732 
1733  }
1734 
1735  else if (data[0] == 101)
1736 
1737 
1738  {
1739 
1740  static const unsigned short string[] =
1741  {
1742  108, 101, 109, 101, 110, 116, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116
1743  };
1744  if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
1745 
1746 
1747  return ElementFormDefault;
1748 
1749  }
1750 
1751 
1752 
1753  return NoKeyword;
1754  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier2()

XsdSchemaToken::NodeName XsdSchemaToken::classifier2 ( const QChar *  data)
inlinestaticprivate

Definition at line 48 of file qxsdschematoken.cpp.

Referenced by toToken().

50  {
51 
52  static const unsigned short string[] =
53  {
54  105, 100
55  };
56  if(memcmp(&data[0], &string, sizeof(QChar) * 2) == 0)
57 
58 
59  return Id;
60 
61 
62  return NoKeyword;
63  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier20()

XsdSchemaToken::NodeName XsdSchemaToken::classifier20 ( const QChar *  data)
inlinestaticprivate

Definition at line 1755 of file qxsdschematoken.cpp.

Referenced by toToken().

1757  {
1758 
1759  static const unsigned short string[] =
1760  {
1761  97, 116, 116, 114, 105, 98, 117, 116, 101, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116
1762  };
1763  if(memcmp(&data[0], &string, sizeof(QChar) * 20) == 0)
1764 
1765 
1766  return AttributeFormDefault;
1767 
1768 
1769  return NoKeyword;
1770  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier21()

XsdSchemaToken::NodeName XsdSchemaToken::classifier21 ( const QChar *  data)
inlinestaticprivate

Definition at line 1771 of file qxsdschematoken.cpp.

Referenced by toToken().

1773  {
1774 
1775  static const unsigned short string[] =
1776  {
1777  120, 112, 97, 116, 104, 68, 101, 102, 97, 117, 108, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101
1778  };
1779  if(memcmp(&data[0], &string, sizeof(QChar) * 21) == 0)
1780 
1781 
1782  return XPathDefaultNamespace;
1783 
1784 
1785  return NoKeyword;
1786  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier22()

XsdSchemaToken::NodeName XsdSchemaToken::classifier22 ( const QChar *  data)
inlinestaticprivate

Definition at line 1787 of file qxsdschematoken.cpp.

Referenced by toToken().

1789  {
1790 
1791  static const unsigned short string[] =
1792  {
1793  100, 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 65, 112, 112, 108, 121
1794  };
1795  if(memcmp(&data[0], &string, sizeof(QChar) * 22) == 0)
1796 
1797 
1798  return DefaultAttributesApply;
1799 
1800 
1801  return NoKeyword;
1802  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier3()

XsdSchemaToken::NodeName XsdSchemaToken::classifier3 ( const QChar *  data)
inlinestaticprivate

Definition at line 64 of file qxsdschematoken.cpp.

Referenced by toToken().

66  {
67  if (data[0] == 97)
68 
69 
70  {
71  if (data[1] == 108)
72 
73 
74  {
75 
76  if(data[2] == 108)
77 
78 
79  return All;
80 
81  }
82 
83  else if (data[1] == 110)
84 
85 
86  {
87 
88  if(data[2] == 121)
89 
90 
91  return Any;
92 
93  }
94 
95 
96  }
97 
98  else if (data[0] == 107)
99 
100 
101  {
102 
103  static const unsigned short string[] =
104  {
105  101, 121
106  };
107  if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
108 
109 
110  return Key;
111 
112  }
113 
114  else if (data[0] == 114)
115 
116 
117  {
118 
119  static const unsigned short string[] =
120  {
121  101, 102
122  };
123  if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
124 
125 
126  return Ref;
127 
128  }
129 
130  else if (data[0] == 117)
131 
132 
133  {
134 
135  static const unsigned short string[] =
136  {
137  115, 101
138  };
139  if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
140 
141 
142  return Use;
143 
144  }
145 
146 
147 
148  return NoKeyword;
149  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier32()

XsdSchemaToken::NodeName XsdSchemaToken::classifier32 ( const QChar *  data)
inlinestaticprivate

Definition at line 1803 of file qxsdschematoken.cpp.

Referenced by toToken().

1805  {
1806 
1807  static const unsigned short string[] =
1808  {
1809  104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 119, 51, 46, 111, 114, 103, 47, 50, 48, 48, 49, 47, 88, 77, 76, 83, 99, 104, 101, 109, 97
1810  };
1811  if(memcmp(&data[0], &string, sizeof(QChar) * 32) == 0)
1812 
1813 
1814  return XML_NS_SCHEMA_URI;
1815 
1816 
1817  return NoKeyword;
1818  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier4()

XsdSchemaToken::NodeName XsdSchemaToken::classifier4 ( const QChar *  data)
inlinestaticprivate

Definition at line 150 of file qxsdschematoken.cpp.

Referenced by toToken().

152  {
153  if (data[0] == 98)
154 
155 
156  {
157 
158  static const unsigned short string[] =
159  {
160  97, 115, 101
161  };
162  if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
163 
164 
165  return Base;
166 
167  }
168 
169  else if (data[0] == 102)
170 
171 
172  {
173 
174  static const unsigned short string[] =
175  {
176  111, 114, 109
177  };
178  if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
179 
180 
181  return Form;
182 
183  }
184 
185  else if (data[0] == 108)
186 
187 
188  {
189 
190  static const unsigned short string[] =
191  {
192  105, 115, 116
193  };
194  if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
195 
196 
197  return List;
198 
199  }
200 
201  else if (data[0] == 109)
202 
203 
204  {
205 
206  static const unsigned short string[] =
207  {
208  111, 100, 101
209  };
210  if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
211 
212 
213  return Mode;
214 
215  }
216 
217  else if (data[0] == 110)
218 
219 
220  {
221 
222  static const unsigned short string[] =
223  {
224  97, 109, 101
225  };
226  if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
227 
228 
229  return Name;
230 
231  }
232 
233  else if (data[0] == 116)
234 
235 
236  {
237  if (data[1] == 101)
238 
239 
240  {
241 
242  static const unsigned short string[] =
243  {
244  115, 116
245  };
246  if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0)
247 
248 
249  return Test;
250 
251  }
252 
253  else if (data[1] == 121)
254 
255 
256  {
257 
258  static const unsigned short string[] =
259  {
260  112, 101
261  };
262  if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0)
263 
264 
265  return Type;
266 
267  }
268 
269 
270  }
271 
272 
273 
274  return NoKeyword;
275  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier5()

XsdSchemaToken::NodeName XsdSchemaToken::classifier5 ( const QChar *  data)
inlinestaticprivate

Definition at line 276 of file qxsdschematoken.cpp.

Referenced by toToken().

278  {
279  if (data[0] == 98)
280 
281 
282  {
283 
284  static const unsigned short string[] =
285  {
286  108, 111, 99, 107
287  };
288  if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
289 
290 
291  return Block;
292 
293  }
294 
295  else if (data[0] == 102)
296 
297 
298  {
299  if (data[1] == 105)
300 
301 
302  {
303  if (data[2] == 101)
304 
305 
306  {
307 
308  static const unsigned short string[] =
309  {
310  108, 100
311  };
312  if(memcmp(&data[3], &string, sizeof(QChar) * 2) == 0)
313 
314 
315  return Field;
316 
317  }
318 
319  else if (data[2] == 110)
320 
321 
322  {
323 
324  static const unsigned short string[] =
325  {
326  97, 108
327  };
328  if(memcmp(&data[3], &string, sizeof(QChar) * 2) == 0)
329 
330 
331  return Final;
332 
333  }
334 
335  else if (data[2] == 120)
336 
337 
338  {
339 
340  static const unsigned short string[] =
341  {
342  101, 100
343  };
344  if(memcmp(&data[3], &string, sizeof(QChar) * 2) == 0)
345 
346 
347  return Fixed;
348 
349  }
350 
351 
352  }
353 
354 
355  }
356 
357  else if (data[0] == 103)
358 
359 
360  {
361 
362  static const unsigned short string[] =
363  {
364  114, 111, 117, 112
365  };
366  if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
367 
368 
369  return Group;
370 
371  }
372 
373  else if (data[0] == 109)
374 
375 
376  {
377 
378  static const unsigned short string[] =
379  {
380  105, 120, 101, 100
381  };
382  if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
383 
384 
385  return Mixed;
386 
387  }
388 
389  else if (data[0] == 114)
390 
391 
392  {
393 
394  static const unsigned short string[] =
395  {
396  101, 102, 101, 114
397  };
398  if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
399 
400 
401  return Refer;
402 
403  }
404 
405  else if (data[0] == 117)
406 
407 
408  {
409 
410  static const unsigned short string[] =
411  {
412  110, 105, 111, 110
413  };
414  if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
415 
416 
417  return Union;
418 
419  }
420 
421  else if (data[0] == 118)
422 
423 
424  {
425 
426  static const unsigned short string[] =
427  {
428  97, 108, 117, 101
429  };
430  if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
431 
432 
433  return Value;
434 
435  }
436 
437  else if (data[0] == 120)
438 
439 
440  {
441 
442  static const unsigned short string[] =
443  {
444  112, 97, 116, 104
445  };
446  if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
447 
448 
449  return Xpath;
450 
451  }
452 
453 
454 
455  return NoKeyword;
456  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier6()

XsdSchemaToken::NodeName XsdSchemaToken::classifier6 ( const QChar *  data)
inlinestaticprivate

Definition at line 457 of file qxsdschematoken.cpp.

Referenced by toToken().

459  {
460  if (data[0] == 97)
461 
462 
463  {
464 
465  static const unsigned short string[] =
466  {
467  115, 115, 101, 114, 116
468  };
469  if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
470 
471 
472  return Assert;
473 
474  }
475 
476  else if (data[0] == 99)
477 
478 
479  {
480 
481  static const unsigned short string[] =
482  {
483  104, 111, 105, 99, 101
484  };
485  if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
486 
487 
488  return Choice;
489 
490  }
491 
492  else if (data[0] == 105)
493 
494 
495  {
496 
497  static const unsigned short string[] =
498  {
499  109, 112, 111, 114, 116
500  };
501  if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
502 
503 
504  return Import;
505 
506  }
507 
508  else if (data[0] == 107)
509 
510 
511  {
512 
513  static const unsigned short string[] =
514  {
515  101, 121, 114, 101, 102
516  };
517  if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
518 
519 
520  return Keyref;
521 
522  }
523 
524  else if (data[0] == 108)
525 
526 
527  {
528 
529  static const unsigned short string[] =
530  {
531  101, 110, 103, 116, 104
532  };
533  if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
534 
535 
536  return Length;
537 
538  }
539 
540  else if (data[0] == 112)
541 
542 
543  {
544 
545  static const unsigned short string[] =
546  {
547  117, 98, 108, 105, 99
548  };
549  if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
550 
551 
552  return Public;
553 
554  }
555 
556  else if (data[0] == 115)
557 
558 
559  {
560  if (data[1] == 99)
561 
562 
563  {
564 
565  static const unsigned short string[] =
566  {
567  104, 101, 109, 97
568  };
569  if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
570 
571 
572  return Schema;
573 
574  }
575 
576  else if (data[1] == 111)
577 
578 
579  {
580 
581  static const unsigned short string[] =
582  {
583  117, 114, 99, 101
584  };
585  if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
586 
587 
588  return Source;
589 
590  }
591 
592  else if (data[1] == 121)
593 
594 
595  {
596 
597  static const unsigned short string[] =
598  {
599  115, 116, 101, 109
600  };
601  if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
602 
603 
604  return System;
605 
606  }
607 
608 
609  }
610 
611  else if (data[0] == 117)
612 
613 
614  {
615 
616  static const unsigned short string[] =
617  {
618  110, 105, 113, 117, 101
619  };
620  if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
621 
622 
623  return Unique;
624 
625  }
626 
627 
628 
629  return NoKeyword;
630  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier7()

XsdSchemaToken::NodeName XsdSchemaToken::classifier7 ( const QChar *  data)
inlinestaticprivate

Definition at line 631 of file qxsdschematoken.cpp.

Referenced by toToken().

633  {
634  if (data[0] == 97)
635 
636 
637  {
638 
639  static const unsigned short string[] =
640  {
641  112, 112, 105, 110, 102, 111
642  };
643  if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
644 
645 
646  return Appinfo;
647 
648  }
649 
650  else if (data[0] == 100)
651 
652 
653  {
654 
655  static const unsigned short string[] =
656  {
657  101, 102, 97, 117, 108, 116
658  };
659  if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
660 
661 
662  return Default;
663 
664  }
665 
666  else if (data[0] == 101)
667 
668 
669  {
670 
671  static const unsigned short string[] =
672  {
673  108, 101, 109, 101, 110, 116
674  };
675  if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
676 
677 
678  return Element;
679 
680  }
681 
682  else if (data[0] == 105)
683 
684 
685  {
686 
687  static const unsigned short string[] =
688  {
689  110, 99, 108, 117, 100, 101
690  };
691  if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
692 
693 
694  return Include;
695 
696  }
697 
698  else if (data[0] == 112)
699 
700 
701  {
702 
703  static const unsigned short string[] =
704  {
705  97, 116, 116, 101, 114, 110
706  };
707  if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
708 
709 
710  return Pattern;
711 
712  }
713 
714  else if (data[0] == 114)
715 
716 
717  {
718 
719  static const unsigned short string[] =
720  {
721  101, 112, 108, 97, 99, 101
722  };
723  if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
724 
725 
726  return Replace;
727 
728  }
729 
730  else if (data[0] == 118)
731 
732 
733  {
734 
735  static const unsigned short string[] =
736  {
737  101, 114, 115, 105, 111, 110
738  };
739  if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
740 
741 
742  return Version;
743 
744  }
745 
746 
747 
748  return NoKeyword;
749  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier8()

XsdSchemaToken::NodeName XsdSchemaToken::classifier8 ( const QChar *  data)
inlinestaticprivate

Definition at line 750 of file qxsdschematoken.cpp.

Referenced by toToken().

752  {
753  if (data[0] == 97)
754 
755 
756  {
757 
758  static const unsigned short string[] =
759  {
760  98, 115, 116, 114, 97, 99, 116
761  };
762  if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
763 
764 
765  return Abstract;
766 
767  }
768 
769  else if (data[0] == 99)
770 
771 
772  {
773 
774  static const unsigned short string[] =
775  {
776  111, 108, 108, 97, 112, 115, 101
777  };
778  if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
779 
780 
781  return Collapse;
782 
783  }
784 
785  else if (data[0] == 105)
786 
787 
788  {
789 
790  static const unsigned short string[] =
791  {
792  116, 101, 109, 84, 121, 112, 101
793  };
794  if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
795 
796 
797  return ItemType;
798 
799  }
800 
801  else if (data[0] == 110)
802 
803 
804  {
805  if (data[1] == 105)
806 
807 
808  {
809 
810  static const unsigned short string[] =
811  {
812  108, 108, 97, 98, 108, 101
813  };
814  if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
815 
816 
817  return Nillable;
818 
819  }
820 
821  else if (data[1] == 111)
822 
823 
824  {
825  if (data[2] == 116)
826 
827 
828  {
829  if (data[3] == 97)
830 
831 
832  {
833 
834  static const unsigned short string[] =
835  {
836  116, 105, 111, 110
837  };
838  if(memcmp(&data[4], &string, sizeof(QChar) * 4) == 0)
839 
840 
841  return Notation;
842 
843  }
844 
845  else if (data[3] == 81)
846 
847 
848  {
849 
850  static const unsigned short string[] =
851  {
852  78, 97, 109, 101
853  };
854  if(memcmp(&data[4], &string, sizeof(QChar) * 4) == 0)
855 
856 
857  return NotQName;
858 
859  }
860 
861 
862  }
863 
864 
865  }
866 
867 
868  }
869 
870  else if (data[0] == 111)
871 
872 
873  {
874 
875  static const unsigned short string[] =
876  {
877  118, 101, 114, 114, 105, 100, 101
878  };
879  if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
880 
881 
882  return Override;
883 
884  }
885 
886  else if (data[0] == 112)
887 
888 
889  {
890 
891  static const unsigned short string[] =
892  {
893  114, 101, 115, 101, 114, 118, 101
894  };
895  if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
896 
897 
898  return Preserve;
899 
900  }
901 
902  else if (data[0] == 114)
903 
904 
905  {
906 
907  static const unsigned short string[] =
908  {
909  101, 100, 101, 102, 105, 110, 101
910  };
911  if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
912 
913 
914  return Redefine;
915 
916  }
917 
918  else if (data[0] == 115)
919 
920 
921  {
922  if (data[1] == 101)
923 
924 
925  {
926  if (data[2] == 108)
927 
928 
929  {
930 
931  static const unsigned short string[] =
932  {
933  101, 99, 116, 111, 114
934  };
935  if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
936 
937 
938  return Selector;
939 
940  }
941 
942  else if (data[2] == 113)
943 
944 
945  {
946 
947  static const unsigned short string[] =
948  {
949  117, 101, 110, 99, 101
950  };
951  if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
952 
953 
954  return Sequence;
955 
956  }
957 
958 
959  }
960 
961 
962  }
963 
964  else if (data[0] == 120)
965 
966 
967  {
968 
969  static const unsigned short string[] =
970  {
971  109, 108, 58, 108, 97, 110, 103
972  };
973  if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
974 
975 
976  return XmlLanguage;
977 
978  }
979 
980 
981 
982  return NoKeyword;
983  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ classifier9()

XsdSchemaToken::NodeName XsdSchemaToken::classifier9 ( const QChar *  data)
inlinestaticprivate

Definition at line 984 of file qxsdschematoken.cpp.

Referenced by toToken().

986  {
987  if (data[0] == 97)
988 
989 
990  {
991  if (data[1] == 115)
992 
993 
994  {
995 
996  static const unsigned short string[] =
997  {
998  115, 101, 114, 116, 105, 111, 110
999  };
1000  if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
1001 
1002 
1003  return Assertion;
1004 
1005  }
1006 
1007  else if (data[1] == 116)
1008 
1009 
1010  {
1011 
1012  static const unsigned short string[] =
1013  {
1014  116, 114, 105, 98, 117, 116, 101
1015  };
1016  if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
1017 
1018 
1019  return Attribute;
1020 
1021  }
1022 
1023 
1024  }
1025 
1026  else if (data[0] == 101)
1027 
1028 
1029  {
1030 
1031  static const unsigned short string[] =
1032  {
1033  120, 116, 101, 110, 115, 105, 111, 110
1034  };
1035  if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
1036 
1037 
1038  return Extension;
1039 
1040  }
1041 
1042  else if (data[0] == 109)
1043 
1044 
1045  {
1046  if (data[1] == 97)
1047 
1048 
1049  {
1050  if (data[2] == 120)
1051 
1052 
1053  {
1054  if (data[3] == 76)
1055 
1056 
1057  {
1058 
1059  static const unsigned short string[] =
1060  {
1061  101, 110, 103, 116, 104
1062  };
1063  if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0)
1064 
1065 
1066  return MaxLength;
1067 
1068  }
1069 
1070  else if (data[3] == 79)
1071 
1072 
1073  {
1074 
1075  static const unsigned short string[] =
1076  {
1077  99, 99, 117, 114, 115
1078  };
1079  if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0)
1080 
1081 
1082  return MaxOccurs;
1083 
1084  }
1085 
1086 
1087  }
1088 
1089 
1090  }
1091 
1092  else if (data[1] == 105)
1093 
1094 
1095  {
1096  if (data[2] == 110)
1097 
1098 
1099  {
1100  if (data[3] == 76)
1101 
1102 
1103  {
1104 
1105  static const unsigned short string[] =
1106  {
1107  101, 110, 103, 116, 104
1108  };
1109  if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0)
1110 
1111 
1112  return MinLength;
1113 
1114  }
1115 
1116  else if (data[3] == 79)
1117 
1118 
1119  {
1120 
1121  static const unsigned short string[] =
1122  {
1123  99, 99, 117, 114, 115
1124  };
1125  if(memcmp(&data[4], &string, sizeof(QChar) * 5) == 0)
1126 
1127 
1128  return MinOccurs;
1129 
1130  }
1131 
1132 
1133  }
1134 
1135 
1136  }
1137 
1138 
1139  }
1140 
1141  else if (data[0] == 110)
1142 
1143 
1144  {
1145 
1146  static const unsigned short string[] =
1147  {
1148  97, 109, 101, 115, 112, 97, 99, 101
1149  };
1150  if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
1151 
1152 
1153  return Namespace;
1154 
1155  }
1156 
1157 
1158 
1159  return NoKeyword;
1160  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72

◆ toString()

QString XsdSchemaToken::toString ( NodeName  token)
static

Definition at line 1910 of file qxsdschematoken.cpp.

Referenced by QPatternist::XsdSchemaChecker::checkConstrainingFacets(), QPatternist::TagValidationHandler::finalize(), QPatternist::XsdTypeChecker::normalizedValue(), QPatternist::XsdSchemaParser::parseList(), QPatternist::XsdSchemaParser::parseNotation(), QPatternist::XsdSchemaParser::parseUnknown(), QPatternist::XsdSchemaParser::parseWhiteSpaceFacet(), QPatternist::XsdSchemaContext::setupBuiltinTypesFacetList(), QPatternist::TagValidationHandler::validate(), and QPatternist::XsdSchemaTypesFactory::XsdSchemaTypesFactory().

1911  {
1912  const unsigned short *data = 0;
1913  int length = 0;
1914 
1915  switch(token)
1916  {
1917 
1918  case Abstract:
1919  {
1920  static const unsigned short staticallyStoredAbstract[] =
1921  {
1922  97, 98, 115, 116, 114, 97, 99, 116, 0
1923  };
1924  data = staticallyStoredAbstract;
1925  length = 8;
1926  break;
1927  }
1928 
1929  case All:
1930  {
1931  static const unsigned short staticallyStoredAll[] =
1932  {
1933  97, 108, 108, 0
1934  };
1935  data = staticallyStoredAll;
1936  length = 3;
1937  break;
1938  }
1939 
1940  case Alternative:
1941  {
1942  static const unsigned short staticallyStoredAlternative[] =
1943  {
1944  97, 108, 116, 101, 114, 110, 97, 116, 105, 118, 101, 0
1945  };
1946  data = staticallyStoredAlternative;
1947  length = 11;
1948  break;
1949  }
1950 
1951  case Annotation:
1952  {
1953  static const unsigned short staticallyStoredAnnotation[] =
1954  {
1955  97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 0
1956  };
1957  data = staticallyStoredAnnotation;
1958  length = 10;
1959  break;
1960  }
1961 
1962  case Any:
1963  {
1964  static const unsigned short staticallyStoredAny[] =
1965  {
1966  97, 110, 121, 0
1967  };
1968  data = staticallyStoredAny;
1969  length = 3;
1970  break;
1971  }
1972 
1973  case AnyAttribute:
1974  {
1975  static const unsigned short staticallyStoredAnyAttribute[] =
1976  {
1977  97, 110, 121, 65, 116, 116, 114, 105, 98, 117, 116, 101, 0
1978  };
1979  data = staticallyStoredAnyAttribute;
1980  length = 12;
1981  break;
1982  }
1983 
1984  case Appinfo:
1985  {
1986  static const unsigned short staticallyStoredAppinfo[] =
1987  {
1988  97, 112, 112, 105, 110, 102, 111, 0
1989  };
1990  data = staticallyStoredAppinfo;
1991  length = 7;
1992  break;
1993  }
1994 
1995  case AppliesToEmpty:
1996  {
1997  static const unsigned short staticallyStoredAppliesToEmpty[] =
1998  {
1999  97, 112, 112, 108, 105, 101, 115, 84, 111, 69, 109, 112, 116, 121, 0
2000  };
2001  data = staticallyStoredAppliesToEmpty;
2002  length = 14;
2003  break;
2004  }
2005 
2006  case Assert:
2007  {
2008  static const unsigned short staticallyStoredAssert[] =
2009  {
2010  97, 115, 115, 101, 114, 116, 0
2011  };
2012  data = staticallyStoredAssert;
2013  length = 6;
2014  break;
2015  }
2016 
2017  case Assertion:
2018  {
2019  static const unsigned short staticallyStoredAssertion[] =
2020  {
2021  97, 115, 115, 101, 114, 116, 105, 111, 110, 0
2022  };
2023  data = staticallyStoredAssertion;
2024  length = 9;
2025  break;
2026  }
2027 
2028  case Attribute:
2029  {
2030  static const unsigned short staticallyStoredAttribute[] =
2031  {
2032  97, 116, 116, 114, 105, 98, 117, 116, 101, 0
2033  };
2034  data = staticallyStoredAttribute;
2035  length = 9;
2036  break;
2037  }
2038 
2039  case AttributeFormDefault:
2040  {
2041  static const unsigned short staticallyStoredAttributeFormDefault[] =
2042  {
2043  97, 116, 116, 114, 105, 98, 117, 116, 101, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116, 0
2044  };
2045  data = staticallyStoredAttributeFormDefault;
2046  length = 20;
2047  break;
2048  }
2049 
2050  case AttributeGroup:
2051  {
2052  static const unsigned short staticallyStoredAttributeGroup[] =
2053  {
2054  97, 116, 116, 114, 105, 98, 117, 116, 101, 71, 114, 111, 117, 112, 0
2055  };
2056  data = staticallyStoredAttributeGroup;
2057  length = 14;
2058  break;
2059  }
2060 
2061  case Base:
2062  {
2063  static const unsigned short staticallyStoredBase[] =
2064  {
2065  98, 97, 115, 101, 0
2066  };
2067  data = staticallyStoredBase;
2068  length = 4;
2069  break;
2070  }
2071 
2072  case Block:
2073  {
2074  static const unsigned short staticallyStoredBlock[] =
2075  {
2076  98, 108, 111, 99, 107, 0
2077  };
2078  data = staticallyStoredBlock;
2079  length = 5;
2080  break;
2081  }
2082 
2083  case BlockDefault:
2084  {
2085  static const unsigned short staticallyStoredBlockDefault[] =
2086  {
2087  98, 108, 111, 99, 107, 68, 101, 102, 97, 117, 108, 116, 0
2088  };
2089  data = staticallyStoredBlockDefault;
2090  length = 12;
2091  break;
2092  }
2093 
2094  case Choice:
2095  {
2096  static const unsigned short staticallyStoredChoice[] =
2097  {
2098  99, 104, 111, 105, 99, 101, 0
2099  };
2100  data = staticallyStoredChoice;
2101  length = 6;
2102  break;
2103  }
2104 
2105  case Collapse:
2106  {
2107  static const unsigned short staticallyStoredCollapse[] =
2108  {
2109  99, 111, 108, 108, 97, 112, 115, 101, 0
2110  };
2111  data = staticallyStoredCollapse;
2112  length = 8;
2113  break;
2114  }
2115 
2116  case ComplexContent:
2117  {
2118  static const unsigned short staticallyStoredComplexContent[] =
2119  {
2120  99, 111, 109, 112, 108, 101, 120, 67, 111, 110, 116, 101, 110, 116, 0
2121  };
2122  data = staticallyStoredComplexContent;
2123  length = 14;
2124  break;
2125  }
2126 
2127  case ComplexType:
2128  {
2129  static const unsigned short staticallyStoredComplexType[] =
2130  {
2131  99, 111, 109, 112, 108, 101, 120, 84, 121, 112, 101, 0
2132  };
2133  data = staticallyStoredComplexType;
2134  length = 11;
2135  break;
2136  }
2137 
2138  case Default:
2139  {
2140  static const unsigned short staticallyStoredDefault[] =
2141  {
2142  100, 101, 102, 97, 117, 108, 116, 0
2143  };
2144  data = staticallyStoredDefault;
2145  length = 7;
2146  break;
2147  }
2148 
2149  case DefaultAttributes:
2150  {
2151  static const unsigned short staticallyStoredDefaultAttributes[] =
2152  {
2153  100, 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 0
2154  };
2155  data = staticallyStoredDefaultAttributes;
2156  length = 17;
2157  break;
2158  }
2159 
2160  case DefaultAttributesApply:
2161  {
2162  static const unsigned short staticallyStoredDefaultAttributesApply[] =
2163  {
2164  100, 101, 102, 97, 117, 108, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 65, 112, 112, 108, 121, 0
2165  };
2166  data = staticallyStoredDefaultAttributesApply;
2167  length = 22;
2168  break;
2169  }
2170 
2171  case DefaultOpenContent:
2172  {
2173  static const unsigned short staticallyStoredDefaultOpenContent[] =
2174  {
2175  100, 101, 102, 97, 117, 108, 116, 79, 112, 101, 110, 67, 111, 110, 116, 101, 110, 116, 0
2176  };
2177  data = staticallyStoredDefaultOpenContent;
2178  length = 18;
2179  break;
2180  }
2181 
2182  case Documentation:
2183  {
2184  static const unsigned short staticallyStoredDocumentation[] =
2185  {
2186  100, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 0
2187  };
2188  data = staticallyStoredDocumentation;
2189  length = 13;
2190  break;
2191  }
2192 
2193  case Element:
2194  {
2195  static const unsigned short staticallyStoredElement[] =
2196  {
2197  101, 108, 101, 109, 101, 110, 116, 0
2198  };
2199  data = staticallyStoredElement;
2200  length = 7;
2201  break;
2202  }
2203 
2204  case ElementFormDefault:
2205  {
2206  static const unsigned short staticallyStoredElementFormDefault[] =
2207  {
2208  101, 108, 101, 109, 101, 110, 116, 70, 111, 114, 109, 68, 101, 102, 97, 117, 108, 116, 0
2209  };
2210  data = staticallyStoredElementFormDefault;
2211  length = 18;
2212  break;
2213  }
2214 
2215  case Enumeration:
2216  {
2217  static const unsigned short staticallyStoredEnumeration[] =
2218  {
2219  101, 110, 117, 109, 101, 114, 97, 116, 105, 111, 110, 0
2220  };
2221  data = staticallyStoredEnumeration;
2222  length = 11;
2223  break;
2224  }
2225 
2226  case Extension:
2227  {
2228  static const unsigned short staticallyStoredExtension[] =
2229  {
2230  101, 120, 116, 101, 110, 115, 105, 111, 110, 0
2231  };
2232  data = staticallyStoredExtension;
2233  length = 9;
2234  break;
2235  }
2236 
2237  case Field:
2238  {
2239  static const unsigned short staticallyStoredField[] =
2240  {
2241  102, 105, 101, 108, 100, 0
2242  };
2243  data = staticallyStoredField;
2244  length = 5;
2245  break;
2246  }
2247 
2248  case Final:
2249  {
2250  static const unsigned short staticallyStoredFinal[] =
2251  {
2252  102, 105, 110, 97, 108, 0
2253  };
2254  data = staticallyStoredFinal;
2255  length = 5;
2256  break;
2257  }
2258 
2259  case FinalDefault:
2260  {
2261  static const unsigned short staticallyStoredFinalDefault[] =
2262  {
2263  102, 105, 110, 97, 108, 68, 101, 102, 97, 117, 108, 116, 0
2264  };
2265  data = staticallyStoredFinalDefault;
2266  length = 12;
2267  break;
2268  }
2269 
2270  case Fixed:
2271  {
2272  static const unsigned short staticallyStoredFixed[] =
2273  {
2274  102, 105, 120, 101, 100, 0
2275  };
2276  data = staticallyStoredFixed;
2277  length = 5;
2278  break;
2279  }
2280 
2281  case Form:
2282  {
2283  static const unsigned short staticallyStoredForm[] =
2284  {
2285  102, 111, 114, 109, 0
2286  };
2287  data = staticallyStoredForm;
2288  length = 4;
2289  break;
2290  }
2291 
2292  case FractionDigits:
2293  {
2294  static const unsigned short staticallyStoredFractionDigits[] =
2295  {
2296  102, 114, 97, 99, 116, 105, 111, 110, 68, 105, 103, 105, 116, 115, 0
2297  };
2298  data = staticallyStoredFractionDigits;
2299  length = 14;
2300  break;
2301  }
2302 
2303  case Group:
2304  {
2305  static const unsigned short staticallyStoredGroup[] =
2306  {
2307  103, 114, 111, 117, 112, 0
2308  };
2309  data = staticallyStoredGroup;
2310  length = 5;
2311  break;
2312  }
2313 
2314  case Id:
2315  {
2316  static const unsigned short staticallyStoredId[] =
2317  {
2318  105, 100, 0
2319  };
2320  data = staticallyStoredId;
2321  length = 2;
2322  break;
2323  }
2324 
2325  case Import:
2326  {
2327  static const unsigned short staticallyStoredImport[] =
2328  {
2329  105, 109, 112, 111, 114, 116, 0
2330  };
2331  data = staticallyStoredImport;
2332  length = 6;
2333  break;
2334  }
2335 
2336  case Include:
2337  {
2338  static const unsigned short staticallyStoredInclude[] =
2339  {
2340  105, 110, 99, 108, 117, 100, 101, 0
2341  };
2342  data = staticallyStoredInclude;
2343  length = 7;
2344  break;
2345  }
2346 
2347  case ItemType:
2348  {
2349  static const unsigned short staticallyStoredItemType[] =
2350  {
2351  105, 116, 101, 109, 84, 121, 112, 101, 0
2352  };
2353  data = staticallyStoredItemType;
2354  length = 8;
2355  break;
2356  }
2357 
2358  case Key:
2359  {
2360  static const unsigned short staticallyStoredKey[] =
2361  {
2362  107, 101, 121, 0
2363  };
2364  data = staticallyStoredKey;
2365  length = 3;
2366  break;
2367  }
2368 
2369  case Keyref:
2370  {
2371  static const unsigned short staticallyStoredKeyref[] =
2372  {
2373  107, 101, 121, 114, 101, 102, 0
2374  };
2375  data = staticallyStoredKeyref;
2376  length = 6;
2377  break;
2378  }
2379 
2380  case Length:
2381  {
2382  static const unsigned short staticallyStoredLength[] =
2383  {
2384  108, 101, 110, 103, 116, 104, 0
2385  };
2386  data = staticallyStoredLength;
2387  length = 6;
2388  break;
2389  }
2390 
2391  case List:
2392  {
2393  static const unsigned short staticallyStoredList[] =
2394  {
2395  108, 105, 115, 116, 0
2396  };
2397  data = staticallyStoredList;
2398  length = 4;
2399  break;
2400  }
2401 
2402  case MaxExclusive:
2403  {
2404  static const unsigned short staticallyStoredMaxExclusive[] =
2405  {
2406  109, 97, 120, 69, 120, 99, 108, 117, 115, 105, 118, 101, 0
2407  };
2408  data = staticallyStoredMaxExclusive;
2409  length = 12;
2410  break;
2411  }
2412 
2413  case MaxInclusive:
2414  {
2415  static const unsigned short staticallyStoredMaxInclusive[] =
2416  {
2417  109, 97, 120, 73, 110, 99, 108, 117, 115, 105, 118, 101, 0
2418  };
2419  data = staticallyStoredMaxInclusive;
2420  length = 12;
2421  break;
2422  }
2423 
2424  case MaxLength:
2425  {
2426  static const unsigned short staticallyStoredMaxLength[] =
2427  {
2428  109, 97, 120, 76, 101, 110, 103, 116, 104, 0
2429  };
2430  data = staticallyStoredMaxLength;
2431  length = 9;
2432  break;
2433  }
2434 
2435  case MaxOccurs:
2436  {
2437  static const unsigned short staticallyStoredMaxOccurs[] =
2438  {
2439  109, 97, 120, 79, 99, 99, 117, 114, 115, 0
2440  };
2441  data = staticallyStoredMaxOccurs;
2442  length = 9;
2443  break;
2444  }
2445 
2446  case MemberTypes:
2447  {
2448  static const unsigned short staticallyStoredMemberTypes[] =
2449  {
2450  109, 101, 109, 98, 101, 114, 84, 121, 112, 101, 115, 0
2451  };
2452  data = staticallyStoredMemberTypes;
2453  length = 11;
2454  break;
2455  }
2456 
2457  case MinExclusive:
2458  {
2459  static const unsigned short staticallyStoredMinExclusive[] =
2460  {
2461  109, 105, 110, 69, 120, 99, 108, 117, 115, 105, 118, 101, 0
2462  };
2463  data = staticallyStoredMinExclusive;
2464  length = 12;
2465  break;
2466  }
2467 
2468  case MinInclusive:
2469  {
2470  static const unsigned short staticallyStoredMinInclusive[] =
2471  {
2472  109, 105, 110, 73, 110, 99, 108, 117, 115, 105, 118, 101, 0
2473  };
2474  data = staticallyStoredMinInclusive;
2475  length = 12;
2476  break;
2477  }
2478 
2479  case MinLength:
2480  {
2481  static const unsigned short staticallyStoredMinLength[] =
2482  {
2483  109, 105, 110, 76, 101, 110, 103, 116, 104, 0
2484  };
2485  data = staticallyStoredMinLength;
2486  length = 9;
2487  break;
2488  }
2489 
2490  case MinOccurs:
2491  {
2492  static const unsigned short staticallyStoredMinOccurs[] =
2493  {
2494  109, 105, 110, 79, 99, 99, 117, 114, 115, 0
2495  };
2496  data = staticallyStoredMinOccurs;
2497  length = 9;
2498  break;
2499  }
2500 
2501  case Mixed:
2502  {
2503  static const unsigned short staticallyStoredMixed[] =
2504  {
2505  109, 105, 120, 101, 100, 0
2506  };
2507  data = staticallyStoredMixed;
2508  length = 5;
2509  break;
2510  }
2511 
2512  case Mode:
2513  {
2514  static const unsigned short staticallyStoredMode[] =
2515  {
2516  109, 111, 100, 101, 0
2517  };
2518  data = staticallyStoredMode;
2519  length = 4;
2520  break;
2521  }
2522 
2523  case Name:
2524  {
2525  static const unsigned short staticallyStoredName[] =
2526  {
2527  110, 97, 109, 101, 0
2528  };
2529  data = staticallyStoredName;
2530  length = 4;
2531  break;
2532  }
2533 
2534  case Namespace:
2535  {
2536  static const unsigned short staticallyStoredNamespace[] =
2537  {
2538  110, 97, 109, 101, 115, 112, 97, 99, 101, 0
2539  };
2540  data = staticallyStoredNamespace;
2541  length = 9;
2542  break;
2543  }
2544 
2545  case Nillable:
2546  {
2547  static const unsigned short staticallyStoredNillable[] =
2548  {
2549  110, 105, 108, 108, 97, 98, 108, 101, 0
2550  };
2551  data = staticallyStoredNillable;
2552  length = 8;
2553  break;
2554  }
2555 
2556  case NotNamespace:
2557  {
2558  static const unsigned short staticallyStoredNotNamespace[] =
2559  {
2560  110, 111, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 0
2561  };
2562  data = staticallyStoredNotNamespace;
2563  length = 12;
2564  break;
2565  }
2566 
2567  case NotQName:
2568  {
2569  static const unsigned short staticallyStoredNotQName[] =
2570  {
2571  110, 111, 116, 81, 78, 97, 109, 101, 0
2572  };
2573  data = staticallyStoredNotQName;
2574  length = 8;
2575  break;
2576  }
2577 
2578  case Notation:
2579  {
2580  static const unsigned short staticallyStoredNotation[] =
2581  {
2582  110, 111, 116, 97, 116, 105, 111, 110, 0
2583  };
2584  data = staticallyStoredNotation;
2585  length = 8;
2586  break;
2587  }
2588 
2589  case OpenContent:
2590  {
2591  static const unsigned short staticallyStoredOpenContent[] =
2592  {
2593  111, 112, 101, 110, 67, 111, 110, 116, 101, 110, 116, 0
2594  };
2595  data = staticallyStoredOpenContent;
2596  length = 11;
2597  break;
2598  }
2599 
2600  case Override:
2601  {
2602  static const unsigned short staticallyStoredOverride[] =
2603  {
2604  111, 118, 101, 114, 114, 105, 100, 101, 0
2605  };
2606  data = staticallyStoredOverride;
2607  length = 8;
2608  break;
2609  }
2610 
2611  case Pattern:
2612  {
2613  static const unsigned short staticallyStoredPattern[] =
2614  {
2615  112, 97, 116, 116, 101, 114, 110, 0
2616  };
2617  data = staticallyStoredPattern;
2618  length = 7;
2619  break;
2620  }
2621 
2622  case Preserve:
2623  {
2624  static const unsigned short staticallyStoredPreserve[] =
2625  {
2626  112, 114, 101, 115, 101, 114, 118, 101, 0
2627  };
2628  data = staticallyStoredPreserve;
2629  length = 8;
2630  break;
2631  }
2632 
2633  case ProcessContents:
2634  {
2635  static const unsigned short staticallyStoredProcessContents[] =
2636  {
2637  112, 114, 111, 99, 101, 115, 115, 67, 111, 110, 116, 101, 110, 116, 115, 0
2638  };
2639  data = staticallyStoredProcessContents;
2640  length = 15;
2641  break;
2642  }
2643 
2644  case Public:
2645  {
2646  static const unsigned short staticallyStoredPublic[] =
2647  {
2648  112, 117, 98, 108, 105, 99, 0
2649  };
2650  data = staticallyStoredPublic;
2651  length = 6;
2652  break;
2653  }
2654 
2655  case Redefine:
2656  {
2657  static const unsigned short staticallyStoredRedefine[] =
2658  {
2659  114, 101, 100, 101, 102, 105, 110, 101, 0
2660  };
2661  data = staticallyStoredRedefine;
2662  length = 8;
2663  break;
2664  }
2665 
2666  case Ref:
2667  {
2668  static const unsigned short staticallyStoredRef[] =
2669  {
2670  114, 101, 102, 0
2671  };
2672  data = staticallyStoredRef;
2673  length = 3;
2674  break;
2675  }
2676 
2677  case Refer:
2678  {
2679  static const unsigned short staticallyStoredRefer[] =
2680  {
2681  114, 101, 102, 101, 114, 0
2682  };
2683  data = staticallyStoredRefer;
2684  length = 5;
2685  break;
2686  }
2687 
2688  case Replace:
2689  {
2690  static const unsigned short staticallyStoredReplace[] =
2691  {
2692  114, 101, 112, 108, 97, 99, 101, 0
2693  };
2694  data = staticallyStoredReplace;
2695  length = 7;
2696  break;
2697  }
2698 
2699  case Restriction:
2700  {
2701  static const unsigned short staticallyStoredRestriction[] =
2702  {
2703  114, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 0
2704  };
2705  data = staticallyStoredRestriction;
2706  length = 11;
2707  break;
2708  }
2709 
2710  case Schema:
2711  {
2712  static const unsigned short staticallyStoredSchema[] =
2713  {
2714  115, 99, 104, 101, 109, 97, 0
2715  };
2716  data = staticallyStoredSchema;
2717  length = 6;
2718  break;
2719  }
2720 
2721  case SchemaLocation:
2722  {
2723  static const unsigned short staticallyStoredSchemaLocation[] =
2724  {
2725  115, 99, 104, 101, 109, 97, 76, 111, 99, 97, 116, 105, 111, 110, 0
2726  };
2727  data = staticallyStoredSchemaLocation;
2728  length = 14;
2729  break;
2730  }
2731 
2732  case Selector:
2733  {
2734  static const unsigned short staticallyStoredSelector[] =
2735  {
2736  115, 101, 108, 101, 99, 116, 111, 114, 0
2737  };
2738  data = staticallyStoredSelector;
2739  length = 8;
2740  break;
2741  }
2742 
2743  case Sequence:
2744  {
2745  static const unsigned short staticallyStoredSequence[] =
2746  {
2747  115, 101, 113, 117, 101, 110, 99, 101, 0
2748  };
2749  data = staticallyStoredSequence;
2750  length = 8;
2751  break;
2752  }
2753 
2754  case SimpleContent:
2755  {
2756  static const unsigned short staticallyStoredSimpleContent[] =
2757  {
2758  115, 105, 109, 112, 108, 101, 67, 111, 110, 116, 101, 110, 116, 0
2759  };
2760  data = staticallyStoredSimpleContent;
2761  length = 13;
2762  break;
2763  }
2764 
2765  case SimpleType:
2766  {
2767  static const unsigned short staticallyStoredSimpleType[] =
2768  {
2769  115, 105, 109, 112, 108, 101, 84, 121, 112, 101, 0
2770  };
2771  data = staticallyStoredSimpleType;
2772  length = 10;
2773  break;
2774  }
2775 
2776  case Source:
2777  {
2778  static const unsigned short staticallyStoredSource[] =
2779  {
2780  115, 111, 117, 114, 99, 101, 0
2781  };
2782  data = staticallyStoredSource;
2783  length = 6;
2784  break;
2785  }
2786 
2787  case SubstitutionGroup:
2788  {
2789  static const unsigned short staticallyStoredSubstitutionGroup[] =
2790  {
2791  115, 117, 98, 115, 116, 105, 116, 117, 116, 105, 111, 110, 71, 114, 111, 117, 112, 0
2792  };
2793  data = staticallyStoredSubstitutionGroup;
2794  length = 17;
2795  break;
2796  }
2797 
2798  case System:
2799  {
2800  static const unsigned short staticallyStoredSystem[] =
2801  {
2802  115, 121, 115, 116, 101, 109, 0
2803  };
2804  data = staticallyStoredSystem;
2805  length = 6;
2806  break;
2807  }
2808 
2809  case TargetNamespace:
2810  {
2811  static const unsigned short staticallyStoredTargetNamespace[] =
2812  {
2813  116, 97, 114, 103, 101, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 0
2814  };
2815  data = staticallyStoredTargetNamespace;
2816  length = 15;
2817  break;
2818  }
2819 
2820  case Test:
2821  {
2822  static const unsigned short staticallyStoredTest[] =
2823  {
2824  116, 101, 115, 116, 0
2825  };
2826  data = staticallyStoredTest;
2827  length = 4;
2828  break;
2829  }
2830 
2831  case TotalDigits:
2832  {
2833  static const unsigned short staticallyStoredTotalDigits[] =
2834  {
2835  116, 111, 116, 97, 108, 68, 105, 103, 105, 116, 115, 0
2836  };
2837  data = staticallyStoredTotalDigits;
2838  length = 11;
2839  break;
2840  }
2841 
2842  case Type:
2843  {
2844  static const unsigned short staticallyStoredType[] =
2845  {
2846  116, 121, 112, 101, 0
2847  };
2848  data = staticallyStoredType;
2849  length = 4;
2850  break;
2851  }
2852 
2853  case Union:
2854  {
2855  static const unsigned short staticallyStoredUnion[] =
2856  {
2857  117, 110, 105, 111, 110, 0
2858  };
2859  data = staticallyStoredUnion;
2860  length = 5;
2861  break;
2862  }
2863 
2864  case Unique:
2865  {
2866  static const unsigned short staticallyStoredUnique[] =
2867  {
2868  117, 110, 105, 113, 117, 101, 0
2869  };
2870  data = staticallyStoredUnique;
2871  length = 6;
2872  break;
2873  }
2874 
2875  case Use:
2876  {
2877  static const unsigned short staticallyStoredUse[] =
2878  {
2879  117, 115, 101, 0
2880  };
2881  data = staticallyStoredUse;
2882  length = 3;
2883  break;
2884  }
2885 
2886  case Value:
2887  {
2888  static const unsigned short staticallyStoredValue[] =
2889  {
2890  118, 97, 108, 117, 101, 0
2891  };
2892  data = staticallyStoredValue;
2893  length = 5;
2894  break;
2895  }
2896 
2897  case Version:
2898  {
2899  static const unsigned short staticallyStoredVersion[] =
2900  {
2901  118, 101, 114, 115, 105, 111, 110, 0
2902  };
2903  data = staticallyStoredVersion;
2904  length = 7;
2905  break;
2906  }
2907 
2908  case WhiteSpace:
2909  {
2910  static const unsigned short staticallyStoredWhiteSpace[] =
2911  {
2912  119, 104, 105, 116, 101, 83, 112, 97, 99, 101, 0
2913  };
2914  data = staticallyStoredWhiteSpace;
2915  length = 10;
2916  break;
2917  }
2918 
2919  case XML_NS_SCHEMA_URI:
2920  {
2921  static const unsigned short staticallyStoredXML_NS_SCHEMA_URI[] =
2922  {
2923  104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 119, 51, 46, 111, 114, 103, 47, 50, 48, 48, 49, 47, 88, 77, 76, 83, 99, 104, 101, 109, 97, 0
2924  };
2925  data = staticallyStoredXML_NS_SCHEMA_URI;
2926  length = 32;
2927  break;
2928  }
2929 
2930  case XPathDefaultNamespace:
2931  {
2932  static const unsigned short staticallyStoredXPathDefaultNamespace[] =
2933  {
2934  120, 112, 97, 116, 104, 68, 101, 102, 97, 117, 108, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 0
2935  };
2936  data = staticallyStoredXPathDefaultNamespace;
2937  length = 21;
2938  break;
2939  }
2940 
2941  case XmlLanguage:
2942  {
2943  static const unsigned short staticallyStoredXmlLanguage[] =
2944  {
2945  120, 109, 108, 58, 108, 97, 110, 103, 0
2946  };
2947  data = staticallyStoredXmlLanguage;
2948  length = 8;
2949  break;
2950  }
2951 
2952  case Xpath:
2953  {
2954  static const unsigned short staticallyStoredXpath[] =
2955  {
2956  120, 112, 97, 116, 104, 0
2957  };
2958  data = staticallyStoredXpath;
2959  length = 5;
2960  break;
2961  }
2962 
2963  default:
2964  /* It's either the default token, or an undefined enum
2965  * value. We silence a compiler warning, and return the
2966  * empty string. */
2967  ;
2968  }
2969 
2970  union
2971  {
2972  const unsigned short *data;
2973  const QChar *asQChar;
2974  } converter;
2975  converter.data = data;
2976 
2977  return QString::fromRawData(converter.asQChar, length);
2978  }
QChar
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72
QString::fromRawData
static QString fromRawData(const QChar *, int size)
Constructs a QString that uses the first size Unicode characters in the array unicode.
Definition: qstring.cpp:7673
data
static const char * data(const QByteArray &arr)
Definition: qdbusmessage.cpp:60

◆ toToken() [1/3]

XsdSchemaToken::NodeName XsdSchemaToken::toToken ( const QString &  value)
inlinestatic

Definition at line 196 of file qxsdschematoken_p.h.

Referenced by QPatternist::ElementNamespaceHandler::ElementNamespaceHandler(), QPatternist::XsdSchemaParser::parse(), QPatternist::XsdSchemaParser::parseAll(), QPatternist::XsdSchemaParser::parseAlternative(), QPatternist::XsdSchemaParser::parseAnnotation(), QPatternist::XsdSchemaParser::parseAny(), QPatternist::XsdSchemaParser::parseAnyAttribute(), QPatternist::XsdSchemaParser::parseAssertion(), QPatternist::XsdSchemaParser::parseChoice(), QPatternist::XsdSchemaParser::parseComplexContent(), QPatternist::XsdSchemaParser::parseComplexContentExtension(), QPatternist::XsdSchemaParser::parseComplexContentRestriction(), QPatternist::XsdSchemaParser::parseDefaultOpenContent(), QPatternist::XsdSchemaParser::parseEnumerationFacet(), QPatternist::XsdSchemaParser::parseField(), QPatternist::XsdSchemaParser::parseFractionDigitsFacet(), QPatternist::XsdSchemaParser::parseGlobalAttribute(), QPatternist::XsdSchemaParser::parseGlobalComplexType(), QPatternist::XsdSchemaParser::parseGlobalElement(), QPatternist::XsdSchemaParser::parseGlobalSimpleType(), QPatternist::XsdSchemaParser::parseImport(), QPatternist::XsdSchemaParser::parseInclude(), QPatternist::XsdSchemaParser::parseKey(), QPatternist::XsdSchemaParser::parseKeyRef(), QPatternist::XsdSchemaParser::parseLengthFacet(), QPatternist::XsdSchemaParser::parseList(), QPatternist::XsdSchemaParser::parseLocalAll(), QPatternist::XsdSchemaParser::parseLocalAttribute(), QPatternist::XsdSchemaParser::parseLocalChoice(), QPatternist::XsdSchemaParser::parseLocalComplexType(), QPatternist::XsdSchemaParser::parseLocalElement(), QPatternist::XsdSchemaParser::parseLocalSequence(), QPatternist::XsdSchemaParser::parseLocalSimpleType(), QPatternist::XsdSchemaParser::parseMaxExclusiveFacet(), QPatternist::XsdSchemaParser::parseMaxInclusiveFacet(), QPatternist::XsdSchemaParser::parseMaxLengthFacet(), QPatternist::XsdSchemaParser::parseMinExclusiveFacet(), QPatternist::XsdSchemaParser::parseMinInclusiveFacet(), QPatternist::XsdSchemaParser::parseMinLengthFacet(), QPatternist::XsdSchemaParser::parseNamedAttributeGroup(), QPatternist::XsdSchemaParser::parseNamedGroup(), QPatternist::XsdSchemaParser::parseNotation(), QPatternist::XsdSchemaParser::parseOpenContent(), QPatternist::XsdSchemaParser::parsePatternFacet(), QPatternist::XsdSchemaParser::parseRedefine(), QPatternist::XsdSchemaParser::parseReferredAttributeGroup(), QPatternist::XsdSchemaParser::parseReferredGroup(), QPatternist::XsdSchemaParser::parseSchema(), QPatternist::XsdSchemaParser::parseSelector(), QPatternist::XsdSchemaParser::parseSequence(), QPatternist::XsdSchemaParser::parseSimpleContent(), QPatternist::XsdSchemaParser::parseSimpleContentExtension(), QPatternist::XsdSchemaParser::parseSimpleContentRestriction(), QPatternist::XsdSchemaParser::parseSimpleRestriction(), QPatternist::XsdSchemaParser::parseTotalDigitsFacet(), QPatternist::XsdSchemaParser::parseUnion(), QPatternist::XsdSchemaParser::parseUnique(), QPatternist::XsdSchemaParser::parseWhiteSpaceFacet(), and toToken().

197  {
198  return toToken(value.constData(), value.length());
199  }
XsdSchemaToken::toToken
static NodeName toToken(const QString &value)
Definition: qxsdschematoken_p.h:196
QString::length
int length() const
Returns the number of characters in this string.
Definition: qstring.h:696
QString::constData
const QChar * constData() const
Returns a pointer to the data stored in the QString.
Definition: qstring.h:712

◆ toToken() [2/3]

XsdSchemaToken::NodeName XsdSchemaToken::toToken ( const QStringRef &  value)
inlinestatic

Definition at line 201 of file qxsdschematoken_p.h.

202  {
203  return toToken(value.constData(), value.length());
204  }
QStringRef::length
int length() const
Returns the number of characters referred to by the string reference.
Definition: qstring.h:1116
XsdSchemaToken::toToken
static NodeName toToken(const QString &value)
Definition: qxsdschematoken_p.h:196
QStringRef::constData
const QChar * constData() const
Same as unicode().
Definition: qstring.h:1159

◆ toToken() [3/3]

XsdSchemaToken::NodeName XsdSchemaToken::toToken ( const QChar *  data,
int  length 
)
static

Definition at line 1819 of file qxsdschematoken.cpp.

1820  {
1821  switch(length)
1822  {
1823 
1824  case 2:
1825  return classifier2(data);
1826 
1827 
1828  case 3:
1829  return classifier3(data);
1830 
1831 
1832  case 4:
1833  return classifier4(data);
1834 
1835 
1836  case 5:
1837  return classifier5(data);
1838 
1839 
1840  case 6:
1841  return classifier6(data);
1842 
1843 
1844  case 7:
1845  return classifier7(data);
1846 
1847 
1848  case 8:
1849  return classifier8(data);
1850 
1851 
1852  case 9:
1853  return classifier9(data);
1854 
1855 
1856  case 10:
1857  return classifier10(data);
1858 
1859 
1860  case 11:
1861  return classifier11(data);
1862 
1863 
1864  case 12:
1865  return classifier12(data);
1866 
1867 
1868  case 13:
1869  return classifier13(data);
1870 
1871 
1872  case 14:
1873  return classifier14(data);
1874 
1875 
1876  case 15:
1877  return classifier15(data);
1878 
1879 
1880  case 17:
1881  return classifier17(data);
1882 
1883 
1884  case 18:
1885  return classifier18(data);
1886 
1887 
1888  case 20:
1889  return classifier20(data);
1890 
1891 
1892  case 21:
1893  return classifier21(data);
1894 
1895 
1896  case 22:
1897  return classifier22(data);
1898 
1899 
1900  case 32:
1901  return classifier32(data);
1902 
1903 
1904  default:
1905  return NoKeyword;
1906  }
1907  }
XsdSchemaToken::classifier32
static NodeName classifier32(const QChar *data)
Definition: qxsdschematoken.cpp:1803
XsdSchemaToken::classifier20
static NodeName classifier20(const QChar *data)
Definition: qxsdschematoken.cpp:1755
XsdSchemaToken::classifier5
static NodeName classifier5(const QChar *data)
Definition: qxsdschematoken.cpp:276
XsdSchemaToken::classifier6
static NodeName classifier6(const QChar *data)
Definition: qxsdschematoken.cpp:457
XsdSchemaToken::classifier10
static NodeName classifier10(const QChar *data)
Definition: qxsdschematoken.cpp:1161
XsdSchemaToken::classifier4
static NodeName classifier4(const QChar *data)
Definition: qxsdschematoken.cpp:150
XsdSchemaToken::classifier22
static NodeName classifier22(const QChar *data)
Definition: qxsdschematoken.cpp:1787
XsdSchemaToken::classifier8
static NodeName classifier8(const QChar *data)
Definition: qxsdschematoken.cpp:750
XsdSchemaToken::classifier14
static NodeName classifier14(const QChar *data)
Definition: qxsdschematoken.cpp:1544
XsdSchemaToken::classifier11
static NodeName classifier11(const QChar *data)
Definition: qxsdschematoken.cpp:1216
XsdSchemaToken::classifier18
static NodeName classifier18(const QChar *data)
Definition: qxsdschematoken.cpp:1716
XsdSchemaToken::classifier9
static NodeName classifier9(const QChar *data)
Definition: qxsdschematoken.cpp:984
XsdSchemaToken::classifier3
static NodeName classifier3(const QChar *data)
Definition: qxsdschematoken.cpp:64
XsdSchemaToken::classifier15
static NodeName classifier15(const QChar *data)
Definition: qxsdschematoken.cpp:1638
XsdSchemaToken::classifier13
static NodeName classifier13(const QChar *data)
Definition: qxsdschematoken.cpp:1505
XsdSchemaToken::classifier7
static NodeName classifier7(const QChar *data)
Definition: qxsdschematoken.cpp:631
XsdSchemaToken::classifier2
static NodeName classifier2(const QChar *data)
Definition: qxsdschematoken.cpp:48
XsdSchemaToken::classifier12
static NodeName classifier12(const QChar *data)
Definition: qxsdschematoken.cpp:1335
XsdSchemaToken::classifier21
static NodeName classifier21(const QChar *data)
Definition: qxsdschematoken.cpp:1771
XsdSchemaToken::classifier17
static NodeName classifier17(const QChar *data)
Definition: qxsdschematoken.cpp:1677
The documentation for this class was generated from the following files:
Qt 4.8 Source Code Browser