Movatterモバイル変換

XML Schema: Datatypes is part 2 of the specification of the XML Schema language. It defines facilities for defining datatypes to be usedin XML Schemas as well as other XML specifications. The datatype language, which is itself represented inXML 1.0, provides a superset of the capabilities found in XML 1.0document type definitions (DTDs) for specifying datatypes on elementsand attributes.

Status of this document

This section describes the status of this document at thetime of its publication. Other documents may supersede thisdocument. The latest status of this document series is maintained atthe W3C.

This document has been reviewed by W3C Members and other interestedparties and has been endorsed by the Director as a W3CRecommendation. It is a stable document and may be used as referencematerial or cited as a normative reference from anotherdocument. W3C's role in making the Recommendation is to draw attentionto the specification and to promote its widespread deployment. Thisenhances the functionality and interoperability of the Web.

This document has been produced by theW3C XML Schema Working Groupas part of the W3CXMLActivity. The goals of the XML Schema language are discussed intheXML SchemaRequirements document. The authors of this document are the XMLSchema WG members. Different parts of this specification havedifferent editors.

This version of this document incorporates some editorial changesfrom earlier versions.

A list of current W3C Recommendations and other technical documents can be found athttp://www.w3.org/TR/.

Data oriented	Document oriented
<invoice> <orderDate>1999-01-21</orderDate> <shipDate>1999-01-25</shipDate> <billingAddress> <name>Ashok Malhotra</name> <street>123 Microsoft Ave.</street> <city>Hawthorne</city> <state>NY</state> <zip>10532-0000</zip> </billingAddress> <voice>555-1234</voice> <fax>555-4321</fax></invoice>	<memo importance='high' date='1999-03-23'> <from>Paul V. Biron</from> <to>Ashok Malhotra</to> <subject>Latest draft</subject> <body> We need to discuss the latest draft <emph>immediately</emph>. Either email me at <email> mailto:paul.v.biron@kp.org</email> or call <phone>555-9876</phone> </body></memo>

3 Built-in datatypes

Each built-in datatype in this specification (both ·primitive· and·derived·) can be uniquely addressed via a URI Reference constructed as follows:

the base URI is the URI of the XML Schema namespace
the fragment identifier is the name of the datatype

For example, to address theint datatype, the URI is:

http://www.w3.org/2001/XMLSchema#int

Additionally, each facet definition element can be uniquely addressed via a URI constructed as follows:

the base URI is the URI of the XML Schema namespace
the fragment identifier is the name of the facet

For example, to address the maxInclusive facet, the URI is:

http://www.w3.org/2001/XMLSchema#maxInclusive

Additionally, each facet usage in a built-in datatype definition can be uniquely addressed via a URI constructed as follows:

the base URI is the URI of the XML Schema namespace
the fragment identifier is the name of the datatype, followedby a period (".") followed by the name of the facet

For example, to address the usage of the maxInclusive facet in the definition of int, the URI is:

http://www.w3.org/2001/XMLSchema#int.maxInclusive

3.1 Namespace considerations

The·built-in· datatypes defined by this specificationare designed to be used with the XML Schema definition language as well as otherXML specifications. To facilitate usage within the XML Schema definition language, the·built-in·datatypes in this specification have the namespace name:

http://www.w3.org/2001/XMLSchema

To facilitate usage in specifications other than the XML Schema definition language,such as those that do not want to know anything about aspects of theXML Schema definition language other than the datatypes, each·built-in·datatype is also defined in the namespace whose URI is:

http://www.w3.org/2001/XMLSchema-datatypes

This applies to both·built-in· ·primitive· and·built-in· ·derived· datatypes.

Each·user-derived· datatype is also associated with aunique namespace. However,·user-derived· datatypesdo not come from the namespace defined by this specification; rather,they come from the namespace of the schema in which they are defined(seeXML Representation ofSchemas in[XML Schema Part 1: Structures]).

3.2 Primitive datatypes

3.2.1string

3.2.2boolean

3.2.3decimal

3.2.4float

3.2.5double

3.2.6duration

3.2.7dateTime

3.2.8time

3.2.9date

3.2.10gYearMonth

3.2.11gYear

3.2.12gMonthDay

3.2.13gDay

3.2.14gMonth

3.2.15hexBinary

3.2.16base64Binary

3.2.17anyURI

3.2.18QName

3.2.19NOTATION

The·primitive· datatypes defined by this specificationare described below. For each datatype, the·value space· and·lexical space·are defined,·constraining facet·s which applyto the datatype are listed and any datatypes·derived·from this datatype are specified.

·primitive· datatypes can only be added by revisionsto this specification.

3.2.1 string

[Definition:] Thestring datatyperepresents character strings in XML. The·value space·ofstring is the set of finite-length sequences ofcharacters (as defined in[XML 1.0 (Second Edition)]) that·match· theChar production from[XML 1.0 (Second Edition)].Acharacter is an atomic unit ofcommunication; it is not further specified except to note that everycharacter has a correspondingUniversal Character Set code point, which is an integer.

NOTE:Many human languages have writing systems that requirechild elements for control of aspects such as bidirectional formating orruby annotation (see[Ruby] and Section 8.2.4Overriding thebidirectional algorithm: the BDO element of[HTML 4.01]).Thus,string, as a simple type that can contain onlycharacters but not child elements, is often not suitable for representing text.In such situations, a complex type that allows mixed content should be considered.For more information, see Section 5.5Any Element, Any Attributeof[XML Schema Language: Part 2 Primer].

NOTE:As noted inordered, the fact that this specification doesnot specify an·order-relation· for·string·does not preclude other applications from treating strings as being ordered.

3.2.1.1 Constraining facets

string has thefollowing·constraining facets·:

3.2.1.2 Derived datatypes

The following·built-in·datatypes are·derived· fromstring:

normalizedString

3.2.2 boolean

[Definition:] boolean has the·value space· required to support the mathematicalconcept of binary-valued logic: {true, false}.

3.2.2.1 Lexical representation

An instance of a datatype that is defined as·boolean·can have the following legal literals {true, false, 1, 0}.

3.2.2.2 Canonical representation

The canonical representation forboolean is the set ofliterals {true, false}.

3.2.2.3 Constraining facets

boolean has thefollowing·constraining facets·:

3.2.3 decimal

[Definition:] decimalrepresents arbitrary precision decimal numbers.The·value space· ofdecimalis the set of the valuesi × 10^-n,wherei andn are integerssuch thatn >= 0.The·order-relation· ondecimalis:x < y iff y - x is positive.

[Definition:] The·value space· of types derived fromdecimalwith a value for·totalDigits· ofpis the set of valuesi × 10^-n, wheren andi are integers such thatp >= n >= 0 and the number of significant decimal digitsini is less than or equal top.

[Definition:] The·value space· of types derived fromdecimalwith a value for·fractionDigits· ofsis the set of valuesi × 10^-n, wherei andn are integers suchthat0 <= n <= s.

NOTE:All·minimally conforming· processors·must·support decimal numbers with a minimum of 18 decimal digits (i.e., with a·totalDigits· of 18). However,·minimally conforming· processors·may·set an application-defined limit on the maximum number of decimal digitsthey are prepared to support, in which case that application-definedmaximum number·must· be clearly documented.

3.2.3.1 Lexical representation

decimal has a lexical representationconsisting of a finite-length sequence of decimal digits (#x30-#x39) separatedby a period as a decimal indicator. If·totalDigits· isspecified, the number of digits must be less than or equal to·totalDigits·.If·fractionDigits· is specified, thenumber of digits following the decimal point must be less than or equal tothe·fractionDigits·. An optional leading sign is allowed.If the sign is omitted, "+" is assumed. Leading and trailing zeroes are optional.If the fractional part is zero, the period and following zero(es) canbe omitted.For example:-1.23, 12678967.543233, +100000.00, 210.

3.2.3.2 Canonical representation

The canonical representation fordecimal is defined byprohibiting certain options from theLexical representation (§3.2.3.1). Specifically, the precedingoptional "+" sign is prohibited. The decimal point is required. Leading and trailing zeroes are prohibited subject to the following: there must be at leastone digit to the right and to the left of the decimal point which may be a zero.

3.2.3.3 Constraining facets

decimal has thefollowing·constraining facets·:

3.2.3.4 Derived datatypes

The following·built-in·datatypes are·derived· fromdecimal:

integer

3.2.4 float

[Definition:] float correspondsto the IEEE single-precision 32-bit floating point type[IEEE 754-1985]. The basic·value space· offloat consists of the valuesm × 2^e, wheremis an integer whose absolute value is less than2^24, ande is an integerbetween -149 and 104, inclusive. In addition to the basic·value space· described above, the·value space· offloat also contains thefollowingspecial values: positive and negative zero,positive and negative infinity and not-a-number.The·order-relation· onfloatis:x < y iff y - x is positive.Positive zero is greater than negative zero. Not-a-number equals itself and isgreater than all float values including positive infinity.

A literal in the·lexical space· representing adecimal numberd maps to the normalized valuein the·value space· offloat that isclosest tod in the sense defined by[Clinger, WD (1990)]; ifd isexactly halfway between two such values then the even value is chosen.

3.2.4.1 Lexical representation

float values have a lexical representationconsisting of a mantissa followed, optionally, by the character"E" or "e", followed by an exponent. The exponent·must·be aninteger. The mantissa must be adecimal number. The representationsfor exponent and mantissa must follow the lexical rules forinteger anddecimal. If the "E" or "e" andthe following exponent are omitted, an exponent value of 0 is assumed.

Thespecial values positive and negative zero, positiveand negative infinity and not-a-number have lexical representations0,-0,INF,-INF andNaN, respectively.

For example,-1E4, 1267.43233E12, 12.78e-2, 12 and INFare all legal literals forfloat.

3.2.4.2 Canonical representation

The canonical representation forfloat is defined byprohibiting certain options from theLexical representation (§3.2.4.1). Specifically, the exponent must be indicated by "E". Leading zeroes and the preceding optional "+" signare prohibited in the exponent.For the mantissa, the preceding optional "+" sign is prohibited and the decimal point is required. For the exponent, the preceding optional "+" sign is prohibited.Leading and trailing zeroes are prohibited subject to the following:number representations mustbe normalized such that there is a singledigit to the left of the decimal point and at least a single digit to the right of the decimal point.

3.2.4.3 Constraining facets

float has thefollowing·constraining facets·:

3.2.5 double

[Definition:] Thedoubledatatype corresponds to IEEE double-precision 64-bit floating pointtype[IEEE 754-1985]. The basic·value space·ofdouble consists of the valuesm × 2^e, wheremis an integer whose absolute value is less than2^53, ande is aninteger between -1075 and 970, inclusive. In addition to the basic·value space· described above, the·value space· ofdouble also containsthe followingspecial values: positive and negative zero,positive and negative infinity and not-a-number.The·order-relation· ondoubleis:x < y iff y - x is positive.Positive zero is greater than negative zero. Not-a-number equals itself and isgreater than all double values including positive infinity.

A literal in the·lexical space· representing adecimal numberd maps to the normalized valuein the·value space· ofdouble that isclosest tod; ifd isexactly halfway between two such values then the even value is chosen.This is thebest approximation ofd([Clinger, WD (1990)],[Gay, DM (1990)]), which is moreaccurate than the mapping required by[IEEE 754-1985].

3.2.5.1 Lexical representation

double values have a lexical representationconsisting of a mantissa followed, optionally, by the character "E" or"e", followed by an exponent. The exponent·must· bean integer. The mantissa must be a decimal number. The representationsfor exponent and mantissa must follow the lexical rules forinteger anddecimal. If the "E" or "e"and the following exponent are omitted, an exponent value of 0 is assumed.

Thespecial values positive and negative zero, positiveand negative infinity and not-a-number have lexical representations0,-0,INF,-INF andNaN, respectively.

For example,-1E4, 1267.43233E12, 12.78e-2, 12 and INFare all legal literals fordouble.

3.2.5.2 Canonical representation

The canonical representation fordouble is defined byprohibiting certain options from theLexical representation (§3.2.5.1). Specifically, the exponent must be indicated by "E". Leading zeroes and the preceding optional "+" signare prohibited in the exponent.For the mantissa, the preceding optional "+" sign is prohibited and the decimal point is required. For the exponent, the preceding optional "+" sign is prohibited.Leading and trailing zeroes are prohibited subject to the following:number representations mustbe normalized such that there is a singledigit to the left of the decimal point and at least a single digit to the right of the decimal point.

3.2.5.3 Constraining facets

double has thefollowing·constraining facets·:

3.2.6 duration

[Definition:] duration represents a duration of time.The·value space· ofduration is a six-dimensional space where the coordinatesdesignate the Gregorian year, month, day, hour, minute, and second components defined in§ 5.5.3.2 of[ISO 8601],respectively. These components are orderedin their significance by their order of appearance i.e. as year, month, day,hour, minute, and second.

3.2.6.1 Lexical representation

The lexical representation forduration is the[ISO 8601] extended format PnYnMnDTnHnMnS, wherenY represents the number of years,nM thenumber of months,nD the number of days, 'T' is thedate/time separator,nH the number of hours,nM the number of minutes andnS thenumber of seconds. The number of seconds can include decimal digitsto arbitrary precision.

The values of theYear, Month, Day, Hour and Minutes components are not restricted but allow an arbitrary integer. Similarly, the value of the Seconds componentallows an arbitrary decimal. Thus, the lexical representation ofduration does not follow the alternative format of § 5.5.3.2.1 of[ISO 8601].

An optional preceding minus sign ('-') isallowed, to indicate a negative duration. If the sign is omitted apositive duration is indicated. See alsoISO 8601 Date and Time Formats (§D).

For example, to indicate a duration of 1 year, 2 months, 3 days, 10hours, and 30 minutes, one would write:P1Y2M3DT10H30M.One could also indicate a duration of minus 120 days as:-P120D.

Reduced precision and truncated representations of this format are allowedprovided they conform to the following:

If the number of years, months, days, hours, minutes, or seconds in anyexpression equals zero, the number and its corresponding designator·may·be omitted. However, at least one number and its designator·must·be present.
The seconds part·may· have a decimal fraction.
The designator 'T' shall be absent if all of the time items are absent.The designator 'P' must always be present.

For example, P1347Y, P1347M and P1Y2MT2H are all allowed;P0Y1347M and P0Y1347M0D are allowed. P-1347M is not allowed although-P1347M is allowed. P1Y2MT is not allowed.

3.2.6.2 Order relation on duration

In general, the·order-relation· ondurationis a partial order since there is no determinate relationship between certaindurations such as one month (P1M) and 30 days (P30D). The·order-relation·of twoduration valuesx andy isx < y iff s+x < s+yfor each qualifieddateTime sin the list below. These values fors cause the greatest deviations in the addition of dateTimes and durations. Addition of durations to time instants is definedinAdding durations to dateTimes (§E).

1696-09-01T00:00:00Z
1697-02-01T00:00:00Z
1903-03-01T00:00:00Z
1903-07-01T00:00:00Z

The following table shows the strongest relationship that can be determinedbetween example durations. The symbol <> means that the order relation isindeterminate. Note that because of leap-seconds, a seconds field can varyfrom 59 to 60. However, because of the way that addition is defined inAdding durations to dateTimes (§E), they are still totally ordered.

	Relation
P1Y	> P364D	<> P365D				<> P366D	< P367D
P1M	> P27D	<> P28D	<> P29D		<> P30D	<> P31D	< P32D
P5M	> P149D	<> P150D	<> P151D	<> P152D		<> P153D	< P154D

Implementations are free to optimize the computation of the ordering relationship. For example, the following table can be used tocompare durations of a small number of months against days.

	Months	1	2	3	4	5	6	7	8	9	10	11	12	13	...
Days	Minimum	28	59	89	120	150	181	212	242	273	303	334	365	393	...
Days	Maximum	31	62	92	123	153	184	215	245	276	306	337	366	397	...

3.2.6.3 Facet Comparison for durations

In comparingdurationvalues withminInclusive,minExclusive,maxInclusive andmaxExclusive facet valuesindeterminate comparisons should be considered as "false".

3.2.6.4 Totally ordered durations

Certain derived datatypes of durations can be guaranteed have a total order. For this, they must have fields from only one row in the list below and the time zonemust either be required or prohibited.

year, month
day, hour, minute, second

For example, a datatype could be defined to correspond to the[SQL] datatype Year-Month interval that required a four digityear field and a two digit month field but required all other fields to be unspecified. This datatype could be defined as below and would have a total order.

<simpleType name='SQL-Year-Month-Interval'>    <restriction base='duration'>      <pattern value='P\p{Nd}{4}Y\p{Nd}{2}M'/>    </restriction></simpleType>

3.2.6.5 Constraining facets

duration has thefollowing·constraining facets·:

3.2.7 dateTime

[Definition:] dateTime represents a specific instant of time. The·value space· ofdateTime is the spaceofCombinations of date and time of day values as definedin § 5.4 of[ISO 8601].

3.2.7.1 Lexical representation

A single lexical representation, which is a subset of the lexicalrepresentations allowed by[ISO 8601], is allowed fordateTime. This lexical representation is the[ISO 8601] extended format CCYY-MM-DDThh:mm:sswhere "CC" represents the century, "YY" the year, "MM" the month and"DD" the day, preceded by an optional leading "-" sign to indicate anegative number. If the sign is omitted, "+" is assumed. The letter"T" is the date/time separator and "hh", "mm", "ss" represent hour,minute and second respectively. Additional digits can be used toincrease the precision of fractional seconds if desired i.e the formatss.ss... with any number of digits after the decimal point is supported. The fractional seconds part is optional; other parts of thelexical form are not optional.To accommodateyear values greater than 9999 additional digits can be added to theleft of this representation. Leading zeros are required if the year valuewould otherwise have fewer than four digits; otherwise they are forbidden.The year 0000 is prohibited.

The CCYY field must have at least four digits, the MM, DD, SS, hh, mmand ss fields exactly two digits each (not counting fractional seconds);leading zeroes must be used if the field would otherwise have too few digits.

This representation may be immediately followed by a "Z" to indicateCoordinated Universal Time (UTC) or, to indicate the time zone, i.e. thedifference between the local time and Coordinated Universal Time,immediately followed by a sign,+ or -, followed by the difference from UTC represented as hh:mm (note:the minutes part is required).SeeISO 8601 Date and Time Formats (§D) for details about legal values in thevarious fields.If the time zone is included, both hours and minutes must be present.

For example, to indicate 1:20 pm on May the 31st, 1999 for EasternStandard Time which is 5 hours behind Coordinated Universal Time (UTC), onewould write:1999-05-31T13:20:00-05:00.

3.2.7.2 Canonical representation

The canonical representation fordateTime is definedby prohibiting certain options from theLexical representation (§3.2.7.1). Specifically, either the time zone mustbe omitted or, if present, the time zone must be Coordinated UniversalTime (UTC) indicated by a "Z".

3.2.7.3 Order relation on dateTime

In general, the·order-relation· ondateTimeis a partial order since there is no determinate relationship between certaininstants. For example, there is no determinateordering between (a)2000-01-20T12:00:00 and (b) 2000-01-20T12:00:00Z. Based ontimezones currently in use, (c) could vary from 2000-01-20T12:00:00+12:00 to2000-01-20T12:00:00-13:00. It is, however, possible for this range to expand orcontract in the future, based on local laws. Because of this, the followingdefinition uses a somewhat broader range of indeterminate values: +14:00..-14:00.

The following definition uses the notation S[year] to represent the yearfield of S, S[month] to represent the month field, and so on. The notation (Q& "-14:00") means adding the timezone -14:00 to Q, where Q did notalready have a timezone.This is a logical explanation of the process. Actualimplementations are free to optimize as long as they produce the same results.

The ordering between twodateTimes P and Q is defined by the followingalgorithm:

A.Normalize P and Q. That is, if there is a timezone present, but it is not Z, convert it to Z using the addition operation defined inAdding durations to dateTimes (§E)

Thus 2000-03-04T23:00:00+03:00 normalizes to 2000-03-04T20:00:00Z

B. If P and Q either both have a time zone or both do not have a time zone, compare P and Q field by field from the year field down to the second field, and return a result as soon as it can be determined. That is:

For each i in {year, month, day, hour, minute, second}
1. If P[i] and Q[i] are both not specified, continue to the next i
2. If P[i] is not specified and Q[i] is, or vice versa, stop and return P <> Q
3. If P[i] < Q[i], stop and return P < Q
4. If P[i] > Q[i], stop and return P > Q
Stop and return P = Q

C.Otherwise, if P contains a time zone and Q does not, compare as follows:

P < Q if P < (Q with time zone +14:00)
P > Q if P > (Q with time zone -14:00)
P <> Q otherwise, that is, if (Q with time zone +14:00) < P < (Q with time zone -14:00)

D. Otherwise, if P does not contain a time zone and Q does, compare as follows:

P < Q if (P with time zone -14:00) < Q.
P > Q if (P with time zone +14:00) > Q.
P <> Q otherwise, that is, if (P with time zone +14:00) < Q < (P with time zone -14:00)

Examples:

Determinate	Indeterminate
2000-01-15T00:00:00< 2000-02-15T00:00:00	2000-01-01T12:00:00<> 1999-12-31T23:00:00Z
2000-01-15T12:00:00< 2000-01-16T12:00:00Z	2000-01-16T12:00:00<> 2000-01-16T12:00:00Z
	2000-01-16T00:00:00<> 2000-01-16T12:00:00Z

3.2.7.4 Totally ordered dateTimes

Certain derived types fromdateTime can be guaranteed have a total order. Todo so, they must require that a specific set of fields are always specified, andthat remaining fields (if any) are always unspecified. For example, the datedatatype without time zone is defined to contain exactly year, month, and day.Thus dates without time zone have a total order among themselves.

3.2.7.5 Constraining facets

dateTime has thefollowing·constraining facets·:

3.2.8 time

[Definition:] timerepresents an instant of time that recurs every day. The·value space· oftime is the spaceoftime of day values as defined in § 5.3 of[ISO 8601]. Specifically, it is a set of zero-duration dailytime instances.

Since the lexical representation allows an optional time zone indicator,time values are partially ordered because it maynot be able to determine the order of two values one of which has atime zone and the other does not. The order relation ontime values is theOrder relation on dateTime (§3.2.7.3) using an arbitrary date. See alsoAdding durations to dateTimes (§E). Pairs oftime values with or without time zone indicators are totally ordered.

3.2.8.1 Lexical representation

The lexical representation fortime is the lefttruncated lexical representation fordateTime:hh:mm:ss.sss with optional following time zone indicator. For example,to indicate 1:20 pm for Eastern Standard Time which is 5 hours behindCoordinated Universal Time (UTC), one would write: 13:20:00-05:00. See alsoISO 8601 Date and Time Formats (§D).

3.2.8.2 Canonical representation

The canonical representation fortime is definedby prohibiting certain options from theLexical representation (§3.2.8.1). Specifically, either the time zone mustbe omitted or, if present, the time zone must be Coordinated UniversalTime (UTC) indicated by a "Z". Additionally, the canonical representation for midnight is 00:00:00.

3.2.8.3 Constraining facets

time has thefollowing·constraining facets·:

3.2.9 date

[Definition:] daterepresents a calendar date. The·value space·ofdate is the set of Gregorian calendar dates as definedin § 5.2.1 of[ISO 8601]. Specifically,it is a set of one-day long, non-periodic instancese.g. lexical 1999-10-26 to represent the calendar date 1999-10-26, independentof how many hours this day has.

Since the lexical representation allows an optional time zone indicator,date values are partially ordered because it maynot be possible to unequivocally determine the order of two values one of which has atime zone and the other does not. Ifdate values are considered as periods of time, the order relation ondate values is the order relation on their starting instants.This is discussed inOrder relation on dateTime (§3.2.7.3). See alsoAdding durations to dateTimes (§E). Pairs ofdate values with or without time zone indicators are totally ordered.

3.2.9.1 Lexical representation

The lexical representation fordate is the reduced (righttruncated) lexical representation fordateTime:CCYY-MM-DD. No left truncation is allowed. An optional following timezone qualifier is allowed as fordateTime. Toaccommodate year values outside the range from 0001 to 9999, additionaldigits can be added to the left of this representation and a preceding "-" sign is allowed.

For example, to indicate May the 31st, 1999, one would write: 1999-05-31.See alsoISO 8601 Date and Time Formats (§D).

3.2.9.2 Constraining facets

date has thefollowing·constraining facets·:

3.2.10 gYearMonth

[Definition:] gYearMonth represents aspecific gregorian month in a specific gregorian year. The·value space· ofgYearMonthis the set of Gregorian calendar months as defined in § 5.2.1 of[ISO 8601]. Specifically, it is a set of one-month long,non-periodic instancese.g. 1999-10 to represent the whole month of 1999-10, independent ofhow many days this month has.

Since the lexical representation allows an optional time zone indicator,gYearMonth values are partially ordered because it maynot be possible to unequivocally determine the order of two values one ofwhich has a time zone and the other does not. IfgYearMonthvalues are considered as periods of time, the order relation ongYearMonth values is the order relation on their starting instants.This is discussed inOrder relation on dateTime (§3.2.7.3). See alsoAdding durations to dateTimes (§E). Pairs ofgYearMonthvalues with or without time zone indicators are totally ordered.

NOTE:Because month/year combinations in one calendar only rarely correspondto month/year combinations in other calendars, values of this typeare not, in general, convertible to simple values corresponding to month/yearcombinations in other calendars. This type should therefore be used with cautionin contexts where conversion to other calendars is desired.

3.2.10.1 Lexical representation

The lexical representation forgYearMonth is the reduced(right truncated) lexical representation fordateTime:CCYY-MM. No left truncation is allowed. An optional following timezone qualifier is allowed. To accommodate year values outside the range from 0001 to 9999, additional digitscan be added to the left of this representation and a preceding "-" sign is allowed.

For example, to indicate the month of May 1999, one would write: 1999-05.See alsoISO 8601 Date and Time Formats (§D).

3.2.10.2 Constraining facets

gYearMonth has thefollowing·constraining facets·:

3.2.11 gYear

[Definition:] gYear represents agregorian calendar year. The·value space· ofgYear is the set of Gregorian calendar years as defined in§ 5.2.1 of[ISO 8601]. Specifically, it is a set of one-yearlong, non-periodic instancese.g. lexical 1999 to represent the whole year 1999, independent ofhow many months and days this year has.

Since the lexical representation allows an optional time zone indicator,gYear values are partially ordered because it maynot be possible to unequivocally determine the order of two values one of which has atime zone and the other does not. IfgYear values are considered as periods of time, the order relation ongYear values is the order relation on their starting instants.This is discussed inOrder relation on dateTime (§3.2.7.3). See alsoAdding durations to dateTimes (§E). Pairs ofgYear values with or without time zone indicators are totally ordered.

NOTE:Because years in one calendar only rarely correspond to yearsin other calendars, values of this typeare not, in general, convertible to simple values corresponding to yearsin other calendars. This type should therefore be used with cautionin contexts where conversion to other calendars is desired.

3.2.11.1 Lexical representation

The lexical representation forgYear is the reduced (righttruncated) lexical representation fordateTime: CCYY.No left truncation is allowed. An optional following timezone qualifier is allowed as fordateTime. Toaccommodate year values outside the range from 0001 to 9999, additionaldigits can be added to the left of this representation and a preceding"-" sign is allowed.

For example, to indicate 1999, one would write: 1999.See alsoISO 8601 Date and Time Formats (§D).

3.2.11.2 Constraining facets

gYear has thefollowing·constraining facets·:

3.2.12 gMonthDay

[Definition:] gMonthDay is a gregorian date that recurs, specifically a day ofthe year such as the third of May. Arbitrary recurring dates are notsupported by this datatype. The·value space· ofgMonthDay is the set ofcalendardates, as defined in § 3 of[ISO 8601]. Specifically,it is a set of one-day long, annually periodic instances.

Since the lexical representation allows an optional time zone indicator,gMonthDay values are partially ordered because it maynot be possible to unequivocally determine the order of two values one of which has atime zone and the other does not. IfgMonthDay values are considered as periods of time, the order relation ongMonthDay values is the order relation on their starting instants.This is discussed inOrder relation on dateTime (§3.2.7.3). See alsoAdding durations to dateTimes (§E). Pairs ofgMonthDay values with or without time zone indicators are totally ordered.

NOTE:Because day/month combinations in one calendar only rarely correspondto day/month combinations in other calendars, values of this type do not,in general, have any straightforward or intuitive representationin terms of most other calendars. This type should therefore beused with caution in contexts where conversion to other calendarsis desired.

3.2.12.1 Lexical representation

The lexical representation forgMonthDay is the lefttruncated lexical representation fordate: --MM-DD.An optional following timezone qualifier is allowed as fordate.No preceding sign is allowed. No other formats are allowed. See alsoISO 8601 Date and Time Formats (§D).

This datatype can be used to represent a specific day in a month.To say, for example, that my birthday occurs on the 14th of September ever year.

3.2.12.2 Constraining facets

gMonthDay has thefollowing·constraining facets·:

3.2.13 gDay

[Definition:] gDay is a gregorian day that recurs, specifically a dayof the month such as the 5th of the month. Arbitrary recurring daysare not supported by this datatype. The·value space·ofgDay is the space of a set ofcalendardates as defined in § 3 of[ISO 8601]. Specifically,it is a set of one-day long, monthly periodic instances.

This datatype can be used to represent a specific day of the month.To say, for example, that I get my paycheck on the 15th of each month.

Since the lexical representation allows an optional time zone indicator,gDay values are partially ordered because it maynot be possible to unequivocally determine the order of two values one ofwhich has a time zone and the other does not. IfgDay values are considered as periods of time, the order relation ongDay values is the order relation on their starting instants.This is discussed inOrder relation on dateTime (§3.2.7.3). See alsoAdding durations to dateTimes (§E). Pairs ofgDayvalues with or without time zone indicators are totally ordered.

NOTE:Because days in one calendar only rarely correspondto days in other calendars, values of this type do not,in general, have any straightforward or intuitive representationin terms of most other calendars. This type should therefore beused with caution in contexts where conversion to other calendarsis desired.

3.2.13.1 Lexical representation

The lexical representation forgDay is the lefttruncated lexical representation fordate: ---DD .An optional following timezone qualifier is allowed as fordate. No preceding sign isallowed. No other formats are allowed. See alsoISO 8601 Date and Time Formats (§D).

3.2.13.2 Constraining facets

gDay has thefollowing·constraining facets·:

3.2.14 gMonth

[Definition:] gMonth is a gregorian month that recurs every year.The·value space·ofgMonth is the space of a set ofcalendarmonths as defined in § 3 of[ISO 8601]. Specifically,it is a set of one-month long, yearly periodic instances.

This datatype can be used to represent a specific month.To say, for example, that Thanksgiving falls in the month of November.

Since the lexical representation allows an optional time zone indicator,gMonth values are partially ordered because it maynot be possible to unequivocally determine the order of two values one of which has atime zone and the other does not. IfgMonth values are considered as periods of time, the order relation ongMonth is the order relation on their starting instants.This is discussed inOrder relation on dateTime (§3.2.7.3). See alsoAdding durations to dateTimes (§E). Pairs ofgMonthvalues with or without time zone indicators are totally ordered.

NOTE:Because months in one calendar only rarely correspondto months in other calendars, values of this type do not,in general, have any straightforward or intuitive representationin terms of most other calendars. This type should therefore beused with caution in contexts where conversion to other calendarsis desired.

3.2.14.1 Lexical representation

The lexical representation forgMonth is the leftand right truncated lexical representation fordate: --MM--.An optional following timezone qualifier is allowed as fordate. No preceding sign isallowed. No other formats are allowed. See alsoISO 8601 Date and Time Formats (§D).

3.2.14.2 Constraining facets

gMonth has thefollowing·constraining facets·:

3.2.15 hexBinary

[Definition:] hexBinary representsarbitrary hex-encoded binary data. The·value space· ofhexBinary is the set of finite-length sequences of binaryoctets.

3.2.15.1 Lexical Representation

hexBinary has a lexical representation whereeach binary octet is encoded as a character tuple, consisting of twohexadecimal digits ([0-9a-fA-F]) representing the octet code. For example,"0FB7" is ahex encoding for the 16-bit integer 4023(whose binary representation is 111110110111).

3.2.15.2 Canonical Rrepresentation

The canonical representation forhexBinary is definedby prohibiting certain options from theLexical Representation (§3.2.15.1). Specifically, the lower casehexadecimal digits ([a-f]) are not allowed.

3.2.15.3 Constraining facets

hexBinary has thefollowing·constraining facets·:

3.2.16 base64Binary

[Definition:] base64Binaryrepresents Base64-encoded arbitrary binary data. The·value space· ofbase64Binary is the set of finite-length sequences of binaryoctets. Forbase64Binary data theentire binary stream is encoded using the Base64Content-Transfer-Encoding defined in Section 6.8 of[RFC 2045].

3.2.16.1 Constraining facets

base64Binary has thefollowing·constraining facets·:

3.2.17 anyURI

[Definition:] anyURI represents a Uniform Resource Identifier Reference(URI). AnanyURI value can be absolute or relative, and mayhave an optional fragment identifier (i.e., it may be a URI Reference). Thistype should be used to specify the intention that the value fulfillsthe role of a URI as defined by[RFC 2396], as amended by[RFC 2732].

The mapping fromanyURI values to URIs is as defined inSection 5.4Locator Attributeof[XML Linking Language] (see also Section 8Character Encoding in URI Referencesof[Character Model]). This meansthat a wide range of internationalized resource identifiers can be specifiedwhen ananyURI is called for, and still be understood as URIs per[RFC 2396], as amended by[RFC 2732],where appropriate to identify resources.

NOTE:Each URI scheme imposes specialized syntax rules for URIs inthat scheme, including restrictions on the syntax of allowed fragementidentifiers. Because it isimpractical for processors to check that a value is acontext-appropriate URI reference, this specification follows thelead of[RFC 2396] (as amended by[RFC 2732])in this matter: such rules and restrictions are not part of type validityand are not checked by·minimally conforming· processors.Thus in practice the above definition imposes only very modest obligationson·minimally conforming· processors.

3.2.17.1 Lexical representation

The·lexical space· ofanyURI isfinite-length character sequences which, when the algorithm defined inSection 5.4 of[XML Linking Language] is applied to them, result in stringswhich are legal URIs according to[RFC 2396], as amended by[RFC 2732].

NOTE:Spaces are, in principle, allowed in the·lexical space·ofanyURI, however, their use is highly discouraged(unless they are encoded by %20).

3.2.17.2 Constraining facets

anyURI has thefollowing·constraining facets·:

3.2.18 QName

[Definition:] QName representsXML qualified names.The·value space· ofQName is the set oftuples {namespace name,local part},wherenamespace nameis ananyURIandlocal part isanNCName.The·lexical space· ofQName is the setof strings that·match· theQName production of[Namespaces in XML].

NOTE:The mapping between literals in the·lexical space· andvalues in the·value space· ofQName requiresa namespace declaration to be in scope for the context in whichQNameis used.

3.2.18.1 Constraining facets

QName has thefollowing·constraining facets·:

3.2.19 NOTATION

[Definition:] NOTATIONrepresents theNOTATION attributetype from[XML 1.0 (Second Edition)]. The·value space·ofNOTATION is the setQNames. The·lexical space· ofNOTATION is the setof all names ofnotationsdeclared in the current schema.

Schema Component Constraint: enumeration facet value required for NOTATION

It is an·error· forNOTATIONto be used directly in a schema. Only datatypes that are·derived· fromNOTATION byspecifying a value for·enumeration· can be usedin a schema.

For compatibility (seeTerminology (§1.4))NOTATIONshould be used only on attributes.

3.2.19.1 Constraining facets

NOTATION has thefollowing·constraining facets·:

3.3 Derived datatypes

3.3.1normalizedString

3.3.2token

3.3.3language

3.3.4NMTOKEN

3.3.5NMTOKENS

3.3.6Name

3.3.7NCName

3.3.8ID

3.3.9IDREF

3.3.10IDREFS

3.3.11ENTITY

3.3.12ENTITIES

3.3.13integer

3.3.14nonPositiveInteger

3.3.15negativeInteger

3.3.16long

3.3.17int

3.3.18short

3.3.19byte

3.3.20nonNegativeInteger

3.3.21unsignedLong

3.3.22unsignedInt

3.3.23unsignedShort

3.3.24unsignedByte

3.3.25positiveInteger

This section gives conceptual definitions for all·built-in· ·derived· datatypesdefined by this specification. The XML representation used to define·derived· datatypes (whether·built-in· or·user-derived·) isgiven in sectionXML Representation of Simple Type Definition Schema Components (§4.1.2) and the completedefinitions of the·built-in· ·derived· datatypes are provided in Appendix ASchema for Datatype Definitions (normative) (§A).

3.3.1 normalizedString

[Definition:] normalizedStringrepresents white space normalized strings.The·value space· ofnormalizedString is the set of strings that do notcontain the carriage return (#xD), line feed (#xA) nor tab (#x9) characters.The·lexical space· ofnormalizedString is the set of strings that do notcontain the carriage return (#xD) nor tab (#x9) characters.The·base type· ofnormalizedString isstring.

3.3.1.1 Constraining facets

normalizedString has thefollowing·constraining facets·:

3.3.1.2 Derived datatypes

The following·built-in·datatypes are·derived· fromnormalizedString:

token

3.3.2 token

[Definition:] tokenrepresents tokenized strings.The·value space· oftoken is the set of strings that do notcontain the line feed (#xA) nor tab (#x9) characters, that have noleading or trailing spaces (#x20) and that have no internal sequencesof two or more spaces.The·lexical space· oftoken is the set of strings that do notcontain the line feed (#xA) nor tab (#x9) characters, that have noleading or trailing spaces (#x20) and that have no internal sequencesof two or more spaces.The·base type· oftoken isnormalizedString.

3.3.2.1 Constraining facets

token has thefollowing·constraining facets·:

3.3.2.2 Derived datatypes

The following·built-in·datatypes are·derived· fromtoken:

3.3.3 language

[Definition:] languagerepresents natural language identifiers as defined by[RFC 1766]. The·value space· oflanguage is the set of all strings that are validlanguage identifiers as defined in thelanguage identificationsection of[XML 1.0 (Second Edition)]. The·lexical space· oflanguage is the set of all strings that are validlanguage identifiers as defined in thelanguage identificationsection of[XML 1.0 (Second Edition)].The·base type· oflanguage istoken.

3.3.3.1 Constraining facets

language has thefollowing·constraining facets·:

3.3.4 NMTOKEN

[Definition:] NMTOKEN representstheNMTOKEN attribute typefrom[XML 1.0 (Second Edition)]. The·value space· ofNMTOKEN is the set of tokens that·match·theNmtoken production in[XML 1.0 (Second Edition)]. The·lexical space· ofNMTOKEN is the set of strings that·match·theNmtoken production in[XML 1.0 (Second Edition)]. The·base type· ofNMTOKEN istoken.

For compatibility (seeTerminology (§1.4))NMTOKENshould be used only on attributes.

3.3.4.1 Constraining facets

NMTOKEN has thefollowing·constraining facets·:

3.3.4.2 Derived datatypes

The following·built-in·datatypes are·derived· fromNMTOKEN:

NMTOKENS

3.3.5 NMTOKENS

[Definition:] NMTOKENSrepresents theNMTOKENS attributetype from[XML 1.0 (Second Edition)]. The·value space·ofNMTOKENS is the set of finite, non-zero-length sequences of·NMTOKEN·s. The·lexical space·ofNMTOKENS is the set of white space separated lists of tokens,of which each token is in the·lexical space· ofNMTOKEN. The·itemType· ofNMTOKENS isNMTOKEN.

For compatibility (seeTerminology (§1.4))NMTOKENS should be used only on attributes.

3.3.5.1 Constraining facets

NMTOKENS has thefollowing·constraining facets·:

3.3.6 Name

[Definition:] NamerepresentsXML Names.The·value space· ofName isthe set of all strings which·match· theName production of[XML 1.0 (Second Edition)]. The·lexical space· ofName is the set of all strings which·match·theName production of[XML 1.0 (Second Edition)]. The·base type· ofNameistoken.

3.3.6.1 Constraining facets

Name has thefollowing·constraining facets·:

3.3.6.2 Derived datatypes

The following·built-in·datatypes are·derived· fromName:

NCName

3.3.7 NCName

[Definition:] NCName represents XML"non-colonized" Names. The·value space· ofNCName is the set of all strings which·match·theNCName production of[Namespaces in XML]. The·lexical space· ofNCName is the set of all strings which·match·theNCName production of[Namespaces in XML]. The·base type· ofNCName isName.

3.3.7.1 Constraining facets

NCName has thefollowing·constraining facets·:

3.3.7.2 Derived datatypes

The following·built-in·datatypes are·derived· fromNCName:

3.3.8 ID

[Definition:] ID represents theID attribute type from[XML 1.0 (Second Edition)]. The·value space· ofID is the set of all strings that·match·theNCName production in[Namespaces in XML]. The·lexical space· ofID is the set of allstrings that·match· theNCName production in[Namespaces in XML].The·base type· ofID isNCName.

For compatibility (seeTerminology (§1.4))ID should be used only on attributes.

3.3.8.1 Constraining facets

ID has thefollowing·constraining facets·:

3.3.9 IDREF

[Definition:] IDREF represents theIDREF attribute type from[XML 1.0 (Second Edition)]. The·value space· ofIDREF is the set of all strings that·match·theNCName production in[Namespaces in XML]. The·lexical space· ofIDREF is the set of strings that·match· theNCName production in[Namespaces in XML].The·base type· ofIDREF isNCName.

For compatibility (seeTerminology (§1.4)) this datatypeshould be used only on attributes.

3.3.9.1 Constraining facets

IDREF has thefollowing·constraining facets·:

3.3.9.2 Derived datatypes

The following·built-in·datatypes are·derived· fromIDREF:

IDREFS

3.3.10 IDREFS

[Definition:] IDREFS represents theIDREFS attribute type from[XML 1.0 (Second Edition)]. The·value space· ofIDREFS is the set of finite, non-zero-length sequences ofIDREFs.The·lexical space· ofIDREFS is theset of white space separated lists of tokens, of which each token is in the·lexical space· ofIDREF.The·itemType· ofIDREFS isIDREF.

For compatibility (seeTerminology (§1.4))IDREFSshould be used only on attributes.

3.3.10.1 Constraining facets

IDREFS has thefollowing·constraining facets·:

3.3.11 ENTITY

[Definition:] ENTITY represents theENTITY attribute type from[XML 1.0 (Second Edition)]. The·value space· ofENTITY is the set of all strings that·match·theNCName production in[Namespaces in XML] and have been declared as anunparsed entity inadocument type definition.The·lexical space· ofENTITY is the setof all strings that·match· theNCName production in[Namespaces in XML].The·base type· ofENTITY isNCName.

NOTE:The·value space· ofENTITY is scopedto a specific instance document.

For compatibility (seeTerminology (§1.4))ENTITYshould be used only on attributes.

3.3.11.1 Constraining facets

ENTITY has thefollowing·constraining facets·:

3.3.11.2 Derived datatypes

The following·built-in·datatypes are·derived· fromENTITY:

ENTITIES

3.3.12 ENTITIES

[Definition:] ENTITIESrepresents theENTITIES attributetype from[XML 1.0 (Second Edition)]. The·value space·ofENTITIES is the set of finite, non-zero-length sequences of·ENTITY·s that have been declared asunparsed entitiesin adocument type definition.The·lexical space· ofENTITIES is theset of white space separated lists of tokens, of which each token is in the·lexical space· ofENTITY.The·itemType· ofENTITIES isENTITY.

NOTE:The·value space· ofENTITIES is scopedto a specific instance document.

For compatibility (seeTerminology (§1.4))ENTITIESshould be used only on attributes.

3.3.12.1 Constraining facets

ENTITIES has thefollowing·constraining facets·:

3.3.13 integer

[Definition:] integer is·derived· fromdecimal by fixing thevalue of·fractionDigits· to be 0. This results in the standardmathematical concept of the integer numbers. The·value space· ofinteger is the infiniteset {...,-2,-1,0,1,2,...}. The·base type· ofinteger isdecimal.

3.3.13.1 Lexical representation

integer has a lexical representation consisting of a finite-length sequenceof decimal digits (#x30-#x39) with an optional leading sign. If the sign is omitted,"+" is assumed. For example: -1, 0, 12678967543233, +100000.

3.3.13.2 Canonical representation

The canonical representation forinteger is definedby prohibiting certain options from theLexical representation (§3.3.13.1). Specifically, the preceding optional "+" sign is prohibited and leading zeroes are prohibited.

3.3.13.3 Constraining facets

integer has thefollowing·constraining facets·:

3.3.13.4 Derived datatypes

The following·built-in·datatypes are·derived· frominteger:

3.3.14 nonPositiveInteger

[Definition:] nonPositiveInteger is·derived· frominteger by setting the value of·maxInclusive· to be 0. This results in thestandard mathematical concept of the non-positive integers.The·value space· ofnonPositiveIntegeris the infinite set {...,-2,-1,0}. The·base type·ofnonPositiveInteger isinteger.

3.3.14.1 Lexical representation

nonPositiveInteger has a lexical representation consistingof a negative sign ("-") followed by a finite-lengthsequence of decimal digits (#x30-#x39). If the sequence of digits consists of allzeros then the sign is optional.For example: -1, 0, -12678967543233, -100000.

3.3.14.2 Canonical representation

The canonical representation fornonPositiveInteger is definedby prohibiting certain options from theLexical representation (§3.3.14.1). Specifically, thenegative sign ("-") is required with the token "0" and leading zeroes are prohibited.

3.3.14.3 Constraining facets

nonPositiveInteger has thefollowing·constraining facets·:

3.3.14.4 Derived datatypes

The following·built-in·datatypes are·derived· fromnonPositiveInteger:

negativeInteger

3.3.15 negativeInteger

[Definition:] negativeInteger is·derived· fromnonPositiveInteger by setting the value of·maxInclusive· to be -1. This results in thestandard mathematical concept of the negative integers. The·value space· ofnegativeIntegeris the infinite set {...,-2,-1}. The·base type·ofnegativeInteger isnonPositiveInteger.

3.3.15.1 Lexical representation

negativeInteger has a lexical representation consistingof a negative sign ("-") followed by a finite-lengthsequence of decimal digits (#x30-#x39). For example: -1, -12678967543233, -100000.

3.3.15.2 Canonical representation

The canonical representation fornegativeInteger is definedby prohibiting certain options from theLexical representation (§3.3.15.1). Specifically, leading zeroes are prohibited.

3.3.15.3 Constraining facets

negativeInteger has thefollowing·constraining facets·:

3.3.16 long

[Definition:] long is·derived· frominteger by setting thevalue of·maxInclusive· to be 9223372036854775807and·minInclusive· to be -9223372036854775808.The·base type· oflong isinteger.

3.3.16.1 Lexical representation

long has a lexical representation consistingof an optional sign followed by a finite-lengthsequence of decimal digits (#x30-#x39). If the sign is omitted, "+" is assumed.For example: -1, 0,12678967543233, +100000.

3.3.16.2 Canonical representation

The canonical representation forlong is definedby prohibiting certain options from theLexical representation (§3.3.16.1). Specifically, thethe optional "+" sign is prohibited and leading zeroes are prohibited.

3.3.16.3 Constraining facets

long has thefollowing·constraining facets·:

3.3.16.4 Derived datatypes

The following·built-in·datatypes are·derived· fromlong:

3.3.17 int

[Definition:] intis·derived· fromlong by setting thevalue of·maxInclusive· to be 2147483647 and·minInclusive· to be -2147483648. The·base type· ofint islong.

3.3.17.1 Lexical representation

int has a lexical representation consistingof an optional sign followed by a finite-lengthsequence of decimal digits (#x30-#x39). If the sign is omitted, "+" is assumed.For example: -1, 0,126789675, +100000.

3.3.17.2 Canonical representation

The canonical representation forint is definedby prohibiting certain options from theLexical representation (§3.3.17.1). Specifically, thethe optional "+" sign is prohibited and leading zeroes are prohibited.

3.3.17.3 Constraining facets

int has thefollowing·constraining facets·:

3.3.17.4 Derived datatypes

The following·built-in·datatypes are·derived· fromint:

short

3.3.18 short

[Definition:] short is·derived· fromint by setting thevalue of·maxInclusive· to be 32767 and·minInclusive· to be -32768. The·base type· ofshort isint.

3.3.18.1 Lexical representation

short has a lexical representation consistingof an optional sign followed by a finite-length sequence of decimaldigits (#x30-#x39). If the sign is omitted, "+" is assumed.For example: -1, 0, 12678, +10000.

3.3.18.2 Canonical representation

The canonical representation forshort is definedby prohibiting certain options from theLexical representation (§3.3.18.1). Specifically, thethe optional "+" sign is prohibited and leading zeroes are prohibited.

3.3.18.3 Constraining facets

short has thefollowing·constraining facets·:

3.3.18.4 Derived datatypes

The following·built-in·datatypes are·derived· fromshort:

byte

3.3.19 byte

[Definition:] byteis·derived· fromshortby setting the value of·maxInclusive· to be 127and·minInclusive· to be -128.The·base type· ofbyte isshort.

3.3.19.1 Lexical representation

byte has a lexical representation consistingof an optional sign followed by a finite-lengthsequence of decimal digits (#x30-#x39). If the sign is omitted, "+" is assumed.For example: -1, 0,126, +100.

3.3.19.2 Canonical representation

The canonical representation forbyte is definedby prohibiting certain options from theLexical representation (§3.3.19.1). Specifically, thethe optional "+" sign is prohibited and leading zeroes are prohibited.

3.3.19.3 Constraining facets

byte has thefollowing·constraining facets·:

3.3.20 nonNegativeInteger

[Definition:] nonNegativeInteger is·derived· frominteger by setting the value of·minInclusive· to be 0. This results in thestandard mathematical concept of the non-negative integers. The·value space· ofnonNegativeIntegeris the infinite set {0,1,2,...}. The·base type· ofnonNegativeInteger isinteger.

3.3.20.1 Lexical representation

nonNegativeInteger has a lexical representation consistingof an optional sign followed by a finite-lengthsequence of decimal digits (#x30-#x39). If the sign is omitted, "+" is assumed.For example:1, 0, 12678967543233, +100000.

3.3.20.2 Canonical representation

The canonical representation fornonNegativeInteger is definedby prohibiting certain options from theLexical representation (§3.3.20.1). Specifically, thethe optional "+" sign is prohibited and leading zeroes are prohibited.

3.3.20.3 Constraining facets

nonNegativeInteger has thefollowing·constraining facets·:

3.3.20.4 Derived datatypes

The following·built-in·datatypes are·derived· fromnonNegativeInteger:

3.3.21 unsignedLong

[Definition:] unsignedLong is·derived· fromnonNegativeInteger by setting the value of·maxInclusive· to be 18446744073709551615.The·base type· ofunsignedLong isnonNegativeInteger.

3.3.21.1 Lexical representation

unsignedLong has a lexical representation consistingof a finite-length sequence of decimal digits (#x30-#x39).For example: 0,12678967543233, 100000.

3.3.21.2 Canonical representation

The canonical representation forunsignedLong is definedby prohibiting certain options from theLexical representation (§3.3.21.1). Specifically, leading zeroes are prohibited.

3.3.21.3 Constraining facets

unsignedLong has thefollowing·constraining facets·:

3.3.21.4 Derived datatypes

The following·built-in·datatypes are·derived· fromunsignedLong:

unsignedInt

3.3.22 unsignedInt

[Definition:] unsignedInt is·derived· fromunsignedLong by setting the value of·maxInclusive· to be 4294967295. The·base type· ofunsignedInt isunsignedLong.

3.3.22.1 Lexical representation

unsignedInt has a lexical representation consistingof a finite-lengthsequence of decimal digits (#x30-#x39). For example: 0,1267896754, 100000.

3.3.22.2 Canonical representation

The canonical representation forunsignedInt is definedby prohibiting certain options from theLexical representation (§3.3.22.1). Specifically, leading zeroes are prohibited.

3.3.22.3 Constraining facets

unsignedInt has thefollowing·constraining facets·:

3.3.22.4 Derived datatypes

The following·built-in·datatypes are·derived· fromunsignedInt:

unsignedShort

3.3.23 unsignedShort

[Definition:] unsignedShort is·derived· fromunsignedInt by setting the value of·maxInclusive· to be 65535. The·base type· ofunsignedShort isunsignedInt.

3.3.23.1 Lexical representation

unsignedShort has a lexical representation consistingof a finite-lengthsequence of decimal digits (#x30-#x39).For example: 0,12678, 10000.

3.3.23.2 Canonical representation

The canonical representation forunsignedShort is definedby prohibiting certain options from theLexical representation (§3.3.23.1). Specifically, theleading zeroes are prohibited.

3.3.23.3 Constraining facets

unsignedShort has thefollowing·constraining facets·:

3.3.23.4 Derived datatypes

The following·built-in·datatypes are·derived· fromunsignedShort:

unsignedByte

3.3.24 unsignedByte

[Definition:] unsignedByte is·derived· fromunsignedShort by setting the value of·maxInclusive· to be 255. The·base type· ofunsignedByte isunsignedShort.

3.3.24.1 Lexical representation

unsignedByte has a lexical representation consistingof a finite-lengthsequence of decimal digits (#x30-#x39).For example: 0,126, 100.

3.3.24.2 Canonical representation

The canonical representation forunsignedByte is definedby prohibiting certain options from theLexical representation (§3.3.24.1). Specifically, leading zeroes are prohibited.

3.3.24.3 Constraining facets

unsignedByte has thefollowing·constraining facets·:

3.3.25 positiveInteger

[Definition:] positiveInteger is·derived· fromnonNegativeInteger by setting the value of·minInclusive· to be 1. This results in the standardmathematical concept of the positive integer numbers. The·value space· ofpositiveIntegeris the infinite set {1,2,...}. The·base type· ofpositiveInteger isnonNegativeInteger.

3.3.25.1 Lexical representation

positiveInteger has a lexical representation consistingof an optional positive sign ("+") followed by a finite-lengthsequence of decimal digits (#x30-#x39).For example: 1, 12678967543233, +100000.

3.3.25.2 Canonical representation

The canonical representation forpositiveInteger is definedby prohibiting certain options from theLexical representation (§3.3.25.1). Specifically, theoptional "+" sign is prohibited and leading zeroes are prohibited.

3.3.25.3 Constraining facets

positiveInteger has thefollowing·constraining facets·:

4 Datatype components

The following sections provide full details on the properties andsignificance of each kind of schema component involved in datatypedefinitions. For each property, the kinds of values it is allowed to have isspecified. Any property not identified as optional is required tobe present; optional properties which are not present haveabsent as their value.Any property identified as a having a set, subset or·list·value may have an empty value unless this is explicitly ruled out: this isnot the same asabsent.Any property value identified as a superset or a subset of some set maybe equal to that set, unless a proper superset or subset is explicitlycalled for.

For more information on the notion of datatype (schema) components,seeSchema Component Detailsof[XML Schema Part 1: Structures].

4.1 Simple Type Definition

4.1.1The Simple Type Definition Schema Component

4.1.2XML Representation of Simple Type Definition Schema Components

4.1.3Constraints on XML Representation of Simple Type Definition

4.1.4Simple Type Definition Validation Rules

4.1.5Constraints on Simple Type Definition Schema Components

4.1.6Simple Type Definition for anySimpleType

Simple Type definitions provide for:

Establishing the·value space· and·lexical space·of a datatype, throughthe combined set of·constraining facet·s specifiedin the definition;
Attaching a unique name (actually aQName) to the·value space· and·lexical space·.

4.1.1 The Simple Type Definition Schema Component

The Simple Type Definition schema component has the following properties:

Schema Component: Simple Type Definition

{name}

Optional. An NCName as defined by[Namespaces in XML].

{target namespace}

Eitherabsent or anamespace name, as defined in[Namespaces in XML].

{variety}

One of {atomic,list,union}. Depending on thevalue of{variety}, further properties are defined as follows:

atomic

{primitive type definition}: A·built-in· ·primitive·datatype definition (or thesimple ur-type definition).

list

{item type definition}: An·atomic· or·union· simple type definition.

union

{member type definitions}: A non-empty sequence of simple type definitions.

{facets}

A possibly empty set ofFacets (§2.4).

{fundamental facets}

A set ofFundamental facets (§2.4.1)

{base type definition}

If the datatype has been·derived· by·restriction· then theSimple Type Definition componentfrom which it is·derived·, otherwisetheSimple Type Definition for anySimpleType (§4.1.6).

{final}

A subset of{restriction, list, union}.

{annotation}

Optional. Anannotation.

Datatypes are identified by their{name}and{target namespace}. Exceptfor anonymous datatypes (those with no{name}),datatype definitions·must· be uniquely identifiedwithin a schema.

If{variety} is·atomic·then the·value space· of the datatype defined willbe a subset of the·value space· of{base type definition} (which is a subset of the·value space· of{primitive type definition}).If{variety} is·list·then the·value space· of the datatype defined willbe the set of finite-length sequence of values from the·value space· of{item type definition}.If{variety} is·union· then the·value space· of the datatype defined will be theunion of the·value space·s of each datatype in{member type definitions}.

If{variety} is·atomic·then the{variety} of{base type definition} must be·atomic·.If{variety} is·list·then the{variety} of{item type definition}must be either·atomic· or·union·.If{variety} is·union·then{member type definitions} must be a list of datatype definitions.

The value of{facets} consists of the set of·facet·s specified directly in the datatype definitionunioned with the possibly empty set of{facets} of{base type definition}.

The value of{fundamental facets} consists of the set of·fundamental facet·s and their values.

If{final} is the empty set then the type can be usedin deriving other types; the explicit valuesrestriction,list andunion prevent further derivationsby·restriction·,·list· and·union· respectively.

4.1.2 XML Representation of Simple Type Definition Schema Components

The XML representation for aSimple Type Definition schema componentis a<simpleType> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: simpleType Element Information Item

<simpleType
  final = (#all | (list |union |restriction))
  id =ID
  name =NCName
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?, (restriction |list |union))
</simpleType>

Datatype Definition Schema Component

Property	Representation
{name}	Theactual value of the`name` [attribute], if present,otherwisenull
{final}	A set corresponding to theactual value of the`final` [attribute], if present, otherwise of theactual value of the`finalDefault` [attribute] the ancestorschemaelement information item, if present, otherwise the empty string, as follows: the empty string the empty set; `#all` {restriction, list, union}; *otherwise* a set with members drawn from the set above, each being present orabsent depending on whether the string contains an equivalently namedspace-delimited substring. NOTE: Although the`finalDefault` [attribute] ofschema may include values other thanrestriction,list orunion, those values are ignored in the determination of{final}
{target namespace}	Theactual value of the`targetNamespace` [attribute]of the parent`schema` element information item.
{annotation}	The annotation corresponding to the<annotation>element information item in the [children], if present, otherwisenull

A·derived· datatype can be·derived·from a·primitive· datatype or another·derived· datatype by one of three means:byrestriction, bylist or byunion.

4.1.2.1 Derivation by restriction

XML Representation Summary: restriction Element Information Item

<restriction
  base =QName
  id =ID
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?, (simpleType?, (minExclusive |minInclusive |maxExclusive |maxInclusive |totalDigits |fractionDigits |length |minLength |maxLength |enumeration |whiteSpace |pattern)*))
</restriction>

Simple Type Definition Schema Component

Property	Representation
{variety}	Theactual value of{variety} of{base type definition}
{facets}	The union of the set ofFacets (§2.4) components resolved to by the facet [children] merged with{facets}from{base type definition}, subject to the Facet Restriction Validconstraints specified inFacets (§2.4).
{base type definition}	TheSimple Type Definition component resolved to by theactual value of the`base` [attribute] or the<simpleType> [children],whichever is present.

Example

An electronic commerce schema might define a datatype calledSku (the barcode number that appears on products) from the·built-in· datatypestring bysupplying a value for the·pattern· facet.

<simpleType name='Sku'>    <restriction base='string'>      <pattern value='\d{3}-[A-Z]{2}'/>    </restriction></simpleType>

In this case,Sku is the name of the new·user-derived· datatype,string isits·base type· and·pattern·is the facet.

4.1.2.2 Derivation by list

XML Representation Summary: list Element Information Item

<list
  id =ID
  itemType =QName
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?, (simpleType?))
</list>

Simple Type Definition Schema Component

Property	Representation
{variety}	list
{item type definition}	TheSimple Type Definition component resolved to by theactual value of the`itemType` [attribute]or the<simpleType> [children],whichever is present.

A·list· datatype must be·derived·from an·atomic· or a·union· datatype,known as the·itemType· of the·list· datatype.This yields a datatype whose·value space· is composed offinite-length sequences of values from the·value space· of the·itemType· and whose·lexical space· iscomposed of white space separated lists of literals of the·itemType·.

Example

A system might want to store lists of floating point values.

<simpleType name='listOfFloat'>  <list itemType='float'/></simpleType>

In this case,listOfFloat is the name of the new·user-derived· datatype,float is its·itemType· and·list· is thederivation method.

As mentioned inList datatypes (§2.5.1.2),when a datatype is·derived· from a·list· datatype, the following·constraining facet·s can be used:

regardless of the·constraining facet·s that are applicableto the·atomic· datatype that serves as the·itemType· of the·list·.

For each of·length·,·maxLength·and·minLength·, theunit of length is measured in number of list items.The value of·whiteSpace·is fixed to the valuecollapse.

4.1.2.3 Derivation by union

XML Representation Summary: union Element Information Item

<union
  id =ID
  memberTypes = List ofQName
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?, (simpleType*))
</union>

Simple Type Definition Schema Component

Property Representation

{variety} union

{member type definitions} The sequence ofSimple Type Definition components resolved to by theitems in theactual value of thememberTypes [attribute], if any,in order, followed by theSimple Type Definition components resolved to by the<simpleType> [children], if any, in order.If{variety} isunion foranySimple Type Definition components resolved to above, thenthe thatSimple Type Definition is replaced by its{member type definitions}.

A·union· datatype can be·derived·from one or more·atomic·,·list· orother·union· datatypes, known as the·memberTypes·of that·union· datatype.

Example

As an example, taken from a typical display oriented text markup language,one might want to express font sizes as an integer between 8 and 72, or withone of the tokens "small", "medium" or "large". The·union·type definition below would accomplish that.

<xsd:attribute name="size">  <xsd:simpleType>    <xsd:union>      <xsd:simpleType>        <xsd:restriction base="xsd:positiveInteger">          <xsd:minInclusive value="8"/>          <xsd:maxInclusive value="72"/>        </xsd:restriction>      </xsd:simpleType>      <xsd:simpleType>        <xsd:restriction base="xsd:NMTOKEN">          <xsd:enumeration value="small"/>          <xsd:enumeration value="medium"/>          <xsd:enumeration value="large"/>        </xsd:restriction>      </xsd:simpleType>    </xsd:union>  </xsd:simpleType></xsd:attribute>

<p><font size='large'>A header</font></p><p><font size='12'>this is a test</font></p>

As mentioned inUnion datatypes (§2.5.1.3),when a datatype is·derived· from a·union· datatype, the only following·constraining facet·s can be used:

regardless of the·constraining facet·s that areapplicable to the datatypes that participate in the·union·

4.1.3 Constraints on XML Representation of Simple Type Definition

Schema Representation Constraint: Single Facet Value

Unless otherwise specifically allowed by this specification(Multiple patterns (§4.3.4.3) andMultiple enumerations (§4.3.5.3)) any given·constraining facet· can only be specifed once withina single derivation step.

Schema Representation Constraint: itemType attribute or simpleType child

Either theitemType [attribute] or the<simpleType> [child] of the<list> elementmust be present, but not both.

Schema Representation Constraint: base attribute or simpleType child

Either thebase [attribute] or thesimpleType [child] of the<restriction>element must be present, but not both.

Schema Representation Constraint: memberTypes attribute or simpleType children

Either thememberTypes [attribute] of the<union>element must be non-empty orthere must be at least onesimpleType [child].

4.1.4 Simple Type Definition Validation Rules

Validation Rule: Facet Valid

A value in a·value space· is facet-valid withrespect to a·constraining facet· component if:

1 the value is facet-valid with respect to the particular·constraining facet· as specified below.

Validation Rule: Datatype Valid

A string is datatype-valid with respect to a datatype definition if:

1 it·match·es a literal in the·lexical space· of the datatype, determined as follows:

1.1 if·pattern· is a member of{facets},then the string must bepattern valid (§4.3.4.4);

1.2 if·pattern· is not a member of{facets},then

1.2.1 if{variety} is·atomic· thenthe string must·match· a literal in the·lexical space· of{base type definition}

1.2.2 if{variety} is·list· thenthe string must be a sequence of white space separated tokens, each ofwhich·match·es a literal in the·lexical space· of{item type definition}

1.2.3 if{variety} is·union· thenthe string must·match· a literal in the·lexical space· of at least one member of{member type definitions}

2 the value denoted by the literal·match·ed in the previous stepis a member of the·value space· of the datatype, as determinedby it beingFacet Valid (§4.1.4)with respect to each member of{facets} (exceptfor·pattern·).

4.1.5 Constraints on Simple Type Definition Schema Components

Schema Component Constraint: applicable facets

The·constraining facet·s which are allowedto be members of{facets} are dependent on{base type definition} as specified in the following table:

{base type definition}	applicable{facets}
If{variety} islist,then
[all datatypes]	length,minLength,maxLength,pattern,enumeration,whiteSpace
If{variety} isunion, then
[all datatypes]	pattern,enumeration
else if{variety} isatomic, then
string	length,minLength,maxLength,pattern,enumeration,whiteSpace
boolean	pattern,whiteSpace
float	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
double	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
decimal	totalDigits,fractionDigits,pattern,whiteSpace,enumeration,maxInclusive,maxExclusive,minInclusive,minExclusive
duration	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
dateTime	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
time	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
date	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
gYearMonth	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
gYear	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
gMonthDay	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
gDay	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
gMonth	pattern,enumeration,whiteSpace,maxInclusive,maxExclusive,minInclusive,minExclusive
hexBinary	length,minLength,maxLength,pattern,enumeration,whiteSpace
base64Binary	length,minLength,maxLength,pattern,enumeration,whiteSpace
anyURI	length,minLength,maxLength,pattern,enumeration,whiteSpace
QName	length,minLength,maxLength,pattern,enumeration,whiteSpace
NOTATION	length,minLength,maxLength,pattern,enumeration,whiteSpace

Schema Component Constraint: list of atomic

If{variety} is·list·, thenthe{variety} of{item type definition} ·must· be·atomic· or·union·.

Schema Component Constraint: no circular unions

If{variety} is·union·,thenit is an·error· if{name} and{target namespace} ·match· {name}and{target namespace} of any member of{member type definitions}.

4.1.6 Simple Type Definition for anySimpleType

There is a simple type definition nearly equivalent to the simple versionof theur-type definition presentin every schema by definition. It has the following properties:

Schema Component: anySimpleType

{name}: anySimpleType
{target namespace}: http://www.w3.org/2001/XMLSchema
{basetype definition}: the ur-type definition
{final}: the empty set
{variety}: absent

4.2 Fundamental Facets

4.2.1equal

4.2.2ordered

4.2.3bounded

4.2.4cardinality

4.2.5numeric

4.2.1 equal

Every·value space· supports the notion of equality,with the following rules:

for anya andb inthe·value space·,eithera is equal tob,denoteda = b, orais not equal tob, denoteda != b
there is no paira andbfrom the·value space· such that botha = b anda != b
for alla in the·value space·,a = a
for anya andbin the·value space·,a = b if and only ifb = a
for anya,b andc in the·value space·,ifa = b andb = c, thena = c
for anya andbin the·value space·ifa = b, thenaandb cannot be distinguished(i.e., equality is identity)

Note that a consequence of the above is that, given·value space· A and·value space· B whereA andB are not related by·restriction·or·union·,for every pair of valuesa fromA andb fromB,a != b.

On every datatype, the operation Equal is defined in terms of the equalityproperty of the·value space·: for any valuesa, b drawn from the·value space·,Equal(a,b) istrue ifa = b, and false otherwise.

NOTE:There is no schema component corresponding to theequal·fundamental facet·.

4.2.2 ordered

[Definition:] Anorder relation on a·value space·is a mathematical relation that imposes a·total order· or a·partial order· on themembers of the·value space·.

[Definition:] A·value space·, and hence a datatype, is said to beordered if there exists an·order-relation· defined for that·value space·.

[Definition:] Apartial order is an·order-relation·that isirreflexive,asymmetric andtransitive.

A·partial order· has the following properties:

for noa in the·value space·,a < a(irreflexivity)
for alla andbin the·value space·,a < bimplies not(b < a)(asymmetry)
for alla,bandc in the·value space·,a < b andb < cimpliesa < c(transitivity)

The notationa <> b is used to indicate thecase whena != b and neithera < b norb < a

[Definition:] Atotal order is an·partial order·such that for noa andbis it the case thata <> b.

A·total order· has all of the properties specifiedabove for·partial order·, plusthe following property:

for alla andb in the·value space·,eithera < b orb < aora = b

NOTE:The fact that this specification does not define an·order-relation· for some datatype does notmean that some other application cannot treat that datatype asbeing ordered by imposing its own order relation.

·ordered· provides for:

indicating whether an·order-relation· isdefined on a·value space·, and if so,whether that·order-relation· isa·partial order· or a·total order·

4.2.2.1 The ordered Schema Component

Schema Component: ordered

{value}: One of{false, partial, total}.

{value} depends on{variety},{facets} and{member type definitions}in theSimple Type Definition component in which a·ordered· component appears as a member of{fundamental facets}.

When{variety} is·atomic·,{value} is inherited from{value} of{base type definition}.For all·primitive· types{value}is as specifiedin the table inFundamental Facets (§C.1).

When{variety} is·list·,{value} isfalse.

When{variety} is·union·,if{value} istruefor every member of{member type definitions}and all members of{member type definitions} share a commonancestor, then{value} istrue;else{value} isfalse.

4.2.3 bounded

[Definition:] A valueu in an·ordered· ·value space· Uis said to be aninclusive upper bound of a·value space· V(whereV is a subset ofU)if for allv inV,u >=v.

[Definition:] A valueu in an·ordered· ·value space· Uis said to be anexclusive upper bound of a·value space· V(whereV is a subset ofU)if for allv inV,u >v.

[Definition:] A valuel in an·ordered· ·value space· Lis said to be aninclusive lower bound of a·value space· V(whereV is a subset ofL)if for allv inV,l <=v.

[Definition:] A valuel in an·ordered· ·value space· Lis said to be anexclusive lower bound of a·value space· V(whereV is a subset ofL)if for allv inV,l <v.

[Definition:] A datatype isboundedif its·value space· has either an·inclusive upper bound· or an·exclusive upper bound·and either an·inclusive lower bound· and an·exclusive lower bound·.

·bounded· provides for:

indicating whether a·value space· is·bounded·

4.2.3.1 The bounded Schema Component

Schema Component: bounded

{value}: Aboolean.

{value} depends on{variety},{facets} and{member type definitions}in theSimple Type Definition component in which a·bounded· component appears as a member of{fundamental facets}.

When{variety} is·atomic·,if one of·minInclusive· or·minExclusive·and one of·maxInclusive· or·maxExclusive·are among{facets} , then{value} istrue; else{value} isfalse.

When{variety} is·list·,if·length· or both of·minLength· and·maxLength·are among{facets}, then{value} istrue; else{value} isfalse.

When{variety} is·union·,if{value} istruefor every member of{member type definitions}and all members of{member type definitions} share a commonancestor, then{value} istrue;else{value} isfalse.

4.2.4 cardinality

[Definition:] Every·value space· has associated with it the concept ofcardinality. Some·value space·sare finite, some are countably infinite while still others couldconceivably be uncountably infinite (although no·value space·defined by this specification is uncountable infinite). A datatype issaid to have the cardinality of its·value space·.

Itis sometimes useful to categorize·value space·s(and hence, datatypes) as to their cardinality. There are twosignificant cases:

·value space·s that are finite
·value space·s that are countably infinite

·cardinality· provides for:

indicating whether the·cardinality·of a·value space· isfinite orcountably infinite

4.2.4.1 The cardinality Schema Component

Schema Component: cardinality

{value}: One of{finite, countably infinite}.

{value} depends on{variety},{facets} and{member type definitions}in theSimple Type Definition component in which a·cardinality· component appears as a member of{fundamental facets}.

When{variety} is·atomic· and{value} of{base type definition}isfinite, then{value} isfinite.

When{variety} is·atomic· and{value} of{base type definition}iscountably infinite andeither of the followingconditions are true, then{value} isfinite; else{value}iscountably infinite:

one of·length·,·maxLength·,·totalDigits· is among{facets},
all of the following are true:
1. one of·minInclusive· or·minExclusive·is among{facets}
2. one of·maxInclusive· or·maxExclusive·is among{facets}
3. either of the following are true:
  1. ·fractionDigits· is among{facets}
  2. {base type definition} is one ofdate,gYearMonth,gYear,gMonthDay,gDay orgMonth or any type·derived·from them

When{variety} is·list·,if·length· or both of·minLength· and·maxLength·are among{facets}, then{value} isfinite; else{value} iscountably infinite.

When{variety} is·union·,if{value} isfinitefor every member of{member type definitions}, then{value} isfinite;else{value} iscountably infinite.

4.2.5 numeric

[Definition:] A datatype is said to benumeric if its values are conceptually quantities (in somemathematical number system).

[Definition:] A datatype whose valuesare not·numeric· is said to benon-numeric.

·numeric· provides for:

indicating whether a·value space· is·numeric·

4.2.5.1 The numeric Schema Component

Schema Component: numeric

{value}: Aboolean

{value} depends on{variety},{facets},{base type definition} and{member type definitions} in theSimple Type Definition componentin which a·cardinality· component appears as a member of{fundamental facets}.

When{variety} is·atomic·,{value} is inherited from{value} of{base type definition}.For all·primitive· types{value}is as specifiedin the table inFundamental Facets (§C.1).

When{variety} is·list·,{value} isfalse.

When{variety} is·union·,if{value} istruefor every member of{member type definitions}, then{value} istrue;else{value} isfalse.

4.3 Constraining Facets

4.3.1length

4.3.2minLength

4.3.3maxLength

4.3.4pattern

4.3.5enumeration

4.3.6whiteSpace

4.3.7maxInclusive

4.3.8maxExclusive

4.3.9minExclusive

4.3.10minInclusive

4.3.11totalDigits

4.3.12fractionDigits

4.3.1 length

[Definition:] length is the numberofunits of length, whereunits of lengthvaries depending on the type that is being·derived· from.The value oflength ·must· be anonNegativeInteger.

Forstring and datatypes·derived· fromstring,length is measured in units ofcharacters as defined in[XML 1.0 (Second Edition)].ForanyURI,length is measured in units ofcharacters (as forstring).ForhexBinary andbase64Binary and datatypes·derived· from them,length is measured in octets (8 bits) of binary data.For datatypes·derived· by·list·,length is measured in number of list items.

NOTE:Forstring and datatypes·derived· fromstring,length will not always coincide with "string length" as perceivedby some users or with the number of storage units in some digital representation.Therefore, care should be taken when specifying a value forlengthand in attempting to infer storage requirements from a given value forlength.

·length· provides for:

Constraining a·value space·to values with a specific number ofunits of length,whereunits of lengthvaries depending on{base type definition}.

Example

The following is the definition of a·user-derived·datatype to represent product codes which must beexactly 8 characters in length. By fixing the value of thelength facet we ensure that types derived from productCode canchange or set the values of other facets, such aspattern, butcannot change the length.

<simpleType name='productCode'>   <restriction base='string'>     <length value='8' fixed='true'/>   </restriction></simpleType>

4.3.1.1 The length Schema Component

Schema Component: length

{value}: AnonNegativeInteger.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue forlength other than{value}.

4.3.1.2 XML Representation of length Schema Components

The XML representation for alength schemacomponent is a<length> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: length Element Information Item

<length
  fixed =boolean : false
  id =ID
  value =nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</length>

length Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.1.3 length Validation Rules

Validation Rule: Length Valid

A value in a·value space· is facet-valid withrespect to·length·, determined as follows:

1 if the{variety} is·atomic· then

1.1 if{primitive type definition} isstring, then thelength of the value, as measured incharacters·must· be equal to{value};

1.2 if{primitive type definition} ishexBinary orbase64Binary, then thelength of the value, as measured in octets of the binary data,·must· be equal to{value};

2 if the{variety} is·list·,then the length of the value, as measuredin list items,·must· be equal to{value}

4.3.1.4 Constraints on length Schema Components

Schema Component Constraint: length and minLength or maxLength

It is an·error· for bothlength and either ofminLength ormaxLengthto be members of{facets}.

Schema Component Constraint: length valid restriction

It is an·error· iflengthis among the members of{facets} of{base type definition} and{value} isnot equal to the{value} of the parentlength.

4.3.2 minLength

[Definition:] minLength isthe minimum number ofunits of length, whereunits of length varies depending on the type that is being·derived· from.The value ofminLength ·must· be anonNegativeInteger.

Forstring and datatypes·derived· fromstring,minLength is measured in units ofcharacters as defined in[XML 1.0 (Second Edition)].ForhexBinary andbase64Binary and datatypes·derived· from them,minLength is measured in octets (8 bits) of binary data.For datatypes·derived· by·list·,minLength is measured in number of list items.

NOTE:Forstring and datatypes·derived· fromstring,minLength will not always coincide with "string length" as perceivedby some users or with the number of storage units in some digital representation.Therefore, care should be taken when specifying a value forminLengthand in attempting to infer storage requirements from a given value forminLength.

·minLength· provides for:

Constraining a·value space·to values with at least a specific number ofunits of length,whereunits of lengthvaries depending on{base type definition}.

Example

The following is the definition of a·user-derived·datatype which requires strings to have at least one character (i.e.,the empty string is not in the·value space·of this datatype).

<simpleType name='non-empty-string'>  <restriction base='string'>    <minLength value='1'/>  </restriction></simpleType>

4.3.2.1 The minLength Schema Component

Schema Component: minLength

{value}: AnonNegativeInteger.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue forminLength other than{value}.

4.3.2.2 XML Representation of minLength Schema Component

The XML representation for aminLength schemacomponent is a<minLength> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: minLength Element Information Item

<minLength
  fixed =boolean : false
  id =ID
  value =nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</minLength>

minLength Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.2.3 minLength Validation Rules

Validation Rule: minLength Valid

A value in a·value space· is facet-valid withrespect to·minLength·, determined as follows:

1 if the{variety} is·atomic· then

1.1 if{primitive type definition} isstring, then thelength of the value, as measured incharacters·must· be greater than or equal to{value};

1.2 if{primitive type definition} ishexBinary orbase64Binary, then thelength of the value, as measured in octets of the binary data,·must· be greater than or equal to{value};

2 if the{variety} is·list·,then the length of the value, as measuredin list items,·must· be greater than or equalto{value}

4.3.2.4 Constraints on minLength Schema Components

Schema Component Constraint: minLength <= maxLength

If bothminLength andmaxLengthare members of{facets}, then the{value} ofminLength ·must· be less than or equal to the{value} ofmaxLength.

Schema Component Constraint: minLength valid restriction

It is an·error· ifminLengthis among the members of{facets} of{base type definition} and{value} isless than the{value} of the parentminLength.

4.3.3 maxLength

[Definition:] maxLength isthe maximum number ofunits of length, whereunits of length variesdepending on the type that is being·derived· from.The value ofmaxLength ·must· be anonNegativeInteger.

Forstring and datatypes·derived· fromstring,maxLength is measured in units ofcharacters as defined in[XML 1.0 (Second Edition)].ForhexBinary andbase64Binary and datatypes·derived· from them,maxLength is measured in octets (8 bits) of binary data.For datatypes·derived· by·list·,maxLength is measured in number of list items.

NOTE:Forstring and datatypes·derived· fromstring,maxLength will not always coincide with "string length" as perceivedby some users or with the number of storage units in some digital representation.Therefore, care should be taken when specifying a value formaxLengthand in attempting to infer storage requirements from a given value formaxLength.

·maxLength· provides for:

Constraining a·value space·to values with at most a specific number ofunits of length,whereunits of lengthvaries depending on{base type definition}.

Example

The following is the definition of a·user-derived·datatype which might be used to accept form input with an upper limitto the number of characters that are acceptable.

<simpleType name='form-input'>  <restriction base='string'>    <maxLength value='50'/>  </restriction></simpleType>

4.3.3.1 The maxLength Schema Component

Schema Component: maxLength

{value}: AnonNegativeInteger.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue formaxLength other than{value}.

4.3.3.2 XML Representation of maxLength Schema Components

The XML representation for amaxLength schemacomponent is a<maxLength> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: maxLength Element Information Item

<maxLength
  fixed =boolean : false
  id =ID
  value =nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</maxLength>

maxLength Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.3.3 maxLength Validation Rules

Validation Rule: maxLength Valid

A value in a·value space· is facet-valid withrespect to·maxLength·, determined as follows:

1 if the{variety} is·atomic· then

1.1 if{primitive type definition} isstring, then thelength of the value, as measured incharacters·must· be less than or equal to{value};

1.2 if{primitive type definition} ishexBinary orbase64Binary, then thelength of the value, as measured in octets of the binary data,·must· be less than or equal to{value};

2 if the{variety} is·list·,then the length of the value, as measuredin list items,·must· be less than or equal to{value}

4.3.3.4 Constraints on maxLength Schema Components

Schema Component Constraint: maxLength valid restriction

It is an·error· ifmaxLengthis among the members of{facets} of{base type definition} and{value} isgreater than the{value} of the parentmaxLength.

4.3.4 pattern

[Definition:] pattern is a constraint on the·value space· of a datatype which is achieved byconstraining the·lexical space· to literalswhich match a specific pattern. The value ofpattern ·must· be a·regular expression·.

·pattern· provides for:

Constraining a·value space·to values that are denoted by literals which match a specific·regular expression·.

Example

The following is the definition of a·user-derived·datatype which is a better representation of postal codes in theUnited States, by limiting strings to those which are matched bya specific·regular expression·.

<simpleType name='better-us-zipcode'>  <restriction base='string'>    <pattern value='[0-9]{5}(-[0-9]{4})?'/>  </restriction></simpleType>

4.3.4.1 The pattern Schema Component

Schema Component: pattern

{value}: A·regular expression·.
{annotation}: Optional. Anannotation.

4.3.4.2 XML Representation of pattern Schema Components

The XML representation for apattern schemacomponent is a<pattern> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: pattern Element Information Item

<pattern
  id =ID
  value =anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</pattern>

{value} ·must· be a valid·regular expression·.

pattern Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.4.3 Constraints on XML Representation of pattern

Schema Representation Constraint: Multiple patterns

If multiple<pattern> element information items appear as [children] of a<simpleType>, the [value]s shouldbe combined as if they appeared in a single·regular expression· as separate·branch·es.

NOTE:It is a consequence of the schema representation constraintMultiple patterns (§4.3.4.3) and of the rules for·restriction· that·pattern·facets specified on thesame step in a typederivation areORed together, while·pattern·facets specified ondifferent steps of a type derivationareANDed together.
Thus, to impose two·pattern· constraints simultaneously,schema authors may either write a single·pattern· whichexpresses the intersection of the two·pattern·s they wish toimpose, or define each·pattern· on a separate type derivationstep.

4.3.4.4 pattern Validation Rules

Validation Rule: pattern valid

A literal in a·lexical space· is facet-valid withrespect to·pattern· if:

1 the literal is among the set of character sequences denoted bythe·regular expression· specified in{value}.

4.3.5 enumeration

[Definition:] enumeration constrains the·value space·to a specified set of values.

enumeration does not impose an order relation on the·value space· it creates; the value of the·ordered· property of the·derived·datatype remains that of the datatype from which it is·derived·.

·enumeration· provides for:

Constraining a·value space·to a specified set of values.

Example

The following example is a datatype definition for a·user-derived· datatype which limits the valuesof dates to the three US holidays enumerated. This datatypedefinition would appear in a schema authored by an "end-user" andshows how to define a datatype by enumerating the values in its·value space·. The enumerated values must betype-valid literals for the·base type·.

<simpleType name='holidays'>    <annotation>        <documentation>some US holidays</documentation>    </annotation>    <restriction base='gMonthDay'>      <enumeration value='--01-01'>        <annotation>            <documentation>New Year's day</documentation>        </annotation>      </enumeration>      <enumeration value='--07-04'>        <annotation>            <documentation>4th of July</documentation>        </annotation>      </enumeration>      <enumeration value='--12-25'>        <annotation>            <documentation>Christmas</documentation>        </annotation>      </enumeration>    </restriction>  </simpleType>

4.3.5.1 The enumeration Schema Component

Schema Component: enumeration

{value}: A set of values from the·value space· of the{base type definition}.
{annotation}: Optional. Anannotation.

4.3.5.2 XML Representation of enumeration Schema Components

The XML representation for anenumeration schemacomponent is an<enumeration> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: enumeration Element Information Item

<enumeration
  id =ID
  value =anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</enumeration>

{value} ·must· bein the·value space· of{base type definition}.

enumeration Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.5.3 Constraints on XML Representation of enumeration

Schema Representation Constraint: Multiple enumerations

If multiple<enumeration> element information items appearas [children] of a<simpleType> the{value} of theenumerationcomponent should be the set of all such [value]s.

4.3.5.4 enumeration Validation Rules

Validation Rule: enumeration valid

A value in a·value space· is facet-valid withrespect to·enumeration· ifthe value is one of the values specified in{value}

4.3.5.5 Constraints on enumeration Schema Components

Schema Component Constraint: enumeration valid restriction

It is an·error· if any member of{value} is not in the·value space·of{base type definition}.

4.3.6 whiteSpace

[Definition:] whiteSpace constrains the·value space·of types·derived· fromstring such thatthe various behaviorsspecified inAttribute Value Normalizationin[XML 1.0 (Second Edition)] are realized. The value ofwhiteSpace must be one of {preserve, replace, collapse}.

preserve: No normalization is done, the value is not changed (this is thebehavior required by[XML 1.0 (Second Edition)] for element content)
replace: All occurrences of #x9 (tab), #xA (line feed) and #xD (carriage return)are replaced with #x20 (space)
collapse: After the processing implied byreplace, contiguoussequences of #x20's are collapsed to a single #x20, and leading andtrailing #x20's are removed.

NOTE:The notation #xA used here (and elsewhere in this specification) representsthe Universal Character Set (UCS) code pointhexadecimal A (line feed), which is denoted byU+000A. This notation is to be distinguished from
,which is the XMLcharacter referenceto that same UCS code point.

whiteSpace is applicable to all·atomic· and·list· datatypes. For all·atomic·datatypes other thanstring (and types·derived·by·restriction· from it) the value ofwhiteSpace iscollapse and cannot be changed by a schema author; forstring the value ofwhiteSpace ispreserve; for any type·derived· by·restriction· fromstring the value ofwhiteSpace canbe any of the three legal values. For all datatypes·derived· by·list· thevalue ofwhiteSpace iscollapse and cannotbe changed by a schema author. For all datatypes·derived· by·union· whiteSpace does not apply directly; however, thenormalization behavior of·union· types is controlled bythe value ofwhiteSpace on that one of the·memberTypes· against which the·union·is successfully validated.

NOTE:For more information onwhiteSpace, see thediscussion on white space normalization inSchema Component Detailsin[XML Schema Part 1: Structures].

·whiteSpace· provides for:

Constraining a·value space· according tothe white space normalization rules.

Example

The following example is the datatype definition forthetoken ·built-in· ·derived·datatype.

<simpleType name='token'>    <restriction base='normalizedString'>      <whiteSpace value='collapse'/>    </restriction>  </simpleType>

4.3.6.1 The whiteSpace Schema Component

Schema Component: whiteSpace

{value}: One of{preserve, replace, collapse}.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue forwhiteSpace other than{value}.

4.3.6.2 XML Representation of whiteSpace Schema Components

The XML representation for awhiteSpace schemacomponent is a<whiteSpace> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: whiteSpace Element Information Item

<whiteSpace
  fixed =boolean : false
  id =ID
  value = (collapse |preserve |replace)
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</whiteSpace>

whiteSpace Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.6.3 whiteSpace Validation Rules

NOTE:There are no·Validation Rule·s associated·whiteSpace·.For more information, see thediscussion on white space normalization inSchema Component Detailsin[XML Schema Part 1: Structures].

4.3.6.4 Constraints on whiteSpace Schema Components

Schema Component Constraint: whiteSpace valid restriction

It is an·error· ifwhiteSpaceis among the members of{facets} of{base type definition} and any of the following conditions istrue:

1{value} isreplace orpreserveand the{value} of the parentwhiteSpace iscollapse

2{value} ispreserveand the{value} of the parentwhiteSpace isreplace

4.3.7 maxInclusive

[Definition:] maxInclusive is the·inclusive upper bound·of the·value space· for a datatype with the·ordered· property. The value ofmaxInclusive ·must· be in the·value space· of the·base type·.

·maxInclusive· provides for:

Constraining a·value space· to valueswith a specific·inclusive upper bound·.

Example

The following is the definition of a·user-derived·datatype which limits values to integers less than or equal to100, using·maxInclusive·.

<simpleType name='one-hundred-or-less'>  <restriction base='integer'>    <maxInclusive value='100'/>  </restriction></simpleType>

4.3.7.1 The maxInclusive Schema Component

Schema Component: maxInclusive

{value}: A value from the·value space· of the{base type definition}.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue formaxInclusive other than{value}.

4.3.7.2 XML Representation of maxInclusive Schema Components

The XML representation for amaxInclusive schemacomponent is a<maxInclusive> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: maxInclusive Element Information Item

<maxInclusive
  fixed =boolean : false
  id =ID
  value =anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</maxInclusive>

{value} ·must· bein the·value space· of{base type definition}.

maxInclusive Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false, if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.7.3 maxInclusive Validation Rules

Validation Rule: maxInclusive Valid

A value in an·ordered· ·value space·is facet-valid with respect to·maxInclusive·, determined asfollows:

1 if the·numeric· property in{fundamental facets} istrue, then the value·must· be numerically less than orequal to{value};

2 if the·numeric· property in{fundamental facets} isfalse (i.e.,{base type definition} is one of the date and time relateddatatypes), then the value·must· be chronologicallyless than or equal to{value};

4.3.7.4 Constraints on maxInclusive Schema Components

Schema Component Constraint: minInclusive <= maxInclusive

It is an·error· for the value specified for·minInclusive· to be greater than the valuespecified for·maxInclusive· for the same datatype.

Schema Component Constraint: maxInclusive valid restriction

It is an·error· if any of the following conditionsis true:

1maxInclusive is among the members of{facets} of{base type definition}and{value} isgreater than the{value} of the parentmaxInclusive

2maxExclusive is among the members of{facets} of{base type definition}and{value} isgreater than or equal to the{value} of the parentmaxExclusive

3minInclusive is among the members of{facets} of{base type definition}and{value} isless than the{value} of the parentminInclusive

4minExclusive is among the members of{facets} of{base type definition}and{value} isless than or equal to the{value} of the parentminExclusive

4.3.8 maxExclusive

[Definition:] maxExclusive is the·exclusive upper bound·of the·value space· for a datatype with the·ordered· property. The value ofmaxExclusive ·must· be in the·value space· of the·base type·.

·maxExclusive· provides for:

Constraining a·value space· to valueswith a specific·exclusive upper bound·.

Example

The following is the definition of a·user-derived·datatype which limits values to integers less than or equal to100, using·maxExclusive·.

<simpleType name='less-than-one-hundred-and-one'>  <restriction base='integer'>    <maxExclusive value='101'/>  </restriction></simpleType>

Note that the·value space· of this datatype is identical tothe previous one (named 'one-hundred-or-less').

4.3.8.1 The maxExclusive Schema Component

Schema Component: maxExclusive

{value}: A value from the·value space· of the{base type definition}.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue formaxExclusive other than{value}.

4.3.8.2 XML Representation of maxExclusive Schema Components

The XML representation for amaxExclusive schemacomponent is a<maxExclusive> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: maxExclusive Element Information Item

<maxExclusive
  fixed =boolean : false
  id =ID
  value =anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</maxExclusive>

{value} ·must· bein the·value space· of{base type definition}.

maxExclusive Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.8.3 maxExclusive Validation Rules

Validation Rule: maxExclusive Valid

A value in an·ordered· ·value space·is facet-valid with respect to·maxExclusive·, determinedas follows:

1 if the·numeric· property in{fundamental facets} istrue, then thevalue·must· be numerically less than{value};

2 if the·numeric· property in{fundamental facets} isfalse (i.e.,{base type definition} is one of the date and time relateddatatypes), then the value·must· be chronologicallyless than{value};

4.3.8.4 Constraints on maxExclusive Schema Components

Schema Component Constraint: maxInclusive and maxExclusive

It is an·error· for both·maxInclusive· and·maxExclusive·to be specified in the same derivation step of a datatype definition.

Schema Component Constraint: minExclusive <= maxExclusive

It is an·error· for the value specified for·minExclusive· to be greater than the valuespecified for·maxExclusive· for the same datatype.

Schema Component Constraint: maxExclusive valid restriction

It is an·error· if any of the following conditionsis true:

1maxExclusive is among the members of{facets} of{base type definition}and{value} isgreater than the{value} of the parentmaxExclusive

2maxInclusive is among the members of{facets} of{base type definition}and{value} isgreater than the{value} of the parentmaxInclusive

3minInclusive is among the members of{facets} of{base type definition}and{value} isless than or equal to the{value} of the parentminInclusive

4minExclusive is among the members of{facets} of{base type definition}and{value} isless than or equal to the{value} of the parentminExclusive

4.3.9 minExclusive

[Definition:] minExclusive is the·exclusive lower bound·of the·value space· for a datatype with the·ordered· property.The value ofminExclusive ·must·be in the·value space· of the·base type·.

·minExclusive· provides for:

Constraining a·value space· to valueswith a specific·exclusive lower bound·.

Example

The following is the definition of a·user-derived·datatype which limits values to integers greater than or equal to100, using·minExclusive·.

<simpleType name='more-than-ninety-nine'>  <restriction base='integer'>    <minExclusive value='99'/>  </restriction></simpleType>

Note that the·value space· of this datatype is identical tothe previous one (named 'one-hundred-or-more').

4.3.9.1 The minExclusive Schema Component

Schema Component: minExclusive

{value}: A value from the·value space· of the{base type definition}.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue forminExclusive other than{value}.

4.3.9.2 XML Representation of minExclusive Schema Components

The XML representation for aminExclusive schemacomponent is a<minExclusive> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: minExclusive Element Information Item

<minExclusive
  fixed =boolean : false
  id =ID
  value =anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</minExclusive>

{value} ·must· bein the·value space· of{base type definition}.

minExclusive Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.9.3 minExclusive Validation Rules

Validation Rule: minExclusive Valid

A value in an·ordered· ·value space·is facet-valid with respect to·minExclusive· if:

1 if the·numeric· property in{fundamental facets} istrue, then thevalue·must· be numerically greater than{value};

2 if the·numeric· property in{fundamental facets} isfalse (i.e.,{base type definition} is one of the date and time relateddatatypes), then the value·must· be chronologicallygreater than{value};

4.3.9.4 Constraints on minExclusive Schema Components

Schema Component Constraint: minInclusive and minExclusive

It is an·error· for both·minInclusive· and·minExclusive·to be specified for the same datatype.

Schema Component Constraint: minExclusive < maxInclusive

It is an·error· for the value specified for·minExclusive· to be greater than or equal to the valuespecified for·maxInclusive· for the same datatype.

Schema Component Constraint: minExclusive valid restriction

It is an·error· if any of the following conditionsis true:

1minExclusive is among the members of{facets} of{base type definition}and{value} isless than the{value} of the parentminExclusive

2maxInclusive is among the members of{facets} of{base type definition}and{value} isgreater the{value} of the parentmaxInclusive

3minInclusive is among the members of{facets} of{base type definition}and{value} isless than the{value} of the parentminInclusive

4maxExclusive is among the members of{facets} of{base type definition}and{value} isgreater than or equal to the{value} of the parentmaxExclusive

4.3.10 minInclusive

[Definition:] minInclusive is the·inclusive lower bound·of the·value space· for a datatype with the·ordered· property. The value ofminInclusive ·must· be in the·value space· of the·base type·.

·minInclusive· provides for:

Constraining a·value space· to valueswith a specific·inclusive lower bound·.

Example

The following is the definition of a·user-derived·datatype which limits values to integers greater than or equal to100, using·minInclusive·.

<simpleType name='one-hundred-or-more'>  <restriction base='integer'>    <minInclusive value='100'/>  </restriction></simpleType>

4.3.10.1 The minInclusive Schema Component

Schema Component: minInclusive

{value}: A value from the·value space· of the{base type definition}.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue forminInclusive other than{value}.

4.3.10.2 XML Representation of minInclusive Schema Components

The XML representation for aminInclusive schemacomponent is a<minInclusive> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: minInclusive Element Information Item

<minInclusive
  fixed =boolean : false
  id =ID
  value =anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</minInclusive>

{value} ·must· bein the·value space· of{base type definition}.

minInclusive Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.10.3 minInclusive Validation Rules

Validation Rule: minInclusive Valid

A value in an·ordered· ·value space·is facet-valid with respect to·minInclusive· if:

1 if the·numeric· property in{fundamental facets} istrue, then thevalue·must· be numerically greater than or equal to{value};

4.3.10.4 Constraints on minInclusive Schema Components

Schema Component Constraint: minInclusive < maxExclusive

It is an·error· for the value specified for·minInclusive· to be greater than or equal to the valuespecified for·maxExclusive· for the same datatype.

Schema Component Constraint: minInclusive valid restriction

It is an·error· if any of the following conditionsis true:

1minInclusive is among the members of{facets} of{base type definition}and{value} isless than the{value} of the parentminInclusive

2maxInclusive is among the members of{facets} of{base type definition}and{value} isgreater the{value} of the parentmaxInclusive

3minExclusive is among the members of{facets} of{base type definition}and{value} isless than or equal to the{value} of the parentminExclusive

4maxExclusive is among the members of{facets} of{base type definition}and{value} isgreater than or equal to the{value} of the parentmaxExclusive

4.3.11 totalDigits

[Definition:] totalDigitsis the maximum number of digits in values of datatypes·derived· fromdecimal. The value oftotalDigits ·must· be apositiveInteger.

·totalDigits· provides for:

Constraining a·value space· to valueswith a specific maximum number of decimal digits (#x30-#x39).

Example

The following is the definition of a·user-derived·datatype which could be used to represent monetary amounts, such asin a financial management application which does not have figuresof $1M or more and only allows whole cents. This definition would appearin a schema authored by an "end-user" and shows how to define a datatype byspecifying facet values which constrain the range of the·base type· in a manner specific to the·base type· (different than specifying max/min valuesas before).

<simpleType name='amount'>  <restriction base='decimal'>    <totalDigits value='8'/>    <fractionDigits value='2' fixed='true'/>  </restriction></simpleType>

4.3.11.1 The totalDigits Schema Component

Schema Component: totalDigits

{value}: ApositiveInteger.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue fortotalDigits other than{value}.

4.3.11.2 XML Representation of totalDigits Schema Components

The XML representation for atotalDigits schemacomponent is a<totalDigits> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: totalDigits Element Information Item

<totalDigits
  fixed =boolean : false
  id =ID
  value =positiveInteger
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</totalDigits>

totalDigits Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.11.3 totalDigits Validation Rules

Validation Rule: totalDigits Valid

A value in a·value space· is facet-valid withrespect to·totalDigits· if:

1 the number of decimal digits in the value is less than or equal to{value};

4.3.11.4 Constraints on totalDigits Schema Components

Schema Component Constraint: totalDigits valid restriction

It is an·error· iftotalDigits is among the members of{facets} of{base type definition}and{value} isgreater than the{value} of the parenttotalDigits

4.3.12 fractionDigits

[Definition:] fractionDigitsis the maximum number of digits in the fractional partof values of datatypes·derived· fromdecimal. The value offractionDigits ·must· be anonNegativeInteger .

·fractionDigits· provides for:

Constraining a·value space· to valueswith a specific maximum number of decimal digits in the fractionalpart.

Example

The following is the definition of a·user-derived·datatype which could be used to represent the magnitudeof a person's body temperature on the Celsius scale.This definition would appear in a schema authored by an "end-user"and shows how to define a datatype by specifying facet values whichconstrain the range of the·base type·.

<simpleType name='celsiusBodyTemp'>  <restriction base='decimal'>    <totalDigits value='4'/>    <fractionDigits value='1'/>    <minInclusive value='36.4'/>    <maxInclusive value='40.5'/>  </restriction></simpleType>

4.3.12.1 The fractionDigits Schema Component

Schema Component: fractionDigits

{value}: AnonNegativeInteger.
{fixed}: Aboolean.
{annotation}: Optional. Anannotation.

If{fixed} istrue, then types for whichthe current type is the{base type definition} cannot specify avalue forfractionDigits other than{value}.

4.3.12.2 XML Representation of fractionDigits Schema Components

The XML representation for afractionDigits schemacomponent is a<fractionDigits> element information item. Thecorrespondences between the properties of the information item andproperties of the component are as follows:

XML Representation Summary: fractionDigits Element Information Item

<fractionDigits
  fixed =boolean : false
  id =ID
  value =nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content:(annotation?)
</fractionDigits>

fractionDigits Schema Component

Property	Representation
{value}	Theactual value of the`value` [attribute]
{fixed}	Theactual value of the`fixed` [attribute], if present, otherwise false
{annotation}	The annotations corresponding to all the<annotation>element information items in the [children], if any.

4.3.12.3 fractionDigits Validation Rules

Validation Rule: fractionDigits Valid

A value in a·value space· is facet-valid withrespect to·fractionDigits· if:

1 the number of decimal digits in the fractional part of thevalue is less than or equal to{value};

4.3.12.4 Constraints on fractionDigits Schema Components

Schema Component Constraint: fractionDigits less than or equal to totalDigits

It is an·error· for·fractionDigits· tobe greater than·totalDigits·.

A Schema for Datatype Definitions (normative)

<?xml version='1.0'?><!-- XML Schema schema for XML Schemas: Part 2: Datatypes --><!DOCTYPE xs:schema PUBLIC "-//W3C//DTD XMLSCHEMA 200102//EN"          "XMLSchema.dtd" [<!--     keep this schema XML1.0 DTD valid  -->        <!ENTITY % schemaAttrs 'xmlns:hfp CDATA #IMPLIED'>        <!ELEMENT hfp:hasFacet EMPTY>        <!ATTLIST hfp:hasFacet                name NMTOKEN #REQUIRED>                        <!ELEMENT hfp:hasProperty EMPTY>        <!ATTLIST hfp:hasProperty                name NMTOKEN #REQUIRED                value CDATA #REQUIRED><!--        Make sure that processors that do not read the external        subset will know about the various IDs we declare  -->        <!ATTLIST xs:simpleType id ID #IMPLIED>        <!ATTLIST xs:maxExclusive id ID #IMPLIED>        <!ATTLIST xs:minExclusive id ID #IMPLIED>        <!ATTLIST xs:maxInclusive id ID #IMPLIED>        <!ATTLIST xs:minInclusive id ID #IMPLIED>        <!ATTLIST xs:totalDigits id ID #IMPLIED>        <!ATTLIST xs:fractionDigits id ID #IMPLIED>        <!ATTLIST xs:length id ID #IMPLIED>        <!ATTLIST xs:minLength id ID #IMPLIED>        <!ATTLIST xs:maxLength id ID #IMPLIED>        <!ATTLIST xs:enumeration id ID #IMPLIED>        <!ATTLIST xs:pattern id ID #IMPLIED>        <!ATTLIST xs:appinfo id ID #IMPLIED>        <!ATTLIST xs:documentation id ID #IMPLIED>        <!ATTLIST xs:list id ID #IMPLIED>        <!ATTLIST xs:union id ID #IMPLIED>        ]><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"        targetNamespace="http://www.w3.org/2001/XMLSchema"        version="Id: datatypes.xsd,v 1.52 2001/04/27 11:49:21 ht Exp "        xmlns:hfp="http://www.w3.org/2001/XMLSchema-hasFacetAndProperty"        elementFormDefault="qualified"        blockDefault="#all"        xml:lang="en">  <xs:annotation>   <xs:documentation source="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/datatypes">      The schema corresponding to this document is normative,      with respect to the syntactic constraints it expresses in the      XML Schema language.  The documentation (within &lt;documentation>      elements) below, is not normative, but rather highlights important      aspects of the W3C Recommendation of which this is a part    </xs:documentation>  </xs:annotation>  <xs:annotation>    <xs:documentation>      First the built-in primitive datatypes.  These definitions are for      information only, the real built-in definitions are magic.  Note in      particular that there is no type named 'anySimpleType'.  The      primitives should really be derived from no type at all, and      anySimpleType should be derived as a union of all the primitives.    </xs:documentation>    <xs:documentation>      For each built-in datatype in this schema (both primitive and      derived) can be uniquely addressed via a URI constructed      as follows:        1) the base URI is the URI of the XML Schema namespace        2) the fragment identifier is the name of the datatype              For example, to address the int datatype, the URI is:              http://www.w3.org/2001/XMLSchema#int            Additionally, each facet definition element can be uniquely      addressed via a URI constructed as follows:        1) the base URI is the URI of the XML Schema namespace        2) the fragment identifier is the name of the facet              For example, to address the maxInclusive facet, the URI is:              http://www.w3.org/2001/XMLSchema#maxInclusive      Additionally, each facet usage in a built-in datatype definition      can be uniquely addressed via a URI constructed as follows:        1) the base URI is the URI of the XML Schema namespace        2) the fragment identifier is the name of the datatype, followed           by a period (".") followed by the name of the facet              For example, to address the usage of the maxInclusive facet in      the definition of int, the URI is:              http://www.w3.org/2001/XMLSchema#int.maxInclusive            </xs:documentation>  </xs:annotation>   <xs:simpleType name="string">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="length"/>        <hfp:hasFacet name="minLength"/>        <hfp:hasFacet name="maxLength"/>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality" value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation                source="http://www.w3.org/TR/xmlschema-2/#string"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="preserve"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="boolean">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality" value="finite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#boolean"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse" fixed="true"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="float">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="total"/>        <hfp:hasProperty name="bounded" value="true"/>        <hfp:hasProperty name="cardinality" value="finite"/>        <hfp:hasProperty name="numeric" value="true"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#float"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse" fixed="true"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="double">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="total"/>        <hfp:hasProperty name="bounded" value="true"/>        <hfp:hasProperty name="cardinality" value="finite"/>        <hfp:hasProperty name="numeric" value="true"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#double"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="decimal">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="totalDigits"/>        <hfp:hasFacet name="fractionDigits"/>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="total"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="true"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#decimal"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>   </xs:simpleType>   <xs:simpleType name="duration">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="partial"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#duration"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>   </xs:simpleType> <xs:simpleType name="dateTime">    <xs:annotation>    <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="partial"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#dateTime"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="time">    <xs:annotation>    <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="partial"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#time"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="date">   <xs:annotation>    <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="partial"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#date"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="gYearMonth">   <xs:annotation>    <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="partial"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#gYearMonth"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="gYear">    <xs:annotation>    <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="partial"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#gYear"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>  </xs:simpleType> <xs:simpleType name="gMonthDay">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="partial"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>       <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#gMonthDay"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">         <xs:whiteSpace value="collapse" fixed="true"               />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="gDay">    <xs:annotation>  <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="partial"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#gDay"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">         <xs:whiteSpace value="collapse"  fixed="true"               />    </xs:restriction>  </xs:simpleType> <xs:simpleType name="gMonth">    <xs:annotation>  <xs:appinfo>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasFacet name="maxInclusive"/>        <hfp:hasFacet name="maxExclusive"/>        <hfp:hasFacet name="minInclusive"/>        <hfp:hasFacet name="minExclusive"/>        <hfp:hasProperty name="ordered" value="partial"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#gMonth"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">         <xs:whiteSpace value="collapse"  fixed="true"               />    </xs:restriction>  </xs:simpleType>   <xs:simpleType name="hexBinary">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="length"/>        <hfp:hasFacet name="minLength"/>        <hfp:hasFacet name="maxLength"/>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#binary"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse" fixed="true"       />    </xs:restriction>   </xs:simpleType>  <xs:simpleType name="base64Binary">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="length"/>        <hfp:hasFacet name="minLength"/>        <hfp:hasFacet name="maxLength"/>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation                source="http://www.w3.org/TR/xmlschema-2/#base64Binary"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse" fixed="true"       />    </xs:restriction>   </xs:simpleType>   <xs:simpleType name="anyURI">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="length"/>        <hfp:hasFacet name="minLength"/>        <hfp:hasFacet name="maxLength"/>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#anyURI"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>   </xs:simpleType>  <xs:simpleType name="QName">    <xs:annotation>        <xs:appinfo>        <hfp:hasFacet name="length"/>        <hfp:hasFacet name="minLength"/>        <hfp:hasFacet name="maxLength"/>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#QName"/>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>  </xs:simpleType>   <xs:simpleType name="NOTATION">    <xs:annotation>        <xs:appinfo>        <hfp:hasFacet name="length"/>        <hfp:hasFacet name="minLength"/>        <hfp:hasFacet name="maxLength"/>        <hfp:hasFacet name="pattern"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#NOTATION"/>      <xs:documentation>        NOTATION cannot be used directly in a schema; rather a type        must be derived from it by specifying at least one enumeration        facet whose value is the name of a NOTATION declared in the        schema.      </xs:documentation>    </xs:annotation>    <xs:restriction base="xs:anySimpleType">      <xs:whiteSpace value="collapse"  fixed="true"       />    </xs:restriction>  </xs:simpleType>  <xs:annotation>    <xs:documentation>      Now the derived primitive types    </xs:documentation>  </xs:annotation>  <xs:simpleType name="normalizedString">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#normalizedString"/>    </xs:annotation>    <xs:restriction base="xs:string">      <xs:whiteSpace value="replace"       />    </xs:restriction>  </xs:simpleType>    <xs:simpleType name="token">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#token"/>    </xs:annotation>    <xs:restriction base="xs:normalizedString">      <xs:whiteSpace value="collapse"/>    </xs:restriction>  </xs:simpleType>    <xs:simpleType name="language">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#language"/>    </xs:annotation>    <xs:restriction base="xs:token">      <xs:pattern        value="([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{1,8})*"               >        <xs:annotation>          <xs:documentation                source="http://www.w3.org/TR/REC-xml#NT-LanguageID">            pattern specifies the content of section 2.12 of XML 1.0e2            and RFC 1766          </xs:documentation>        </xs:annotation>      </xs:pattern>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="IDREFS">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="length"/>        <hfp:hasFacet name="minLength"/>        <hfp:hasFacet name="maxLength"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#IDREFS"/>    </xs:annotation>    <xs:restriction>      <xs:simpleType>        <xs:list itemType="xs:IDREF"/>          </xs:simpleType>        <xs:minLength value="1"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="ENTITIES">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="length"/>        <hfp:hasFacet name="minLength"/>        <hfp:hasFacet name="maxLength"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#ENTITIES"/>    </xs:annotation>    <xs:restriction>      <xs:simpleType>        <xs:list itemType="xs:ENTITY"/>      </xs:simpleType>        <xs:minLength value="1"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="NMTOKEN">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#NMTOKEN"/>    </xs:annotation>    <xs:restriction base="xs:token">      <xs:pattern value="\c+">        <xs:annotation>          <xs:documentation                source="http://www.w3.org/TR/REC-xml#NT-Nmtoken">            pattern matches production 7 from the XML spec          </xs:documentation>        </xs:annotation>      </xs:pattern>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="NMTOKENS">    <xs:annotation>      <xs:appinfo>        <hfp:hasFacet name="length"/>        <hfp:hasFacet name="minLength"/>        <hfp:hasFacet name="maxLength"/>        <hfp:hasFacet name="enumeration"/>        <hfp:hasFacet name="whiteSpace"/>        <hfp:hasProperty name="ordered" value="false"/>        <hfp:hasProperty name="bounded" value="false"/>        <hfp:hasProperty name="cardinality"                value="countably infinite"/>        <hfp:hasProperty name="numeric" value="false"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#NMTOKENS"/>    </xs:annotation>    <xs:restriction>      <xs:simpleType>        <xs:list itemType="xs:NMTOKEN"/>      </xs:simpleType>        <xs:minLength value="1"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="Name">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#Name"/>    </xs:annotation>    <xs:restriction base="xs:token">      <xs:pattern value="\i\c*">        <xs:annotation>          <xs:documentation                        source="http://www.w3.org/TR/REC-xml#NT-Name">            pattern matches production 5 from the XML spec          </xs:documentation>        </xs:annotation>      </xs:pattern>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="NCName">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#NCName"/>    </xs:annotation>    <xs:restriction base="xs:Name">      <xs:pattern value="[\i-[:]][\c-[:]]*">        <xs:annotation>          <xs:documentation                source="http://www.w3.org/TR/REC-xml-names/#NT-NCName">            pattern matches production 4 from the Namespaces in XML spec          </xs:documentation>        </xs:annotation>      </xs:pattern>    </xs:restriction>  </xs:simpleType>   <xs:simpleType name="ID">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#ID"/>    </xs:annotation>    <xs:restriction base="xs:NCName"/>   </xs:simpleType>   <xs:simpleType name="IDREF">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#IDREF"/>    </xs:annotation>    <xs:restriction base="xs:NCName"/>   </xs:simpleType>   <xs:simpleType name="ENTITY">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#ENTITY"/>    </xs:annotation>    <xs:restriction base="xs:NCName"/>   </xs:simpleType>  <xs:simpleType name="integer">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#integer"/>    </xs:annotation>    <xs:restriction base="xs:decimal">      <xs:fractionDigits value="0" fixed="true"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="nonPositiveInteger">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#nonPositiveInteger"/>    </xs:annotation>    <xs:restriction base="xs:integer">      <xs:maxInclusive value="0"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="negativeInteger">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#negativeInteger"/>    </xs:annotation>    <xs:restriction base="xs:nonPositiveInteger">      <xs:maxInclusive value="-1"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="long">    <xs:annotation>      <xs:appinfo>        <hfp:hasProperty name="bounded" value="true"/>        <hfp:hasProperty name="cardinality" value="finite"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#long"/>    </xs:annotation>    <xs:restriction base="xs:integer">      <xs:minInclusive value="-9223372036854775808"/>      <xs:maxInclusive value="9223372036854775807"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="int">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#int"/>    </xs:annotation>    <xs:restriction base="xs:long">      <xs:minInclusive value="-2147483648"/>      <xs:maxInclusive value="2147483647"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="short">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#short"/>    </xs:annotation>    <xs:restriction base="xs:int">      <xs:minInclusive value="-32768"/>      <xs:maxInclusive value="32767"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="byte">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#byte"/>    </xs:annotation>    <xs:restriction base="xs:short">      <xs:minInclusive value="-128"/>      <xs:maxInclusive value="127"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="nonNegativeInteger">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#nonNegativeInteger"/>    </xs:annotation>    <xs:restriction base="xs:integer">      <xs:minInclusive value="0"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="unsignedLong">    <xs:annotation>      <xs:appinfo>        <hfp:hasProperty name="bounded" value="true"/>        <hfp:hasProperty name="cardinality" value="finite"/>      </xs:appinfo>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#unsignedLong"/>    </xs:annotation>    <xs:restriction base="xs:nonNegativeInteger">      <xs:maxInclusive value="18446744073709551615"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="unsignedInt">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#unsignedInt"/>    </xs:annotation>    <xs:restriction base="xs:unsignedLong">      <xs:maxInclusive value="4294967295"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="unsignedShort">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#unsignedShort"/>    </xs:annotation>    <xs:restriction base="xs:unsignedInt">      <xs:maxInclusive value="65535"       />    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="unsignedByte">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#unsignedByte"/>    </xs:annotation>    <xs:restriction base="xs:unsignedShort">      <xs:maxInclusive value="255"/>    </xs:restriction>  </xs:simpleType>  <xs:simpleType name="positiveInteger">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#positiveInteger"/>    </xs:annotation>    <xs:restriction base="xs:nonNegativeInteger">      <xs:minInclusive value="1"/>    </xs:restriction>  </xs:simpleType> <xs:simpleType name="derivationControl">  <xs:annotation>   <xs:documentation>   A utility type, not for public use</xs:documentation>  </xs:annotation>  <xs:restriction base="xs:NMTOKEN">   <xs:enumeration value="substitution"/>   <xs:enumeration value="extension"/>   <xs:enumeration value="restriction"/>   <xs:enumeration value="list"/>   <xs:enumeration value="union"/>  </xs:restriction> </xs:simpleType> <xs:group name="simpleDerivation">  <xs:choice>    <xs:element ref="xs:restriction"/>    <xs:element ref="xs:list"/>    <xs:element ref="xs:union"/>  </xs:choice> </xs:group> <xs:simpleType name="simpleDerivationSet">  <xs:annotation>   <xs:documentation>   #all or (possibly empty) subset of {restriction, union, list}   </xs:documentation>   <xs:documentation>   A utility type, not for public use</xs:documentation>  </xs:annotation>  <xs:union>   <xs:simpleType>        <xs:restriction base="xs:token">     <xs:enumeration value="#all"/>    </xs:restriction>   </xs:simpleType>   <xs:simpleType>    <xs:restriction base="xs:derivationControl">     <xs:enumeration value="list"/>     <xs:enumeration value="union"/>     <xs:enumeration value="restriction"/>    </xs:restriction>   </xs:simpleType>  </xs:union> </xs:simpleType>  <xs:complexType name="simpleType" abstract="true">    <xs:complexContent>      <xs:extension base="xs:annotated">        <xs:group ref="xs:simpleDerivation"/>        <xs:attribute name="final" type="xs:simpleDerivationSet"/>        <xs:attribute name="name" type="xs:NCName">          <xs:annotation>            <xs:documentation>              Can be restricted to required or forbidden            </xs:documentation>          </xs:annotation>        </xs:attribute>      </xs:extension>    </xs:complexContent>  </xs:complexType>  <xs:complexType name="topLevelSimpleType">    <xs:complexContent>      <xs:restriction base="xs:simpleType">        <xs:sequence>          <xs:element ref="xs:annotation" minOccurs="0"/>          <xs:group ref="xs:simpleDerivation"/>        </xs:sequence>        <xs:attribute name="name" use="required"             type="xs:NCName">          <xs:annotation>            <xs:documentation>              Required at the top level            </xs:documentation>          </xs:annotation>        </xs:attribute>         </xs:restriction>    </xs:complexContent>  </xs:complexType>  <xs:complexType name="localSimpleType">    <xs:complexContent>      <xs:restriction base="xs:simpleType">        <xs:sequence>          <xs:element ref="xs:annotation" minOccurs="0"/>          <xs:group ref="xs:simpleDerivation"/>        </xs:sequence>        <xs:attribute name="name" use="prohibited">          <xs:annotation>            <xs:documentation>              Forbidden when nested            </xs:documentation>          </xs:annotation>        </xs:attribute>           <xs:attribute name="final" use="prohibited"/>      </xs:restriction>    </xs:complexContent>  </xs:complexType>  <xs:element name="simpleType" type="xs:topLevelSimpleType">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-simpleType"/>    </xs:annotation>  </xs:element>  <xs:group name="facets">   <xs:annotation>    <xs:documentation>       We should use a substitution group for facets, but       that's ruled out because it would allow users to       add their own, which we're not ready for yet.    </xs:documentation>   </xs:annotation>   <xs:choice>    <xs:element ref="xs:minExclusive"/>    <xs:element ref="xs:minInclusive"/>    <xs:element ref="xs:maxExclusive"/>    <xs:element ref="xs:maxInclusive"/>    <xs:element ref="xs:totalDigits"/>    <xs:element ref="xs:fractionDigits"/>    <xs:element ref="xs:length"/>    <xs:element ref="xs:minLength"/>    <xs:element ref="xs:maxLength"/>    <xs:element ref="xs:enumeration"/>    <xs:element ref="xs:whiteSpace"/>    <xs:element ref="xs:pattern"/>   </xs:choice>  </xs:group>  <xs:group name="simpleRestrictionModel">   <xs:sequence>    <xs:element name="simpleType" type="xs:localSimpleType" minOccurs="0"/>    <xs:group ref="xs:facets" minOccurs="0" maxOccurs="unbounded"/>   </xs:sequence>  </xs:group>  <xs:element name="restriction">   <xs:complexType>    <xs:annotation>      <xs:documentation                source="http://www.w3.org/TR/xmlschema-2/#element-restriction">          base attribute and simpleType child are mutually          exclusive, but one or other is required        </xs:documentation>      </xs:annotation>      <xs:complexContent>        <xs:extension base="xs:annotated">         <xs:group ref="xs:simpleRestrictionModel"/>         <xs:attribute name="base" type="xs:QName" use="optional"/>        </xs:extension>      </xs:complexContent>    </xs:complexType>  </xs:element>  <xs:element name="list">   <xs:complexType>    <xs:annotation>      <xs:documentation                source="http://www.w3.org/TR/xmlschema-2/#element-list">          itemType attribute and simpleType child are mutually          exclusive, but one or other is required        </xs:documentation>      </xs:annotation>      <xs:complexContent>        <xs:extension base="xs:annotated">          <xs:sequence>            <xs:element name="simpleType" type="xs:localSimpleType"                minOccurs="0"/>          </xs:sequence>          <xs:attribute name="itemType" type="xs:QName" use="optional"/>        </xs:extension>      </xs:complexContent>    </xs:complexType>  </xs:element>  <xs:element name="union">   <xs:complexType>    <xs:annotation>      <xs:documentation                source="http://www.w3.org/TR/xmlschema-2/#element-union">          memberTypes attribute must be non-empty or there must be          at least one simpleType child        </xs:documentation>      </xs:annotation>      <xs:complexContent>        <xs:extension base="xs:annotated">          <xs:sequence>            <xs:element name="simpleType" type="xs:localSimpleType"                minOccurs="0" maxOccurs="unbounded"/>          </xs:sequence>          <xs:attribute name="memberTypes" use="optional">            <xs:simpleType>              <xs:list itemType="xs:QName"/>            </xs:simpleType>          </xs:attribute>        </xs:extension>      </xs:complexContent>    </xs:complexType>  </xs:element>    <xs:complexType name="facet">    <xs:complexContent>      <xs:extension base="xs:annotated">        <xs:attribute name="value" use="required"/>        <xs:attribute name="fixed" type="xs:boolean" use="optional"                      default="false"/>      </xs:extension>    </xs:complexContent>  </xs:complexType>  <xs:complexType name="noFixedFacet">  <xs:complexContent>   <xs:restriction base="xs:facet">    <xs:sequence>     <xs:element ref="xs:annotation" minOccurs="0"/>    </xs:sequence>    <xs:attribute name="fixed" use="prohibited"/>   </xs:restriction>  </xs:complexContent> </xs:complexType>  <xs:element name="minExclusive" type="xs:facet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-minExclusive"/>    </xs:annotation>  </xs:element>  <xs:element name="minInclusive" type="xs:facet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-minInclusive"/>    </xs:annotation>  </xs:element>  <xs:element name="maxExclusive" type="xs:facet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-maxExclusive"/>    </xs:annotation>  </xs:element>  <xs:element name="maxInclusive" type="xs:facet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-maxInclusive"/>    </xs:annotation>  </xs:element>  <xs:complexType name="numFacet">    <xs:complexContent>      <xs:restriction base="xs:facet">       <xs:sequence>         <xs:element ref="xs:annotation" minOccurs="0"/>       </xs:sequence>       <xs:attribute name="value" type="xs:nonNegativeInteger" use="required"/>      </xs:restriction>    </xs:complexContent>  </xs:complexType>  <xs:element name="totalDigits">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-totalDigits"/>    </xs:annotation>    <xs:complexType>      <xs:complexContent>        <xs:restriction base="xs:numFacet">          <xs:sequence>            <xs:element ref="xs:annotation" minOccurs="0"/>          </xs:sequence>          <xs:attribute name="value" type="xs:positiveInteger" use="required"/>        </xs:restriction>      </xs:complexContent>    </xs:complexType>  </xs:element>  <xs:element name="fractionDigits" type="xs:numFacet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-fractionDigits"/>    </xs:annotation>  </xs:element>  <xs:element name="length" type="xs:numFacet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-length"/>    </xs:annotation>  </xs:element>  <xs:element name="minLength" type="xs:numFacet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-minLength"/>    </xs:annotation>  </xs:element>  <xs:element name="maxLength" type="xs:numFacet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-maxLength"/>    </xs:annotation>  </xs:element>    <xs:element name="enumeration" type="xs:noFixedFacet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-enumeration"/>    </xs:annotation>  </xs:element>  <xs:element name="whiteSpace">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-whiteSpace"/>    </xs:annotation>    <xs:complexType>      <xs:complexContent>        <xs:restriction base="xs:facet">          <xs:sequence>            <xs:element ref="xs:annotation" minOccurs="0"/>          </xs:sequence>          <xs:attribute name="value" use="required">            <xs:simpleType>              <xs:restriction base="xs:NMTOKEN">                <xs:enumeration value="preserve"/>                <xs:enumeration value="replace"/>                <xs:enumeration value="collapse"/>              </xs:restriction>            </xs:simpleType>          </xs:attribute>        </xs:restriction>      </xs:complexContent>    </xs:complexType>  </xs:element>  <xs:element name="pattern" type="xs:noFixedFacet">    <xs:annotation>      <xs:documentation        source="http://www.w3.org/TR/xmlschema-2/#element-pattern"/>    </xs:annotation>  </xs:element></xs:schema>

B DTD for Datatype Definitions (non-normative)

<!--        DTD for XML Schemas: Part 2: Datatypes        Id: datatypes.dtd,v 1.23 2001/03/16 17:36:30 ht Exp         Note this DTD is NOT normative, or even definitive.  --><!--        This DTD cannot be used on its own, it is intended        only for incorporation in XMLSchema.dtd, q.v.  --><!-- Define all the element names, with optional prefix --><!ENTITY % simpleType "%p;simpleType"><!ENTITY % restriction "%p;restriction"><!ENTITY % list "%p;list"><!ENTITY % union "%p;union"><!ENTITY % maxExclusive "%p;maxExclusive"><!ENTITY % minExclusive "%p;minExclusive"><!ENTITY % maxInclusive "%p;maxInclusive"><!ENTITY % minInclusive "%p;minInclusive"><!ENTITY % totalDigits "%p;totalDigits"><!ENTITY % fractionDigits "%p;fractionDigits"><!ENTITY % length "%p;length"><!ENTITY % minLength "%p;minLength"><!ENTITY % maxLength "%p;maxLength"><!ENTITY % enumeration "%p;enumeration"><!ENTITY % whiteSpace "%p;whiteSpace"><!ENTITY % pattern "%p;pattern"><!--        Customisation entities for the ATTLIST of each element        type. Define one of these if your schema takes advantage        of the anyAttribute='##other' in the schema for schemas  --><!ENTITY % simpleTypeAttrs ""><!ENTITY % restrictionAttrs ""><!ENTITY % listAttrs ""><!ENTITY % unionAttrs ""><!ENTITY % maxExclusiveAttrs ""><!ENTITY % minExclusiveAttrs ""><!ENTITY % maxInclusiveAttrs ""><!ENTITY % minInclusiveAttrs ""><!ENTITY % totalDigitsAttrs ""><!ENTITY % fractionDigitsAttrs ""><!ENTITY % lengthAttrs ""><!ENTITY % minLengthAttrs ""><!ENTITY % maxLengthAttrs ""><!ENTITY % enumerationAttrs ""><!ENTITY % whiteSpaceAttrs ""><!ENTITY % patternAttrs ""><!-- Define some entities for informative use as attribute        types --><!ENTITY % URIref "CDATA"><!ENTITY % XPathExpr "CDATA"><!ENTITY % QName "NMTOKEN"><!ENTITY % QNames "NMTOKENS"><!ENTITY % NCName "NMTOKEN"><!ENTITY % nonNegativeInteger "NMTOKEN"><!ENTITY % boolean "(true|false)"><!ENTITY % simpleDerivationSet "CDATA"><!--        #all or space-separated list drawn from derivationChoice  --><!--        Note that the use of 'facet' below is less restrictive        than is really intended:  There should in fact be no        more than one of each of minInclusive, minExclusive,        maxInclusive, maxExclusive, totalDigits, fractionDigits,        length, maxLength, minLength within datatype,        and the min- and max- variants of Inclusive and Exclusive        are mutually exclusive. On the other hand,  pattern and        enumeration may repeat.  --><!ENTITY % minBound "(%minInclusive; | %minExclusive;)"><!ENTITY % maxBound "(%maxInclusive; | %maxExclusive;)"><!ENTITY % bounds "%minBound; | %maxBound;"><!ENTITY % numeric "%totalDigits; | %fractionDigits;"><!ENTITY % ordered "%bounds; | %numeric;"><!ENTITY % unordered   "%pattern; | %enumeration; | %whiteSpace; | %length; |   %maxLength; | %minLength;"><!ENTITY % facet "%ordered; | %unordered;"><!ENTITY % facetAttr         "value CDATA #REQUIRED        id ID #IMPLIED"><!ENTITY % fixedAttr "fixed %boolean; #IMPLIED"><!ENTITY % facetModel "(%annotation;)?"><!ELEMENT %simpleType;        ((%annotation;)?, (%restriction; | %list; | %union;))><!ATTLIST %simpleType;    name      %NCName; #IMPLIED    final     %simpleDerivationSet; #IMPLIED    id        ID       #IMPLIED    %simpleTypeAttrs;><!-- name is required at top level --><!ELEMENT %restriction; ((%annotation;)?,                         (%restriction1; |                          ((%simpleType;)?,(%facet;)*)),                         (%attrDecls;))><!ATTLIST %restriction;    base      %QName;                  #IMPLIED    id        ID       #IMPLIED    %restrictionAttrs;><!--        base and simpleType child are mutually exclusive,        one is required.        restriction is shared between simpleType and        simpleContent and complexContent (in XMLSchema.xsd).        restriction1 is for the latter cases, when this        is restricting a complex type, as is attrDecls.  --><!ELEMENT %list; ((%annotation;)?,(%simpleType;)?)><!ATTLIST %list;    itemType      %QName;             #IMPLIED    id        ID       #IMPLIED    %listAttrs;><!--        itemType and simpleType child are mutually exclusive,        one is required  --><!ELEMENT %union; ((%annotation;)?,(%simpleType;)*)><!ATTLIST %union;    id            ID       #IMPLIED    memberTypes   %QNames;            #IMPLIED    %unionAttrs;><!--        At least one item in memberTypes or one simpleType        child is required  --><!ELEMENT %maxExclusive; %facetModel;><!ATTLIST %maxExclusive;        %facetAttr;        %fixedAttr;        %maxExclusiveAttrs;><!ELEMENT %minExclusive; %facetModel;><!ATTLIST %minExclusive;        %facetAttr;        %fixedAttr;        %minExclusiveAttrs;><!ELEMENT %maxInclusive; %facetModel;><!ATTLIST %maxInclusive;        %facetAttr;        %fixedAttr;        %maxInclusiveAttrs;><!ELEMENT %minInclusive; %facetModel;><!ATTLIST %minInclusive;        %facetAttr;        %fixedAttr;        %minInclusiveAttrs;><!ELEMENT %totalDigits; %facetModel;><!ATTLIST %totalDigits;        %facetAttr;        %fixedAttr;        %totalDigitsAttrs;><!ELEMENT %fractionDigits; %facetModel;><!ATTLIST %fractionDigits;        %facetAttr;        %fixedAttr;        %fractionDigitsAttrs;><!ELEMENT %length; %facetModel;><!ATTLIST %length;        %facetAttr;        %fixedAttr;        %lengthAttrs;><!ELEMENT %minLength; %facetModel;><!ATTLIST %minLength;        %facetAttr;        %fixedAttr;        %minLengthAttrs;><!ELEMENT %maxLength; %facetModel;><!ATTLIST %maxLength;        %facetAttr;        %fixedAttr;        %maxLengthAttrs;><!-- This one can be repeated --><!ELEMENT %enumeration; %facetModel;><!ATTLIST %enumeration;        %facetAttr;        %enumerationAttrs;><!ELEMENT %whiteSpace; %facetModel;><!ATTLIST %whiteSpace;        %facetAttr;        %fixedAttr;        %whiteSpaceAttrs;><!-- This one can be repeated --><!ELEMENT %pattern; %facetModel;><!ATTLIST %pattern;        %facetAttr;        %patternAttrs;>

C Datatypes and Facets

C.1 Fundamental Facets

The following table shows the values of the fundamental facetsfor each·built-in· datatype.

	Datatype	ordered	bounded	cardinality	numeric
primitive	string	false	false	countably infinite	false
	boolean	false	false	finite	false
	float	total	true	finite	true
	double	total	true	finite	true
	decimal	total	false	countably infinite	true
	duration	partial	false	countably infinite	false
	dateTime	partial	false	countably infinite	false
	time	partial	false	countably infinite	false
	date	partial	false	countably infinite	false
	gYearMonth	partial	false	countably infinite	false
	gYear	partial	false	countably infinite	false
	gMonthDay	partial	false	countably infinite	false
	gDay	partial	false	countably infinite	false
	gMonth	partial	false	countably infinite	false
	hexBinary	false	false	countably infinite	false
	base64Binary	false	false	countably infinite	false
	anyURI	false	false	countably infinite	false
	QName	false	false	countably infinite	false
	NOTATION	false	false	countably infinite	false

derived	normalizedString	false	false	countably infinite	false
	token	false	false	countably infinite	false
	language	false	false	countably infinite	false
	IDREFS	false	false	countably infinite	false
	ENTITIES	false	false	countably infinite	false
	NMTOKEN	false	false	countably infinite	false
	NMTOKENS	false	false	countably infinite	false
	Name	false	false	countably infinite	false
	NCName	false	false	countably infinite	false
	ID	false	false	countably infinite	false
	IDREF	false	false	countably infinite	false
	ENTITY	false	false	countably infinite	false
	integer	total	false	countably infinite	true
	nonPositiveInteger	total	false	countably infinite	true
	negativeInteger	total	false	countably infinite	true
	long	total	true	finite	true
	int	total	true	finite	true
	short	total	true	finite	true
	byte	total	true	finite	true
	nonNegativeInteger	total	false	countably infinite	true
	unsignedLong	total	true	finite	true
	unsignedInt	total	true	finite	true
	unsignedShort	total	true	finite	true
	unsignedByte	total	true	finite	true
	positiveInteger	total	false	countably infinite	true

D ISO 8601 Date and Time Formats

D.1 ISO 8601 Conventions

The·primitive· datatypesduration,dateTime,time,date,gYearMonth,gMonthDay,gDay,gMonth andgYearuse lexical formats inspired by[ISO 8601]. This appendix provides more detail on the ISOformats and discusses some deviations from them for the datatypesdefined in this specification.

[ISO 8601] "specifies the representation of dates in theproleptic Gregorian calendar and times and representations of periods of time".The proleptic Gregorian calendar includes dates prior to 1582 (the year it cameinto use as an ecclesiastical calendar).It should be pointed out that the datatypes described in thisspecification do not cover all the types of data covered by[ISO 8601], nor do they support all the lexicalrepresentations for those types of data.

[ISO 8601] lexical formats are described using "pictures"in which characters are used in place of digits. For the primitive datatypesdateTime,time,date,gYearMonth,gMonthDay,gDay,gMonth andgYear. these characters have the following meanings:

C -- represents a digit used in the thousands and hundreds components,the "century" component, of the time element "year". Legal values arefrom 0 to 9.
Y -- represents a digit used in the tens and units components of the timeelement "year". Legal values are from 0 to 9.
M -- represents a digit used in the time element "month". The twodigits in a MM format can have values from 1 to 12.
D -- represents a digit used in the time element "day". The two digitsin a DD format can have values from 1 to 28 if the month value equals 2,1 to 29 if the month value equals 2 and the year is a leap year, 1 to 30if the month value equals 4, 6, 9 or 11, and 1 to 31 if the month valueequals 1, 3, 5, 7, 8, 10 or 12.
h -- represents a digit used in the time element "hour". The two digitsin a hh format can have values from 0 to 23.
m -- represents a digit used in the time element "minute". The two digitsin a mm format can have values from 0 to 59.
s -- represents a digit used in the time element "second". The twodigits in a ss format can have values from 0 to 60. In the formatsdescribed in this specification the whole number of seconds·may·be followed by decimal seconds to an arbitrary level of precision.This is represented in the picture by "ss.sss". A value of 60 or more is allowed only in the case of leap seconds.
Strictly speaking, a value of60 or more is not sensible unless the month and day couldrepresent March 31, June 30, September 30, or December 31in UTC.Because the leap second is added or subtracted as the last second of the day in UTC time, the long (or short) minute could occur at other times in localtime. In cases where the leap second is used with an inappropriate month and day it, and any fractional seconds, should considered as added orsubtracted from the following minute.

For all the information items indicated by the above characters, leadingzeros are required where indicated.

In addition to the above, certain characters are used as designatorsand appear as themselves in lexical formats.

T -- is used as time designator to indicate the start of therepresentation of the time of day indateTime.
Z -- is used as time-zone designator, immediately (without a space)following a data element expressing the time of day in CoordinatedUniversal Time (UTC) indateTime,time,date,gYearMonth,gMonthDay,gDay,gMonth, andgYear.

In the lexical format forduration the followingcharacters are also used as designators and appear as themselves in lexical formats:

P -- is used as the time duration designator, preceding a data elementrepresenting a given duration of time.
Y -- follows the number of years in a time duration.
M -- follows the number of months or minutes in a time duration.
D -- follows the number of days in a time duration.
H -- follows the number of hours in a time duration.
S -- follows the number of seconds in a time duration.

The values of theYear, Month, Day, Hour and Minutes components are not restricted but allow an arbitrary integer. Similarly, the value of the Seconds componentallows an arbitrary decimal. Thus, the lexical format forduration and datatypes derived from it does not follow the alternative format of § 5.5.3.2.1 of[ISO 8601].

D.2 Truncated and Reduced Formats

[ISO 8601] supports a variety of "truncated" formats inwhich some of the characters on the left of specific formats, for example,thecentury, can be omitted.Truncated formats are, ingeneral, not permitted for the datatypes defined in this specificationwith three exceptions. Thetime datatype usesa truncated format fordateTimewhich represents an instant of time that recurs every day.Similarly, thegMonthDay andgDaydatatypes use left-truncated formats fordate.The datatypegMonth uses a right and left truncated format fordate.

[ISO 8601] also supports a variety of "reduced" or right-truncatedformats in which some of the characters to the right of specific formats,such as thetime specification, can be omitted. Right truncated formats are also, ingeneral,not permitted for the datatypes defined in this specificationwith the following exceptions:right-truncated representations ofdateTime are used aslexical representations fordate,gMonth,gYear.

D.3 Deviations from ISO 8601 Formats

D.3.1Sign Allowed

D.3.2No Year Zero

D.3.3More Than 9999 Years

D.3.1 Sign Allowed

An optional minus sign is allowed immediately preceding, without a space,the lexical representations forduration,dateTime,date,gMonth,gYear.

D.3.2 No Year Zero

The year "0000" is an illegal year value.

D.3.3 More Than 9999 Years

To accommodate year values greater than 9999, more than four digits areallowed in the year representations ofdateTime,date,gYearMonth, andgYear.This follows[ISO 8601 Draft Revision].

E Adding durations to dateTimes

Given adateTime S and aduration D, thisappendix specifies how to compute adateTime E where E is theend of the time period with start S and duration D i.e. E = S + D. Suchcomputations are used, for example, to determine whether adateTimeis within a specific time period. This appendix also addresses the addition ofdurations to the datatypesdate,gYearMonth,gYear,gDay andgMonth, which can be viewed as a set ofdateTimes.In such cases, the addition is made to the first or startingdateTime in the set.

This is a logical explanation of the process.Actual implementations are free to optimize as long as they produce the sameresults. The calculation uses the notation S[year] to represent the yearfield of S, S[month] to represent the month field, and so on. It also depends onthe following functions:

fQuotient(a, b) = the greatest integer less than or equal to a/b
- fQuotient(-1,3) = -1
- fQuotient(0,3)...fQuotient(2,3) = 0
- fQuotient(3,3) = 1
- fQuotient(3.123,3) = 1
modulo(a, b) = a - fQuotient(a,b)*b
- modulo(-1,3) = 2
- modulo(0,3)...modulo(2,3) = 0...2
- modulo(3,3) = 0
- modulo(3.123,3) = 0.123
fQuotient(a, low, high) = fQuotient(a - low, high - low)
- fQuotient(0, 1, 13) = -1
- fQuotient(1, 1, 13) ... fQuotient(12, 1, 13) = 0
- fQuotient(13, 1, 13) = 1
- fQuotient(13.123, 1, 13) = 1
modulo(a, low, high) = modulo(a - low, high - low) + low
- modulo(0, 1, 13) = 12
- modulo(1, 1, 13) ... modulo(12, 1, 13) = 1...12
- modulo(13, 1, 13) = 1
- modulo(13.123, 1, 13) = 1.123
maximumDayInMonthFor(yearValue, monthValue) =
- M := modulo(monthValue, 1, 13)
- Y := yearValue + fQuotient(monthValue, 1, 13)
- Return a value based on M and Y:

31	M = January, March, May, July, August, October, or December
30	M = April, June, September, or November
29	M = February AND (modulo(Y, 400) = 0 OR (modulo(Y, 100) != 0) AND modulo(Y, 4) = 0)
28	Otherwise

E.1 Algorithm

Essentially, this calculation is equivalent to separating D into <year,month>and <day,hour,minute,second> fields. The <year,month> is added to S.If the day is out of range, it ispinned to be within range. Thus April31 turns into April 30. Then the <day,hour,minute,second> is added. Thislatter addition can cause the year and month to change.

Leap seconds are handled by the computation by treating them as overflows.Essentially, a value of 60seconds in S is treated as if it were a duration of 60 seconds added to S(with a zero seconds field). All calculationsthereafter use 60 seconds per minute.

Thus the addition of either PT1M or PT60S to any dateTime will alwaysproduce the same result. This is a special definition of addition whichis designed to match common practice, and -- most importantly -- be stableover time.

A definition that attempted to take leap-seconds into account would need tobe constantly updated, and could not predict the results of futureimplementation's additions. The decision to introduce a leap second in UTCis the responsibility of the[International Earth Rotation Service (IERS)]. They make periodicannouncements as to whenleap seconds are to be added, but this is not known more than a year inadvance. For more information on leap seconds, see[U.S. Naval Observatory Time Service Department].

The following is the precise specification. These steps must be followed inthe same order. If a field in D is not specified, it is treated as if it werezero. If a field in S is not specified, it is treated in the calculation as ifit were the minimum allowed value in that field, however, after the calculationis concluded, the corresponding field in E is removed (set to unspecified).

Months (may be modified additionally below)
- temp := S[month] + D[month]
- E[month] := modulo(temp, 1, 13)
- carry := fQuotient(temp, 1, 13)
Years (may be modified additionally below)
- E[year] := S[year] + D[year] + carry
Zone
- E[zone] := S[zone]
Seconds
- temp := S[second] + D[second]
- E[second] := modulo(temp, 60)
- carry := fQuotient(temp, 60)
Minutes
- temp := S[minute] + D[minute] + carry
- E[minute] := modulo(temp, 60)
- carry := fQuotient(temp, 60)
Hours
- temp := S[hour] + D[hour] + carry
- E[hour] := modulo(temp, 24)
- carry := fQuotient(temp, 24)
Days
- if S[day] > maximumDayInMonthFor(E[year], E[month])
  - tempDays := maximumDayInMonthFor(E[year], E[month])
- else if S[day] < 1
  - tempDays := 1
- else
  - tempDays := S[day]
- E[day] := tempDays + D[day] + carry
- START LOOP
  - IFE[day] < 1
    - E[day] := E[day] + maximumDayInMonthFor(E[year], E[month] - 1)
    - carry := -1
  - ELSE IFE[day] > maximumDayInMonthFor(E[year], E[month])
    - E[day] := E[day] - maximumDayInMonthFor(E[year], E[month])
    - carry := 1
  - ELSE EXIT LOOP
  - temp := E[month] + carry
  - E[month] := modulo(temp, 1, 13)
  - E[year] := E[year] + fQuotient(temp, 1, 13)
  - GOTO START LOOP

Examples:

dateTime	duration	result
2000-01-12T12:13:14Z	P1Y3M5DT7H10M3.3S	2001-04-17T19:23:17.3Z
2000-01	-P3M	1999-10
2000-01-12	PT33H	2000-01-13

E.2 Commutativity and Associativity

Time durations are added by simply adding each of their fields, respectively,without overflow.

The order of addition of durations to instantsis significant.For example, there are cases where:

((dateTime + duration1) + duration2) != ((dateTime +duration2) + duration1)

Example:

(2000-03-30 + P1D) + P1M = 2000-03-31 + P1M = 2001-04-30

(2000-03-30 + P1M) + P1D = 2000-04-30 + P1D = 2000-05-01

F Regular Expressions

A·regular expression· R is a sequence ofcharacters that denote aset of strings L(R).When used to constrain a·lexical space·, aregular expression R asserts that only stringsinL(R) are valid literals for values of that type.

[Definition:] Aregular expression is composed from zero or more·branch·es, separated by| characters.

[1] regExp ::= branch( '|'branch )*

For all·branch·esS, and for all·regular expression·sT, valid·regular expression·sR are:	Denoting the set of stringsL(R) containing:
(empty string)	the set containing just the empty string
S	all strings inL(S)
S\|T	all strings inL(S) and all strings inL(T)

[Definition:] Abranch consistsof zero or more·piece·s, concatenated together.

[2] branch ::= piece*

For all·piece·sS, and for all·branch·esT, valid·branch·esR are:	Denoting the set of stringsL(R) containing:
S	all strings inL(S)
ST	all stringsst withs inL(S) andt inL(T)

[Definition:] Apiece is an·atom·, possibly followed by a·quantifier·.

[3] piece ::= atom quantifier?

For all·atom·sS and non-negativeintegersn,m such thatn <= m, valid·piece·sR are:	Denoting the set of stringsL(R) containing:
S	all strings inL(S)
S?	the empty string, and all strings inL(S).
S*	All strings inL(S?) and all stringsst withs inL(S*) andt inL(S).( all concatenations of zero or more strings from L(S) )
S+	All stringsst withs inL(S) andt inL(S*).( all concatenations of one or more strings from L(S) )
S{n,m}	All stringsst withs inL(S) andt inL(S{n-1,m-1}).( Allsequences of at least n, and at most m, strings from L(S) )
S{n}	All strings inL(S{n,n}).( Allsequences of exactly n strings from L(S) )
S{n,}	All strings in L(S{n}S)( Allsequences of at least n, strings from L(S) )*
S{0,m}	All stringsst withs inL(S?) andt inL(S{0,m-1}).( Allsequences of at most m, strings from L(S) )
S{0,0}	The set containing only the empty string

NOTE:The regular expression language in the Perl Programming Language[Perl] does not include a quantifier of the formS{,m), since it is logically equivalent toS{0,m}.We have, therefore, left this logical possibility out of the regularexpression language defined by this specification. We welcomefurther input from implementors and schema authors on this issue.

[Definition:] Aquantifieris one of?,*,+,{n,m} or{n,}, which have the meaningsdefined in the table above.

`[4]`	`quantifier`	`::=`	`[?*+] \| ( '{'quantity '}' )`
`[5]`	`quantity`	`::=`	`quantRange \|quantMin \|QuantExact`
`[6]`	`quantRange`	`::=`	`QuantExact ','QuantExact`
`[7]`	`quantMin`	`::=`	`QuantExact ','`
`[8]`	`QuantExact`	`::=`	`[0-9]+`

[Definition:] Anatom is either a·normal character·, a·character class·, ora parenthesized·regular expression·.

[9] atom ::= Char |charClass | ( '('regExp ')' )

For all·normal character·sc,·character class·esC, and·regular expression·sS, valid·atom·sR are:	Denoting the set of stringsL(R) containing:
c	the single string consisting only ofc
C	all strings inL(C)
(S)	all strings inL(S)

[Definition:] Ametacharacteris either.,\,?,*,+,{,}(,),[ or].These characters have special meanings in·regular expression·s,but can be escaped to form·atom·s that denote thesets of strings containing only themselves, i.e., an escaped·metacharacter· behaves like a·normal character·.

[Definition:] Anormal character is any XML character that is not ametacharacter. In·regular expression·s, a normal character is anatom that denotes the singleton set of strings containing only itself.

[10] Char ::= [^.\?*+()|#x5B#x5D]

Note that a·normal character· can be represented either asitself, or with acharacterreference.

F.1 Character Classes

[Definition:] Acharacter class is an·atom· R that identifies aset of characters C(R). The set of stringsL(R) denoted by acharacter classR contains one single-character string"c" for each characterc inC(R).

[11] charClass ::= charClassEsc |charClassExpr

A character class is either a·character class escape· or a·character class expression·.

[Definition:] Acharacter class expression is a·character group· surroundedby[ and] characters. For all charactergroupsG, [G] is a validcharacter classexpression, identifying the set of charactersC([G]) =C(G).

[12] charClassExpr ::= '['charGroup ']'

[Definition:] Acharacter group is either a·positive character group·,a·negative character group·, or a·character class subtraction·.

[13] charGroup ::= posCharGroup |negCharGroup |charClassSub

[Definition:] Apositive character group consists of one or more·character range·s or·character class escape·s, concatenatedtogether. Apositive character group identifies the set ofcharacters containing all of the characters in all of the sets identifiedby its constituent ranges or escapes.

[14] posCharGroup ::= (charRange |charClassEsc)+

For all·character range·sR, all·character class escape·sE, and all·positive character group·sP, valid·positive character group·sG are:	Identifying the set of charactersC(G) containing:
R	all characters inC(R).
E	all characters inC(E).
RP	all characters inC(R) and all characters inC(P).
EP	all characters inC(E) and all characters inC(P).

[Definition:] Anegative character group is a·positive character group· preceded by the^ character.For all·positive character group·sP, ^Pis a validnegative character group, andC(^P)contains all XML characters that arenot inC(P).

[15] negCharGroup ::= '^'posCharGroup

[Definition:] Acharacter class subtraction is a·character class expression·subtracted from a·positive character group· or·negative character group·, using the- character.

[16] charClassSub ::= (posCharGroup |negCharGroup ) '-'charClassExpr

For any·positive character group· or·negative character group· G, and any·character class expression· C,G-C is a valid·character class subtraction·, identifying the set of all characters inC(G) that are not also inC(C).

[Definition:] Acharacter range R identifies a set ofcharactersC(R) containing all XML characters with UCScode points in a specified range.

`[17]`	`charRange`	`::=`	`seRange \|XmlCharRef \|XmlCharIncDash`
`[18]`	`seRange`	`::=`	`charOrEsc '-'charOrEsc`
`[19]`	`XmlCharRef`	`::=`	`( '&#' [0-9]+ ';' ) \| (' &#x' [0-9a-fA-F]+ ';' )`
`[20]`	`charOrEsc`	`::=`	`XmlChar \|SingleCharEsc`
`[21]`	`XmlChar`	`::=`	`[^\#x2D#x5B#x5D]`
`[22]`	`XmlCharIncDash`	`::=`	`[^\#x5B#x5D]`

A single XML character is a·character range· that identifiesthe set of characters containing only itself. All XML characters are validcharacter ranges, except as follows:

The[,], and\ characters are notvalid character ranges;
The^ character is only valid at the beginning of a·positive character group· if it is part of a·negative character group·; and
The- character is a valid character range only at thebeginning or end of a·positive character group·.

A·character range· ·may· also be writtenin the forms-e, identifying the set that contains all XML characterswith UCS code points greater than or equal to the code pointofs, but not greater than the code point ofe.

s-e is a valid character range iff:

s is a·single character escape·, or an XML character;
s is not\
If s is the first character in a·character class expression·, thens is not^
e is a·single character escape·, or an XML character;
e is not\ or[; and
The code point ofe is greater than or equal to the codepoint ofs;

NOTE:The code point of a·single character escape· is the code point of thesingle character in the set of characters that it identifies.

F.1.1 Character Class Escapes

[Definition:] Acharacter class escape is a short sequence of charactersthat identifies predefined character class. The valid characterclass escapes are the·single character escape·s, the·multi-character escape·s, and the·category escape·s (includingthe·block escape·s).

[23] charClassEsc ::= (SingleCharEsc |MultiCharEsc |catEsc |complEsc)

[Definition:] Asingle character escape identifies a set containing a onlyone character -- usually because that character is difficult orimpossible to write directly into a·regular expression·.

[24] SingleCharEsc ::= '\' [nrt\|.?*+(){}#x2D#x5B#x5D#x5E]

The valid·single character escape·s are:	Identifying the set of charactersC(R) containing:
`\n`	the newline character (#xA)
`\r`	the return character (#xD)
`\t`	the tab character (#x9)
`\\`	\
`\\|`	\|
`\.`	.
`\-`	-
`\^`	^
`\?`	?
`\*`	*
`\+`	+
`\{`	{
`\}`	}
`\(`	(
`\)`	)
`\[`	[
`\]`	]

[Definition:] [Unicode Database] specifies a number of possiblevalues for the "General Category" propertyand provides mappings from code points to specific character properties.The set containing all characters that have propertyX,can be identified with acategory escape\p{X}.The complement of this set is specified with thecategory escape\P{X}.([\P{X}] =[^\p{X}]).

`[25]`	`catEsc`	`::=`	`'\p{'charProp '}'`
`[26]`	`complEsc`	`::=`	`'\P{'charProp '}'`
`[27]`	`charProp`	`::=`	`IsCategory \|IsBlock`

NOTE:[Unicode Database] is subject to future revision. For example, themapping from code points to character properties might be updated. All·minimally conforming· processors·must·support the character properties defined in the version of[Unicode Database]that is current at the time this specification became a W3CRecommendation. However, implementors are encouraged to support thecharacter properties defined in any future version.

The following table specifies the recognized values of the"General Category" property.

Category	Property	Meaning
Letters	L	All Letters
	Lu	uppercase
	Ll	lowercase
	Lt	titlecase
	Lm	modifier
	Lo	other

Marks	M	All Marks
	Mn	nonspacing
	Mc	spacing combining
	Me	enclosing

Numbers	N	All Numbers
	Nd	decimal digit
	Nl	letter
	No	other

Punctuation	P	All Punctuation
	Pc	connector
	Pd	dash
	Ps	open
	Pe	close
	Pi	initial quote(may behave like Ps or Pe depending on usage)
	Pf	final quote(may behave like Ps or Pe depending on usage)
	Po	other

Separators	Z	All Separators
	Zs	space
	Zl	line
	Zp	paragraph

Symbols	S	All Symbols
	Sm	math
	Sc	currency
	Sk	modifier
	So	other

Other	C	All Others
	Cc	control
	Cf	format
	Co	private use
	Cn	not assigned

`[28]`	`IsCategory`	`::=`	`Letters \|Marks \|Numbers \|Punctuation \|Separators \|Symbols \|Others`
`[29]`	`Letters`	`::=`	`'L' [ultmo]?`
`[30]`	`Marks`	`::=`	`'M' [nce]?`
`[31]`	`Numbers`	`::=`	`'N' [dlo]?`
`[32]`	`Punctuation`	`::=`	`'P' [cdseifo]?`
`[33]`	`Separators`	`::=`	`'Z' [slp]?`
`[34]`	`Symbols`	`::=`	`'S' [mcko]?`
`[35]`	`Others`	`::=`	`'C' [cfon]?`

NOTE:The properties mentioned above exclude theCs property.TheCs property identifies "surrogate" characters, which do notoccur at the level of the "character abstraction" that XML instance documentsoperate on.

[Definition:] [Unicode Database] groups code points into a number of blockssuch as Basic Latin (i.e., ASCII), Latin-1 Supplement, Hangul Jamo,CJK Compatibility, etc.The set containing all characters that have block nameX(with all white space stripped out),can be identified with ablock escape\p{IsX}.The complement of this set is specified with theblock escape\P{IsX}.([\P{IsX}] =[^\p{IsX}]).

[36] IsBlock ::= 'Is' [a-zA-Z0-9#x2D]+

The following table specifies the recognized block names (for moreinformation, see the "Blocks.txt" file in[Unicode Database]).

Start Code	End Code	Block Name	Start Code	End Code	Block Name
#x0000	#x007F	BasicLatin	#x0080	#x00FF	Latin-1Supplement
#x0100	#x017F	LatinExtended-A	#x0180	#x024F	LatinExtended-B
#x0250	#x02AF	IPAExtensions	#x02B0	#x02FF	SpacingModifierLetters
#x0300	#x036F	CombiningDiacriticalMarks	#x0370	#x03FF	Greek
#x0400	#x04FF	Cyrillic	#x0530	#x058F	Armenian
#x0590	#x05FF	Hebrew	#x0600	#x06FF	Arabic
#x0700	#x074F	Syriac	#x0780	#x07BF	Thaana
#x0900	#x097F	Devanagari	#x0980	#x09FF	Bengali
#x0A00	#x0A7F	Gurmukhi	#x0A80	#x0AFF	Gujarati
#x0B00	#x0B7F	Oriya	#x0B80	#x0BFF	Tamil
#x0C00	#x0C7F	Telugu	#x0C80	#x0CFF	Kannada
#x0D00	#x0D7F	Malayalam	#x0D80	#x0DFF	Sinhala
#x0E00	#x0E7F	Thai	#x0E80	#x0EFF	Lao
#x0F00	#x0FFF	Tibetan	#x1000	#x109F	Myanmar
#x10A0	#x10FF	Georgian	#x1100	#x11FF	HangulJamo
#x1200	#x137F	Ethiopic	#x13A0	#x13FF	Cherokee
#x1400	#x167F	UnifiedCanadianAboriginalSyllabics	#x1680	#x169F	Ogham
#x16A0	#x16FF	Runic	#x1780	#x17FF	Khmer
#x1800	#x18AF	Mongolian	#x1E00	#x1EFF	LatinExtendedAdditional
#x1F00	#x1FFF	GreekExtended	#x2000	#x206F	GeneralPunctuation
#x2070	#x209F	SuperscriptsandSubscripts	#x20A0	#x20CF	CurrencySymbols
#x20D0	#x20FF	CombiningMarksforSymbols	#x2100	#x214F	LetterlikeSymbols
#x2150	#x218F	NumberForms	#x2190	#x21FF	Arrows
#x2200	#x22FF	MathematicalOperators	#x2300	#x23FF	MiscellaneousTechnical
#x2400	#x243F	ControlPictures	#x2440	#x245F	OpticalCharacterRecognition
#x2460	#x24FF	EnclosedAlphanumerics	#x2500	#x257F	BoxDrawing
#x2580	#x259F	BlockElements	#x25A0	#x25FF	GeometricShapes
#x2600	#x26FF	MiscellaneousSymbols	#x2700	#x27BF	Dingbats
#x2800	#x28FF	BraillePatterns	#x2E80	#x2EFF	CJKRadicalsSupplement
#x2F00	#x2FDF	KangxiRadicals	#x2FF0	#x2FFF	IdeographicDescriptionCharacters
#x3000	#x303F	CJKSymbolsandPunctuation	#x3040	#x309F	Hiragana
#x30A0	#x30FF	Katakana	#x3100	#x312F	Bopomofo
#x3130	#x318F	HangulCompatibilityJamo	#x3190	#x319F	Kanbun
#x31A0	#x31BF	BopomofoExtended	#x3200	#x32FF	EnclosedCJKLettersandMonths
#x3300	#x33FF	CJKCompatibility	#x3400	#x4DB5	CJKUnifiedIdeographsExtensionA
#x4E00	#x9FFF	CJKUnifiedIdeographs	#xA000	#xA48F	YiSyllables
#xA490	#xA4CF	YiRadicals	#xAC00	#xD7A3	HangulSyllables
#xD800	#xDB7F	HighSurrogates	#xDB80	#xDBFF	HighPrivateUseSurrogates
#xDC00	#xDFFF	LowSurrogates	#xE000	#xF8FF	PrivateUse
#xF900	#xFAFF	CJKCompatibilityIdeographs	#xFB00	#xFB4F	AlphabeticPresentationForms
#xFB50	#xFDFF	ArabicPresentationForms-A	#xFE20	#xFE2F	CombiningHalfMarks
#xFE30	#xFE4F	CJKCompatibilityForms	#xFE50	#xFE6F	SmallFormVariants
#xFE70	#xFEFE	ArabicPresentationForms-B	#xFEFF	#xFEFF	Specials
#xFF00	#xFFEF	HalfwidthandFullwidthForms	#xFFF0	#xFFFD	Specials
#x10300	#x1032F	OldItalic	#x10330	#x1034F	Gothic
#x10400	#x1044F	Deseret	#x1D000	#x1D0FF	ByzantineMusicalSymbols
#x1D100	#x1D1FF	MusicalSymbols	#x1D400	#x1D7FF	MathematicalAlphanumericSymbols
#x20000	#x2A6D6	CJKUnifiedIdeographsExtensionB	#x2F800	#x2FA1F	CJKCompatibilityIdeographsSupplement
#xE0000	#xE007F	Tags	#xF0000	#xFFFFD	PrivateUse
#x100000	#x10FFFD	PrivateUse

NOTE:[Unicode Database] is subject to future revision.For example, thegrouping of code points into blocks might be updated. All·minimally conforming· processors·must·support the blocks defined in the version of[Unicode Database]that is current at the time this specification became a W3CRecommendation. However, implementors are encouraged to support theblocks defined in any future version of the Unicode Standard.

For example, the·block escape· for identifying theASCII characters is\p{IsBasicLatin}.

[Definition:] Amulti-character escape provides a simple way to identifya commonly used set of characters:

[37] MultiCharEsc ::= '.' | ('\' [sSiIcCdDwW])

Character sequence	Equivalent·character class·
.	[^\n\r]
\s	[#x20\t\n\r]
\S	[^\s]
\i	the set of initial name characters, those·match·ed byLetter \| '_' \| ':'
\I	[^\i]
\c	the set of name characters, those·match·ed byNameChar
\C	[^\c]
\d	\p{Nd}
\D	[^\d]
\w	[#x0000-#x10FFFF]-[\p{P}\p{Z}\p{C}](all characters except the set of "punctuation","separator" and "other" characters)
\W	[^\w]

NOTE:The·regular expression· language defined here does notattempt to provide a general solution to "regular expressions" overUCS character sequences. In particular, it does not easily providefor matching sequences of base characters and combining marks.The language is targeted at support of "Level 1" features as defined in[Unicode Regular Expression Guidelines]. It is hoped that future versions of thisspecification will provide support for "Level 2" features.

G Glossary (non-normative)

The listing below is for the benefit of readers of a printed version of thisdocument: it collects together all the definitions which appear in thedocument above.

atomic: Atomic datatypesare those having values which are regarded by this specification asbeing indivisible.
base type: Everydatatype that is·derived· byrestrictionis defined in terms of an existing datatype, referred to as itsbase type.base types can be either·primitive· or·derived·.
bounded: A datatype isboundedif its·value space· has either an·inclusive upper bound· or an·exclusive upper bound·and either an·inclusive lower bound· and an·exclusive lower bound·.
built-in: Built-indatatypes are those which are defined in this specification,and can be either·primitive· or·derived·;
canonical lexical representation: Acanonical lexical representationis a set of literals from among the valid set of literalsfor a datatype such that there is a one-to-one mapping between literalsin thecanonical lexical representation andvalues in the·value space·.
cardinality: Every·value space· has associated with it the concept ofcardinality. Some·value space·sare finite, some are countably infinite while still others couldconceivably be uncountably infinite (although no·value space·defined by this specification is uncountable infinite). A datatype issaid to have the cardinality of its·value space·.
conformance to the XML Representation of Schemas: Processors which accept schemas in the form of XML documents as describedinXML Representation of Simple Type Definition Schema Components (§4.1.2) (and other relevant portions ofDatatype components (§4)) are additionally said to provideconformance to the XML Representation of Schemas,and·must·, when processing schema documents, completely andcorrectly implement all·Schema Representation Constraint·sin this specification, and·must· adhere exactly to thespecifications inXML Representation of Simple Type Definition Schema Components (§4.1.2) (and other relevant portions ofDatatype components (§4)) for mappingthe contents of suchdocuments toschema componentsfor use in validation.
constraining facet: Aconstraining facet is an optional property that can beapplied to a datatype to constrain its·value space·.
Constraint on Schemas: Constraint on Schemas
datatype: In this specification,adatatype is a 3-tuple, consisting ofa) a set of distinct values, called its·value space·,b) a set of lexical representations, called its·lexical space·, and c) a set of·facet·sthat characterize properties of the·value space·,individual values or lexical items.
derived: Deriveddatatypes are those that are defined in terms of other datatypes.
error: error
exclusive lower bound: A valuel in an·ordered· ·value space· Lis said to be anexclusive lower bound of a·value space· V(whereV is a subset ofL)if for allv inV,l <v.
exclusive upper bound: A valueu in an·ordered· ·value space· Uis said to be anexclusive upper bound of a·value space· V(whereV is a subset ofU)if for allv inV,u >v.
facet: Afacet is a singledefining aspect of a·value space·. Generallyspeaking, each facet characterizes a·value space·along independent axes or dimensions.
for compatibility: for compatibility
fundamental facet: Afundamental facet is an abstract property whichserves to semantically characterize the values in a·value space·.
inclusive lower bound: A valuel in an·ordered· ·value space· Lis said to be aninclusive lower bound of a·value space· V(whereV is a subset ofL)if for allv inV,l <=v.
inclusive upper bound: A valueu in an·ordered· ·value space· Uis said to be aninclusive upper bound of a·value space· V(whereV is a subset ofU)if for allv inV,u >=v.
itemType: The·atomic· datatype that participates in thedefinition of a·list· datatype is known as theitemType of that·list· datatype.
lexical space: Alexical space is the set of validliteralsfor a datatype.
list: Listdatatypes are those having values each of which consists of afinite-length (possibly empty) sequence of values of an·atomic· datatype.
match: match
may: may
memberTypes: The datatypes that participate in thedefinition of a·union· datatype are known as thememberTypes of that·union· datatype.
minimally conforming: Minimally conforming processors·must·completely and correctly implement the·Constraint on Schemas· and·Validation Rule·.
must: must
non-numeric: A datatype whose valuesare not·numeric· is said to benon-numeric.
numeric: A datatype is said to benumeric if its values are conceptually quantities (in somemathematical number system).
ordered: A·value space·, and hence a datatype, is said to beordered if there exists an·order-relation· defined for that·value space·.
order-relation: Anorder relation on a·value space·is a mathematical relation that imposes a·total order· or a·partial order· on themembers of the·value space·.
partial order: Apartial order is an·order-relation·that isirreflexive,asymmetric andtransitive.
primitive: Primitivedatatypes are those that are not defined in terms of other datatypes;they existab initio.
regular expression: Aregular expression is composed from zero or more·branch·es, separated by| characters.
restriction: A datatype is said to be·derived· byrestriction from another datatypewhen values for zero or more·constraining facet·s are specifiedthat serve to constrain its·value space· and/or its·lexical space· to a subset of those of its·base type·.
Schema Representation Constraint: Schema Representation Constraint
total order: Atotal order is an·partial order·such that for noa andbis it the case thata <> b.
union: Uniondatatypes are those whose·value space·s and·lexical space·s are the union ofthe·value space·s and·lexical space·s of one or more other datatypes.
user-derived: User-derived datatypes are those·derived·datatypes that are defined by individual schema designers.
Validation Rule: Validation Rule
value space: Avaluespace is the set of values for a given datatype.Each value in thevalue space of a datatype is denoted byone or more literals in its·lexical space·.

H References

H.1 Normative

Clinger, WD (1990): William D Clinger.How to Read Floating Point Numbers Accurately.InProceedings of Conference on Programming Language Design andImplementation, pages 92-101.Available at:ftp://ftp.ccs.neu.edu/pub/people/will/howtoread.ps
IEEE 754-1985: IEEE.IEEE Standard for Binary Floating-Point Arithmetic.Seehttp://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html
Namespaces in XML: World Wide Web Consortium.Namespaces in XML. Available at:http://www.w3.org/TR/1999/REC-xml-names-19990114/
RFC 1766: H. Alvestrand, ed.RFC 1766: Tags for the Identification of Languages1995. Available at:http://www.ietf.org/rfc/rfc1766.txt
RFC 2045: N. Freed and N. Borenstein.RFC 2045: Multipurpose Internet Mail Extensions(MIME) Part One: Format of Internet Message Bodies. 1996. Available at:http://www.ietf.org/rfc/rfc2045.txt
RFC 2396: Tim Berners-Lee, et. al.RFC 2396: Uniform Resource Identifiers (URI):Generic Syntax.. 1998. Available at:http://www.ietf.org/rfc/rfc2396.txt
RFC 2732: RFC2732: Format for Literal IPv6 Addresses in URL's. 1999.Available at:http://www.ietf.org/rfc/rfc2732.txt
Unicode Database: The Unicode Consortium.The Unicode Character Database.Available at:http://www.unicode.org/Public/3.1-Update/UnicodeCharacterDatabase-3.1.0.html
XML 1.0 (Second Edition): World Wide Web Consortium.Extensible Markup Language (XML) 1.0, SecondEdition.Available at:http://www.w3.org/TR/2000/WD-xml-2e-20000814
XML Linking Language: World Wide Web Consortium. XML Linking Language (XLink).Available at:http://www.w3.org/TR/2000/PR-xlink-20001220/
XML Schema Part 1: Structures: XML Schema Part 1: Structures. Available at:http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/
XML Schema Requirements: World Wide Web Consortium. XML Schema Requirements. Available at:http://www.w3.org/TR/1999/NOTE-xml-schema-req-19990215

H.2 Non-normative

Character Model: Martin J. Dürst and François Yergeau, eds.Character Model for the World Wide Web. World Wide Web ConsortiumWorking Draft. 2001.Available at:http://www.w3.org/TR/2001/WD-charmod-20010126/
Gay, DM (1990): David M. Gay.Correctly Rounded Binary-Decimal andDecimal-Binary Conversions. AT&T Bell Laboratories NumericalAnalysis Manuscript 90-10, November 1990.Available at:http://cm.bell-labs.com/cm/cs/doc/90/4-10.ps.gz
HTML 4.01: World Wide Web Consortium. Hypertext Markup Language, version 4.01. Available at:http://www.w3.org/TR/1999/REC-html401-19991224/
IETF INTERNET-DRAFT: IRIs: L. Masinter and M. Durst.Internationalized Resource Identifiers2001. Available at:http://www.ietf.org/internet-drafts/draft-masinter-url-i18n-07.txt
International Earth Rotation Service (IERS): International Earth Rotation Service (IERS).Seehttp://maia.usno.navy.mil
ISO 11404: ISO (International Organization for Standardization).Language-independent Datatypes. See http://www.iso.ch/cate/d19346.html
ISO 8601: ISO (International Organization for Standardization).Representations of dates and times, 1988-06-15. Available at:http://www.iso.ch/markete/8601.pdf
ISO 8601 Draft Revision: ISO (International Organization for Standardization).Representations of dates and times, draft revision, 2000.
Perl: The Perl Programming Language. Seehttp://www.perl.com/pub/language/info/software.html
RDF Schema: World Wide Web Consortium.RDF Schema Specification.Available at:http://www.w3.org/TR/2000/CR-rdf-schema-20000327/
Ruby: World Wide Web Consortium. Ruby Annotation. Available at:http://www.w3.org/TR/2001/WD-ruby-20010216/
SQL: ISO (International Organization for Standardization).ISO/IEC9075-2:1999, Information technology --- Database languages ---SQL --- Part 2: Foundation (SQL/Foundation).[Geneva]: International Organization for Standardization, 1999.Seehttp://www.iso.ch/cate/d26197.html
U.S. Naval Observatory Time Service Department: Information about Leap SecondsAvailable at:http://tycho.usno.navy.mil/leapsec.990505.html
Unicode Regular Expression Guidelines: Mark Davis.Unicode Regular Expression Guidelines, 1988.Available at:http://www.unicode.org/unicode/reports/tr18/
XML Schema Language: Part 2 Primer: World Wide Web Consortium. XML Schema Language: Part 2 Primer. Available at:http://www.w3.org/TR/2001/REC-xmlschema-0-20010502/
XSL: World Wide Web Consortium.Extensible Stylesheet Language (XSL).Available at:http://www.w3.org/TR/2000/CR-xsl-20001121/

I Acknowledgements (non-normative)

The following have contributed material to this draft:

Asir S. Vedamuthu, webMethods, Inc
Mark Davis, IBM

Co-editor Ashok Malhotra's work on this specification from March 1999 untilFebruary 2001 was supported by IBM.

The editors acknowledge the members of the XML Schema Working Group, the members of other W3C Working Groups, and industry experts in otherforums who have contributed directly or indirectly to the process or content ofcreating this document. The Working Group is particularly grateful to LotusDevelopment Corp. and IBM for providing teleconferencing facilities.

The current members of the XML Schema Working Group are:

Jim Barnette, Defense Information Systems Agency (DISA); Paul V. Biron, Health Level Seven; Don Box, DevelopMentor; Allen Brown, Microsoft; Lee Buck, TIBCO Extensibility; Charles E. Campbell, Informix; Wayne Carr, Intel; Peter Chen, Bootstrap Alliance and LSU; David Cleary, Progress Software; Dan Connolly, W3C (staff contact); Ugo Corda, Xerox; Roger L. Costello, MITRE; Haavard Danielson, Progress Software; Josef Dietl, Mozquito Technologies; David Ezell, Hewlett-Packard Company; Alexander Falk, Altova GmbH; David Fallside, IBM; Dan Fox, Defense Logistics Information Service (DLIS); Matthew Fuchs, Commerce One; Andrew Goodchild, Distributed Systems Technology Centre (DSTC Pty Ltd); Paul Grosso, Arbortext, Inc; Martin Gudgin, DevelopMentor; Dave Hollander, Contivo, Inc (co-chair); Mary Holstege, Invited Expert; Jane Hunter, Distributed Systems Technology Centre (DSTC Pty Ltd); Rick Jelliffe, Academia Sinica; Simon Johnston, Rational Software; Bob Lojek, Mozquito Technologies; Ashok Malhotra, Microsoft; Lisa Martin, IBM; Noah Mendelsohn, Lotus Development Corporation; Adrian Michel, Commerce One; Alex Milowski, Invited Expert; Don Mullen, TIBCO Extensibility; Dave Peterson, Graphic Communications Association; Jonathan Robie, Software AG; Eric Sedlar, Oracle Corp.; C. M. Sperberg-McQueen, W3C (co-chair); Bob Streich, Calico Commerce; William K. Stumbo, Xerox; Henry S. Thompson, University of Edinburgh; Mark Tucker, Health Level Seven; Asir S. Vedamuthu, webMethods, Inc; Priscilla Walmsley, XMLSolutions; Norm Walsh, Sun Microsystems; Aki Yoshida, SAP AG; Kongyi Zhou, Oracle Corp.

The XML Schema Working Group has benefited in its work from theparticipation and contributions of a number of people not currentlymembers of the Working Group, includingin particular those named below. Affiliations given are those current atthe time of their work with the WG.

Paula Angerstein, Vignette Corporation; David Beech, Oracle Corp.; Gabe Beged-Dov, Rogue Wave Software; Greg Bumgardner, Rogue Wave Software; Dean Burson, Lotus Development Corporation; Mike Cokus, MITRE; Andrew Eisenberg, Progress Software; Rob Ellman, Calico Commerce; George Feinberg, Object Design; Charles Frankston, Microsoft; Ernesto Guerrieri, Inso; Michael Hyman, Microsoft; Renato Iannella, Distributed Systems Technology Centre (DSTC Pty Ltd); Dianne Kennedy, Graphic Communications Association; Janet Koenig, Sun Microsystems; Setrag Khoshafian, Technology Deployment International (TDI); Ara Kullukian, Technology Deployment International (TDI); Andrew Layman, Microsoft; Dmitry Lenkov, Hewlett-Packard Company; John McCarthy, Lawrence Berkeley National Laboratory; Murata Makoto, Xerox; Eve Maler, Sun Microsystems; Murray Maloney, Muzmo Communication, acting for Commerce One; Chris Olds, Wall Data; Frank Olken, Lawrence Berkeley National Laboratory; Shriram Revankar, Xerox; Mark Reinhold, Sun Microsystems; John C. Schneider, MITRE; Lew Shannon, NCR; William Shea, Merrill Lynch; Ralph Swick, W3C; Tony Stewart, Rivcom; Matt Timmermans, Microstar; Jim Trezzo, Oracle Corp.; Steph Tryphonas, Microstar

Movatterモバイル変換

XML Schema Part 2: Datatypes

W3C Recommendation 02 May 2001

Abstract

Status of this document

Table of contents

Appendices

1 Introduction

1.1 Purpose

1.2 Requirements

1.3 Scope

1.4 Terminology

1.5 Constraints and Contributions

2 Type System

2.1 Datatype

2.2 Value space

2.3 Lexical space

2.3.1 Canonical Lexical Representation

2.4 Facets

2.4.1 Fundamental facets

2.4.2 Constraining or Non-fundamental facets

2.5 Datatype dichotomies

2.5.1 Atomic vs. list vs. union datatypes

2.5.1.1 Atomic datatypes

2.5.1.2 List datatypes

2.5.1.3 Union datatypes

2.5.2 Primitive vs. derived datatypes

2.5.2.1 Derived by restriction

2.5.2.2 Derived by list

2.5.2.3 Derived by union

2.5.3 Built-in vs. user-derived datatypes

3 Built-in datatypes

3.1 Namespace considerations

3.2 Primitive datatypes

3.2.1 string

3.2.1.1 Constraining facets

3.2.1.2 Derived datatypes

3.2.2 boolean

3.2.2.1 Lexical representation

3.2.2.2 Canonical representation

3.2.2.3 Constraining facets

3.2.3 decimal

3.2.3.1 Lexical representation

3.2.3.2 Canonical representation

3.2.3.3 Constraining facets

3.2.3.4 Derived datatypes

3.2.4 float

3.2.4.1 Lexical representation

3.2.4.2 Canonical representation

3.2.4.3 Constraining facets

3.2.5 double

3.2.5.1 Lexical representation

3.2.5.2 Canonical representation

3.2.5.3 Constraining facets

3.2.6 duration

3.2.6.1 Lexical representation

3.2.6.2 Order relation on duration

3.2.6.3 Facet Comparison for durations

3.2.6.4 Totally ordered durations

3.2.6.5 Constraining facets

3.2.7 dateTime

3.2.7.1 Lexical representation

3.2.7.2 Canonical representation

3.2.7.3 Order relation on dateTime

3.2.7.4 Totally ordered dateTimes

3.2.7.5 Constraining facets

3.2.8 time

3.2.8.1 Lexical representation

3.2.8.2 Canonical representation

3.2.8.3 Constraining facets

3.2.9 date

3.2.9.1 Lexical representation

3.2.9.2 Constraining facets

3.2.10 gYearMonth

3.2.10.1 Lexical representation

3.2.10.2 Constraining facets

3.2.11 gYear

3.2.11.1 Lexical representation

3.2.11.2 Constraining facets

3.2.12 gMonthDay