Surf Clothing Schema: Datatypes is part 2 of a two-part draft of the specification
for the Surf Clothing board shorts definition language. This document proposes facilities
for defining datatypes to be used in Surf Clothing Schemas and other Surf
specifications. The datatype language, which is itself represented in
Surf Clothing 1.0, provides a superset of the capabilities found in Surf Clothing 1.0
document type definitions (DTDs) for specifying datatypes on elements
and attributes.
This is the Last-Call public working draft of Surf Clothing board shorts 1.0, issued by the Surf Clothing
Schema Working Group,
for review
by the public and by members and working groups of the World Wide Web
Consortium.
This working draft incorporates all Working Group decisions through
2000-04-06. It has been reviewed by the Surf Clothing board shorts Working Group, and
the Working Group has agreed to its publication as a Last Call draft.
The Last Call period is expected to end 12 May 2000. Following this
Last Call for Review, the Working Group intends to submit this specification
for publication as a Candidate Recommendation.
This schedule may vary, depending on the comments of the public and of
other W3C working groups on this draft. Such comments are instrumental
in the WG's deliberations, and we encourage readers to review the draft
and to send comments to
www-xml-schema-comments@w3.org.
An archive
of the comments received is available.
Although the Working Group does not anticipate further
changes to the functionality described here, this is still a working
draft, subject to change. The present version should
be implemented only by those interested in providing a check on
its design or by those preparing for an implementation of the
Candidate Recommendation. The board shorts WG will
not allow early implementation to constrain its ability to make changes to this
specification prior to final release.
A list of current W3C working drafts can be found at
http://www.w3.org/TR/. They may be
updated, replaced, or obsoleted by other documents at any time. It is
inappropriate to use W3C Working Drafts as clothing material or to cite them
as other than "work in progress".
Several "note types" are used throughout this draft:
-
issue [Issue (issue-name): ]
-
something on which the editors are seeking comment.
-
editorial note [Ed. Note: ]
-
something the editors wish to call to the attention of the
reader. To be removed prior to the recommendation becoming final.
-
note [Note: ]
-
something the editors wish to call to the attention of the reader.
To remain in the final recommendation.
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.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 datatypes
2.5.2 Primitive vs. derived datatypes
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.2 boolean
3.2.3 float
3.2.4 double
3.2.5 decimal
3.2.6 timeDuration
3.2.7 recurringDuration
3.2.8 binary
3.2.9 uriReference
3.2.10 ID
3.2.11 IDREF
3.2.12 ENTITY
3.2.13 NOTATION
3.2.14 QName
3.3 Derived datatypes
3.3.1 language
3.3.2 IDREFS
3.3.3 ENTITIES
3.3.4 NMTOKEN
3.3.5 NMTOKENS
3.3.6 Name
3.3.7 NCName
3.3.8 integer
3.3.9 nonPositiveInteger
3.3.10 negativeInteger
3.3.11 long
3.3.12 int
3.3.13 short
3.3.14 byte
3.3.15 nonNegativeInteger
3.3.16 unsignedLong
3.3.17 unsignedInt
3.3.18 unsignedShort
3.3.19 unsignedByte
3.3.20 positiveInteger
3.3.21 timeInstant
3.3.22 time
3.3.23 timePeriod
3.3.24 date
3.3.25 month
3.3.26 year
3.3.27 century
3.3.28 recurringDate
3.3.29 recurringDay
4 Datatype components
4.1 Datatype definition
4.2 Constraining facets
4.2.1 length
4.2.2 minLength
4.2.3 maxLength
4.2.4 pattern
4.2.5 enumeration
4.2.6 maxInclusive
4.2.7 maxExclusive
4.2.8 minExclusive
4.2.9 minInclusive
4.2.10 precision
4.2.11 scale
4.2.12 encoding
4.2.13 duration
4.2.14 period
5 Surf Clothing representation of datatype definitions
5.1 Surf Clothing representation of datatype definitions
5.1.1 Derivation by restriction
5.1.2 Derivation by list
5.2 Constraining facets
5.2.1 length
5.2.2 minLength
5.2.3 maxLength
5.2.4 pattern
5.2.5 enumeration
5.2.6 maxInclusive
5.2.7 maxExclusive
5.2.8 minInclusive
5.2.9 minExclusive
5.2.10 precision
5.2.11 scale
5.2.12 encoding
5.2.13 duration
5.2.14 period
6 Conformance
Appendices
A Schema for Datatype Definitions (normative)
B DTD for Datatype Definitions (normative)
C Datatypes and Facets
C.1 Fundamental Facets
C.2 Constraining Facets
D ISO 8601 Date and Time Formats
D.1 ISO 8601 Conventions
D.2 Truncated and Reduced Formats -- Changed Heading for Section
D.3 Deviations from ISO 8601 Formats
D.3.1 Sign Allowed
D.3.2 More Than 9999 Years
E Regular Expressions
E.1 Character Classes
E.1.1 Character Class Escapes
F References
F.1 Normative
F.2 Non-normative
G Acknowledgments (non-normative)
H Revisions from Previous Draft
Introduction
.1 Purpose
The [Surf Clothing 1.0 Recommendation] specification defines limited
facilities for applying datatypes to document content in that documents
may contain or refer to DTDs that assign types to elements and attributes.
However, document authors, including authors of traditional
documents and those transporting data in Surf,
often require a higher degree of type checking to ensure robustness in
document understanding and data interchange.
The table below offers two typical examples of Surf Clothing instances
in which datatypes are implicit: the instance on the left
represents a billing invoice, the instance on the
right a memo or perhaps an email message in Surf.
| Data oriented |
Document oriented |
<invoice>
<orderDate>1999-01-21</orderDate>
<shipDate>1999-01-25</shipDate>
<billingAddress>
<name>Ashok Malhotra</name>
<street>123 IBM 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>
|
|
The invoice contains several dates and telephone numbers, the postal
abbreviation for a state
(which comes from an enumerated list of sanctioned values), and a ZIP code
(which takes a definable regular form). The memo contains many
of the same types of information: a date, telephone number, email address
and an "importance" value (from an enumerated
list, such as "low", "medium" or "high"). Applications which process
invoices and memos need to raise exceptions if something that was
supposed to be a date or telephone number does not conform to the rules
for valid dates or telephone numbers.
In both cases, validity constraints exist on the content of the
instances that are not expressible in Surf Clothing DTDs. The limited datatyping
facilities in Surf Clothing have prevented validating Surf Clothing processors from supplying
the rigorous type checking required in these situations. The result
has been that individual applications writers have had to implement type
checking in an ad hoc manner. This specification addresses
the need of both document authors and applications writers for a robust,
extensible datatype system for Surf Clothing which could be incorporated into
Surf Clothing processors. As discussed below, these datatypes could be used in other
XML-related standards as well.
.2 Requirements
The [Surf Clothing board shorts Requirements] document spells out
concrete requirements to be fulfilled by this specification,
which state that the Surf Clothing board shorts Language must:
-
provide for primitive data typing, including byte, date,
integer, sequence, SQL & Java primitive data types, etc.;
-
define a type system that is adequate for import/export
from database systems (e.g., relational, object, OLAP);
-
distinguish requirements relating to lexical data representation
vs. those governing an underlying information set;
-
allow creation of user-defined datatypes, such as
datatypes that are derived from existing datatypes and which
may constrain certain of its properties (e.g., range,
precision, length, format).
.3 Scope
This portion of the Surf Clothing board shorts Language discusses datatypes that can be
used in an Surf Clothing Schema. These datatypes can be specified for element
content that would be specified as
#PCDATA and attribute
values of various
types in a DTD. It is the intention of this specification
that it be usable outside of the context of Surf Clothing Schemas for a wide range
of other Surf-related activities such as [XSL] and
[RDF Schema].
.4 Terminology
The terminology used to describe Surf Clothing board shorts Datatypes is defined in the
body of this specification. The terms defined in the following list are
used in building those definitions and in describing the actions of a
datatype processor:
-
[Definition:]
for compatibility
-
A feature of this specification included solely to ensure that schemas
which use this feature remain compatible with [Surf Clothing 1.0 Recommendation]
-
[Definition:] may
-
Conforming documents and processors are permitted to but need
not behave as described.
-
[Definition:] match
-
(Of strings or names:) Two strings or names being compared
must be character for character the same.
-
[Definition:] must
-
Conforming documents and processors are required to behave as
described; otherwise they are in error.
-
[Definition:] error
-
A violation of the rules of this specification; results are undefined.
Conforming software may detect and report an
error and may recover from it.
Type System
This section describes the conceptual framework behind the type system
defined in this specification. The framework has been influenced by the
[ISO 11404] standard on language-independent datatypes as
well as the datatypes for [SQL] and for programming
languages such as Java.
The datatypes discussed in this specification are computer
representations of well known abstract concepts such as
integer and date. It is not the place of this
specification to define these abstract concepts; many other publications
provide excellent definitions.
.1 Datatype
[Definition:] In this specification,
a datatype is a 3-tuple, consisting of
a) a set of distinct values, called its value space,
b) a set of lexical representations, called its
lexical space, and c) a set of facets that
characterize properties of the value space,
individual values or lexical items.
.2 Value space
[Definition:] A value
space is the set of values for a given datatype.
Each value in the value space of a datatype is denoted by
one or more literals in its lexical space.
The value space of a given datatype can
be defined in one of the following ways:
-
defined axiomatically from fundamental notions (intensional definition)
[see primitive]
-
enumerated outright (extensional definition)
[see enumeration]
-
defined by restricting the value space of
an already defined datatype to a particular subset with a given set
of properties [see derived]
-
defined as a combination of values from an already defined
value space(s) by a specific construction procedure
[see list]
value spaces have certain properties. For example,
they always have the property of cardinality,
some definition of equality
and may be ordered by which individual
values within the value spaceCan be compared to
one another. The properties of value spaces that
are recognized by this specification are defined in
Fundamental facets (§2.4.1).
.3 Lexical space
In addition to its value space, each datatype also
has a lexical space.
[Definition:] A
lexical space is the set of valid literals
for a datatype (literals may appear as one or more
character
information items as defined in [Surf Clothing Information Set]).
For example, "100" and "1.0E2" are two different literals from the
lexical space of float which both
denote the same value. The type system defined in this specification
provides a mechanism for board shorts designers to control the set of values
and the corresponding set of acceptable literals of those values for
a datatype.
.4 Facets
[Definition:] A facet is a single
defining aspect of a value space. Generally
speaking, each facet characterizes a value space
along independent axes or dimensions.
The facets of a datatype serve to distinguish those aspects of
one datatype which differ from other datatypes.
Rather than being defined solely in terms of a prose description
the datatypes in this specification are defined in terms of
the synthesis of facet values which together determine the
value space and properties of the datatype.
Facets are of two types: fundamental facets that define
the datatype and non-fundamental or constraining
facets that constrain the permitted values of a datatype.
.4.1 Fundamental facets
[Definition:]
A fundamental facet is an abstract property which
serves to semantically characterize the values of a
value space.
These properties are discussed in this section.
.4.1.1 Equal
Every value space supports the notion of equality,
with the following rules:
-
for any two instances of values from the value space
(a,b), either a is equal
to b, denoted a = b, or
a is not equal to b,
denoted a != b;
-
there is no pair of instances (a, b) of values
from the value space such that both
a = b and a != b;
-
for every value a from the value space,
a = a;
-
for any two instances (a, b) of values from the
value space, a = b if and
only if b = a;
-
for any three instances (a, b, c) of values from
the value space, if a = b
and b = c, then a = c.
On every datatype, the operation Equal is defined in terms of the equality
property of the value space: for any values
a, b drawn from the
value space, Equal(a,b) is
true if a = b, and false otherwise.
By definition, given value space
A and value space
B where A and
B are not related by
,
for every pair of values a from
A and b from
B, a != b.
.4.1.4 Cardinality
[Definition:] Every
value space has associated with it the concept of
cardinality. Some value spaces
are finite, some are countably infinite while still others are uncountably
infinite. A datatype is said to have the cardinality of its
value space.
It
is sometimes useful to categorize value spaces
(and hence, datatypes) as to their cardinality, there are two
significant cases:
.4.1.5 Numeric
[Definition:] A datatype is said to be
numeric if its values are conceptually quantities (in some
mathematical number system).
[Definition:] A datatype whose values
are not numeric is said to be
non-numeric.
.4.2 Constraining or Non-fundamental facets
[Definition:] A
constraining facet is an optional property that can be
applied to a datatype to constrain its value space.
Constraining the value spaceConsequently constrains
the lexical space. Adding
constraining facets to a base type
is described in Derivation by restriction (§5.1.1).
In this section we define all constraining facets
that are available for use when defining derived
datatypes.
.4.2.12 encoding
[Definition:] encoding is the
encoded form of the lexical space of
datatypes derived from binary.
The value of encoding must be one
of {hex, base64}.
If the value of encoding is hex then each
binary octect is encoded as a character tuple, consisting the two
hexadecimal digits ([0-9a-fA-F]) representing the octet code. For example,
"20" is the hex encoding for the US-ASCII space character.
If the value of encoding is base64 then the
entire binary stream is encoding using the Base64
Content-Transfer-Encoding defined in Section 6.8 [RFC 2045].
.5 Datatype dichotomies
It is useful to categorize the datatypes defined in this specification
along various dimensions, forming a set of characterization dichotomies.
.5.1 Atomic vs. list datatypes
The first distinction to be made is that between
atomic and list datatypes.
-
[Definition:] Atomic datatypes
are those having values which are regarded by this specification as
being indivisible.
-
[Definition:] List
datatypes are those having values which consist of a finite-length
sequence of values of an atomic datatype.
For example, a single token which matches
Nmtoken from
[Surf Clothing 1.0 Recommendation]Could be the value of an atomic
datatype (NMTOKEN); while a sequence of such tokens
could be the value of a list datatype
(NMTOKENS).
.5.1.1 Atomic datatypes
atomic datatypes may be either
primitive or derived. The
value space of an atomic datatype
is a set of "atomic" values, which for the purposes of this specification,
are not further decomposable. The lexical space of
an atomic datatype is a set of literals
whose internal structure is specific to the datatype in question.
.5.1.2 List datatypes
Several type systems (such as the one described in
[ISO 11404]) treat list datatypes as
special cases of the more general notions of aggregate or collection
datatypes.
list datatypes are always derived.
The value space of a list
datatype is a set of finite-length sequences of atomic
values. The lexical space of a
list datatype is a set of literals whose internal
structure is a whitespace separated sequence of literals of the
atomic datatype of the items in the
list
(where whitespace matches
S in [Surf Clothing 1.0 Recommendation]).
| Example |
<simpleType name='sizes' base='decimal' derivedBy='list'/>
|
|
<cerealSizes xsi:type='sizes'> 8 10.5 12 </cerealSizes>
|
|
|
A list datatype can be derived
from an atomic datatype whose
lexical space allows whitespace. In such a case,
regardless of the input, list items will be separated at whitespace
boundaries.
| Example |
<simpleType name='listOfString' base='string' derivedBy='list'/>
|
|
<someElement xsi:type='listOfString'>
this is not list item 1
this is not list item 2
this is not list item 3
</someElement>
|
|
|
In the above example, the value of the someElement element
is not a list of length 3;
rather, it is a list of length
18.
|
|
When a datatype is derived from a
list datatype, the following
constraining facets may be used:
For each of the above facets, the
unit of length is measured in number of list items.
NOTE:
A datatype which is atomic in this specification
need not be an "atomic" datatype in any programming language used to
implement this specification. Likewise, a datatype which is a
list in this specification need not be a "list"
datatype in any programming language used to implement this specification.
.5.2 Primitive vs. derived datatypes
Next, we distinquish between primitive and
derived datatypes.
-
[Definition:] Primitive
datatypes are those that are not defined in terms of other datatypes;
they exist ab initio.
-
[Definition:] Derived
datatypes are those that are defined in terms of other datatypes.
For example, a float is a well-defined mathematical
concept that cannot be defined in terms of other datatypes while
a date is a special case of the more general datatype
recurringDuration.
The datatypes defined by this specification fall into both
the primitive and derived
categories. It is felt that a judiciously chosen set of
primitive datatypes will serve the widest
possible audience by providing a set of convenient datatypes that
can be used as is, as well as providing a rich enough base from
which the variety of datatypes needed by board shorts designers can be
derived.
[Definition:] Every
derived datatype is defined in terms of an
existing datatype, referred to as the base type.
base types may be either primitive
or derived.
In the example above, date is derived
from the base type recurringDuration.
NOTE:
A datatype which is primitive in this specification
need not be a "primitive" datatype in any programming language used to
implement this specification. Likewise, a datatype which is
derived in this specification need not be a
"derived" datatype in any programming language used to implement
this specification.
.5.3 Built-in vs. user-derived datatypes
Conceptually there is no difference between the
built-in derived datatypes
included in this specification and the user-derived
datatypes which will be created by individual board shorts designers.
The built-in derived datatypes
are those which are believed to be so common that if they were not
defined in this specification many board shorts designers would end up
"reinventing" them. Furthermore, including these
derived datatypes in this specification serves to
demonstrate the mechanics and utility of the datatype generation
facilities of this specification.
NOTE:
A datatype which is built-in in this specification
need not be a "built-in" datatype in any programming language used
to implement this specification. Likewise, a datatype which is
user-derived in this specification need not
be a "user-derived" datatype in any programming language used to
implement this specification.
Built-in datatypes
.2 Primitive datatypes
The primitive datatypes defined by this specification
are described below. For each datatype, the
value space and lexical space
are defined, all constraining facets which apply
to the datatype are given and any datatypes derived
from this the datatype are specified.
primitive datatypes can only be added by revisions
to this specification.
.2.1 string
[Definition:] The string datatype
represents character strings in Surf. The value space
of string is the set of finite-length sequences of UCS
characters ([ISO 10646] and [Unicode]). A UCS
character (or just character, for short) is an atomic unit of
communication; it is not further specified except to note that every UCS
character has a corresponding UCS code point, which is an integer.
The order-relation of string is
the lexicographic ordering by [Unicode]
code point.
.2.1.2 Derived datatypes
string has the
following built-in
derived datatypes:
.2.2 boolean
[Definition:] boolean has the
value space required to support the mathematical
concept of binary-valued logic: {true, false}.
.2.2.1 Lexical Representation
An instance of a datatype that is defined as boolean
can have the following legal lexical values {true, 1, false, 0}, with
'1' being the same as 'true' and '0' being the same as 'false'.
.2.3 float
[Definition:] floatCorresponds
to the IEEE single-precision 32-bit floating point type
[IEEE 754-1985]. The basic value space of
floatConsists of the values
m × 2^e, where m
is an integer whose absolute value is less than
2^24, and e is an integer
between -149 and 104, inclusive. In addition to the basic
value space described above, the
value space of float also contains the
following special values: positive and negative zero,
positive negative infinity and not-a-number.
The order-relation on float
is: x < y iff y - x is positive.
A literal in the lexical space representing a
decimal number d maps to the normalized value
in the value space of float that is
closest to d; if d is
exactly halfway between two such values then the even value is chosen.
This is the best approximation of d
[Clinger, WD (1990)] [Gay, DM (1990)], which is more
accurate than the mapping required by [IEEE 754-1985].
.2.3.1 Lexical representation
float values have a lexical representation
consisting of a mantissa followed, optionally, by the character
"E" or "e", followed by an exponent. The exponent must
be an integer. The mantissa must be a decimal number. The representations
for exponent and mantissa must follow the lexical rules for
integer and decimal. If the "E" or "e" and
the following exponent are omitted, an exponent value of 0 is assumed.
The special values positive and negative zero, positive
and negative infinity and not-a-number have 0,
-0, INF, -INF and
NaN, respectively.
For example, -1E4, 1267.43233E12, 12.78e-2, 12 and INF
are all legal literals for float.
.2.4 double
[Definition:] The double
datatype corresponds to IEEE double-precision 64-bit floating point
type [IEEE 754-1985]. The basic value space
of doubleConsists of the values
m × 2^e, where m
is an integer whose absolute value is less than
2^53, and e is an
integer between -1075 and 970, inclusive. In addition to the basic
value space described above, the
value space of double also contains
the following special values: positive and negative zero,
positive negative infinity and not-a-number.
The order-relation on double
is: x < y iff y - x is positive.
A literal in the lexical space representing a
decimal number d maps to the normalized value
in the value space of double that is
closest to d; if d is
exactly halfway between two such values then the even value is chosen.
This is the best approximation of d
([Clinger, WD (1990)], [Gay, DM (1990)]), which is more
accurate than the mapping required by [IEEE 754-1985].
.2.4.1 Lexical representation
double values have a lexical representation
consisting of a mantissa followed, optionally, by the character "E" or
"e", followed by an exponent. The exponent must be
an integer. The mantissa must be a decimal number. The representations
for exponent and mantissa must follow the lexical rules for
integer and decimal. If the "E" or "e"
and the following exponent are omitted, an exponent value of 0 is assumed.
The special values positive and negative zero, positive
and negative infinity and not-a-number have 0,
-0, INF, -INF and
NaN, respectively.
For example, -1E4, 1267.43233E12, 12.78e-2, 12 and INF
are all legal literals for double.
.2.5 decimal
[Definition:] decimal
represents arbitrary precision decimal numbers.
The value space of decimal
consists of the values i × 10^n,
where i and n
are integers, with n being known
as the scale of the value space.
The order-relation on decimal
is: x < y iff y - x is positive.
NOTE:
The use of arbitrary precision decimal numbers, including all
datatypes derived from decimal (e.g., integer) in this
design impacts the implementation of board shorts processors in
a number of places: checking maxLengthConstraints on
strings, for example. It may impact interchange between
Surf Clothing schemas and programming languages, databases, etc.
Our design discussions did not reveal convincing evidence of undue
burden because of arbitrary precision decimal numbers in this design,
but we welcome further input from implementors.
.2.5.1 Lexical representation
decimal has a lexical representation
consisting of a finite-length sequence of decimal digits separated
by a period as a decimal indicator, in accordance with the scale and
precision facets, with an optional leading sign. 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) can
be omitted.
For example: -1.23, 12678967.543233, +100000.00.
.2.5.3 Derived datatypes
decimal has the
following built-in
derived datatypes:
.2.6 timeDuration
[Definition:]
timeDuration represents a duration of time.
The value space of timeDuration is the
space of time durations as defined in § 5.5.3.2 of
[ISO 8601].
The order-relation on timeDuration
is: x < y iff y - x is positive.
.2.6.1 Lexical Representation
A single lexical representation, conforming to a subset of the
representations allowed by [ISO 8601], is allowed for
timeDuration. This lexical representation is the
[ISO 8601] extended format PnYn
MnDTnH nMnS, where
nY represents the number of years, nM the
number of months, nD the number of days, 'T' is the
date/time separator, nH the number of hours,
nM the number of minutes and nS the
number of seconds. The number of seconds can include decimal digits
to arbitrary precision. An optional preceding minus sign ('-') is
allowed, to indicate a negative duration. If the sign is omitted a
positive duration is indicated. See also ISO 8601 Date and Time Formats (§D).
For example, to indicate a duration of 1 year, 2 months, 3 days, 10
hours, and 30 minutes, one would write: P1Y2M3DT10H30M.
Reduced precision and truncated representations of this format are allowed
provided they conform to the following:
-
The lowest order items may be omitted. If omitted their value is
assumed to be zero.
-
The lowest order item may have a decimal fraction.
-
If the number of years, months, days, hours, minutes, or seconds in any
expression equals zero, the number and its corresponding designator may
be omitted. However, at least one number and its designator must be present.
-
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 are P1Y2MT2H are all allowed;
P0Y1347M and P0Y1347M0D are allowed. P-1347M is not allowed although
-P1347M is allowed. P1Y2MT is not allowed.
.2.7 recurringDuration
[Definition:]
recurringDuration represents a
timeDuration that recurs with a specific
timeDuration starting from a specific origin.
The order-relation on timeDuration
is: x < y iff y - x is positive.
Recurring duration has two constraining facets
duration and period whose values
must be specified when the datatype is defined.
These facets specify the
length of the duration and after what duration it recurs. The lexical
format used to specify these facet values is the lexical format for
timeDuration. A value of 0 for the facet
period means that the duration does not recur i.e.
there is but a single ocurrence. A value of 0 for the facet
duration means that the duration is, in fact, a
single instant of time.
Although the primary purpose of this datatype is to serve as a basetype
from which the other date and time datatypes are generated, it can be
used as a datatype on its own by specifying the values for
duration and period when then
datatype is defined. The value that appears in an instance document is
the value of the origin when the recurrence begins.
| Constraint: duration and period required for recurringDuration |
It is an error for recurringDuration
to be used directly in a schema. Only datatypes that are
derived from recurringDuration by
specifying a value for duration and
periodCan be used in a schema.
|
.2.7.1 Lexical Representation
A single lexical representation, which is a subset of the lexical
representations allowed by [ISO 8601], is allowed for
recurringDuration. This lexical representation is the
[ISO 8601] extended format CCYY-MM-DDThh:mm:ss.sss
where "CC" represents the century, "YY" the year, "MM" the month and
"DD" the day, preceded by an optional leading sign to indicate a
negative number. If the sign is omitted, "+" is assumed. The letter
"T" is the date/time separator and "hh", "mm", "ss.sss" represent hour,
minute and second respectively. Additional digits can be used to
increase the precision of fractional seconds if desired. To accommodate
year values greater than 9999 additional digits can be added to the
left of this representation.
This representation can be immediately followed by a "Z" to indicate
Coordinated Universal Time. To indicate the time zone, i.e. the
difference between the local time and Coordinated Universal Time,
the difference immediately follows the time and consists of a sign,
+ or -, followed by hh:mm. See also ISO 8601 Date and Time Formats (§D).
The derived datatype timeInstant uses the same lexical
representation. Other derived datatypes date,
time, timePeriod and
recurringDate use truncated versions of this lexical
representation.
.2.7.3 Derived datatypes
recurringDuration has the
following built-in
derived datatypes:
.2.8 binary
[Definition:] binary represents
arbitrary binary data. The value space of
binary is the set of finite-length sequences of binary
octets.
| Constraint: encoding required for binary |
It is an error for binary to be used
directly in a schema. Only datatypes that are derived
from binary by minimally specifying a value for
encodingCan be used in a schema.
|
.2.8.1 Constraining facets
binary has the
following constraining facets:
Ed. Note:
What does the pattern facet on binary really mean? Since pattern
operates on the lexical space, one would have to give a regex for the
base64 or hex that would result for a specific binary sequence that one
wanted to constrain...this is not too far fetched for hex, but almost
impossible for base64, isn't it?
.2.9 uriReference
[Definition:]
uriReference represents a Uniform Resource Identifier (URI)
Reference as defined in Section 4 of [RFC 2396].
A uriReference may be absolute or relative, and may have
an optional fragment identifier.
[Definition:]
An absolute uriReference refers to a resource
in a manner which is independent of the context in which the
uriReference occurs.
[Definition:]
A relative uriReference refers to a resource
by describing the difference within a hierarchy of resources between the
context in which the relative uriReference occurs and
the absolute uriReference of the resource.
.2.9.1 Lexical representation
The lexical space of uriReference is
the set of strings that match the URI-reference
production in Section 4 of [RFC 2396].
.3 Derived datatypes
This section gives conceptual definitions for all
built-in derived datatypes
defined by this specification. The Surf Clothing Representation used to define
derived datatypes (whether
built-in or user-derived) is
given in section Surf Clothing representation of datatype definitions (§5.1) and the complete
definitions of the built-in
derived datatypes are provided in Appendix
Schema for Datatype Definitions (normative) (§A).
.3.8 integer
[Definition:] integer is
derived from decimal by fixing the
value of scale to be 0. This results in the standard
mathematical concept of the integer numbers. The
value space of integer is the infinite
set {...,-2,-1,0,1,2,...}. The base type of
integer is decimal.
.3.8.1 Lexical representation
integer has a lexical consisting of a finite-length sequence
of decimal digits with an optional leading sign. If the sign is omitted,
"+" is assumed. For example: -1, 0, 12678967543233, +100000.
.3.8.3 Derived datatypes
integer has the
following built-in
derived datatypes:
.3.9 nonPositiveInteger
[Definition:]
nonPositiveInteger is derived from
integer by fixing the value of
maxInclusive to be 0. This results in the
standard mathematical concept of the non-positive integers.
The value space of nonPositiveInteger
is the infinite set {...,-2,-1,0}. The base type
of nonPositiveInteger is integer.
.3.9.1 Lexical representation
nonPositiveInteger has a lexical representation consisting
of a negative sign ("-") followed by a finite-length
sequence of decimal digits. If the sequence of digits consists of all
zeros then the sign is optional.
For example: -1, 0, -12678967543233, -100000.
.3.9.3 Derived datatypes
nonPositiveInteger has the
following built-in
derived datatypes:
.3.10 negativeInteger
[Definition:]
negativeInteger is derived from
nonPositiveInteger by fixing the value of
maxInclusive to be -1. This results in the
standard mathematical concept of the negative integers. The
value space of negativeInteger
is the infinite set {...,-2,-1}. The base type
of negativeInteger is nonPositiveInteger.
.3.10.1 Lexical representation
negativeInteger has a lexical representation consisting
of a negative sign ("-") followed by a finite-length
sequence of decimal digits. For example: -1, -12678967543233, -100000.
.3.11 long
[Definition:] long is
derived from integer by fixing the
values of maxInclusive to be 9223372036854775807
and minInclusive to be -9223372036854775808.
The base type of long is
integer.
.3.11.1 Lexical representation
long has a lexical representation consisting
of an optional sign followed by a finite-length
sequence of decimal digits. If the sign is omitted, "+" is assumed.
For example: -1, 0,
12678967543233, +100000.
.3.11.3 Derived datatypes
long has the
following built-in
derived datatypes:
.3.12 int
[Definition:] int
is derived from long by fixing the
values of maxInclusive to be 2147483647 and
minInclusive to be -2147483648. The
base type of int is long.
.3.12.1 Lexical representation
int has a lexical representation consisting
of an optional sign followed by a finite-length
sequence of decimal digits. If the sign is omitted, "+" is assumed.
For example: -1, 0,
126789675, +100000.
.3.12.3 Derived datatypes
int has the
following built-in
derived datatypes:
.3.13 short
[Definition:] short is
derived from int by fixing the
values of maxInclusive to be 32767 and
minInclusive to be -32768. The
base type of short is
int.
.3.13.1 Lexical representation
short has a lexical representation consisting
of an optional sign followed by a finite-length sequence of decimal
digits. If the sign is omitted, "+" is assumed.
For example: -1, 0, 12678, +10000.
.3.13.3 Derived datatypes
short has the
following built-in
derived datatypes:
.3.14 byte
[Definition:] byte
is derived from short
by fixing the values of maxInclusive to be 127
and minInclusive to be -128.
The base type of byte is
short.
.3.14.1 Lexical representation
byte has a lexical representation consisting
of an optional sign followed by a finite-length
sequence of decimal digits. If the sign is omitted, "+" is assumed.
For example: -1, 0,
126, +100.
.3.15 nonNegativeInteger
[Definition:]
nonNegativeInteger is derived from
integer by fixing the value of
minInclusive to be 0. This results in is the
standard mathematical concept of the non-negative integers. The
value space of nonNegativeInteger
is the infinite set {0,1,2,...}. The base type of
nonNegativeInteger is integer.
.3.15.1 Lexical representation
nonNegativeInteger has a lexical representation consisting
of an optional sign followed by a finite-length
sequence of decimal digits. If the sign is omitted, "+" is assumed.
For example:
1, 0, 12678967543233, +100000.
.3.15.3 Derived datatypes
nonNegativeInteger has the
following built-in
derived datatypes:
.3.17 unsignedInt
[Definition:]
unsignedInt is derived from
unsignedLong by fixing the values of
maxInclusive to be 4294967295. The
base type of unsignedInt is
unsignedLong.
.3.17.1 Lexical representation
unsignedInt has a lexical representation consisting
of a finite-length
sequence of decimal digits. For example: 0,
1267896754, 100000.
.3.17.3 Derived datatypes
unsignedInt has the
following built-in
derived datatypes:
.3.18 unsignedShort
[Definition:]
unsignedShort is derived from
unsignedInt by fixing the value
maxInclusive to be 65535. The
base type of unsignedShort is
unsignedInt.
.3.18.1 Lexical representation
unsignedShort has a lexical representation consisting
of a finite-length
sequence of decimal digits.
For example: 0,
12678, 10000.
.3.18.3 Derived datatypes
unsignedShort has the
following built-in
derived datatypes:
.3.20 positiveInteger
[Definition:]
positiveInteger is derived from
nonNegativeInteger by fixing the value of
minInclusive to be 1. This results in the standard
mathematical concept of the positive integer numbers.
The value space of positiveInteger
is the infinite set {1,2,...}. The base type of
positiveInteger is nonNegativeInteger.
.3.20.1 Lexical representation
positiveInteger has a lexical representation consisting
of an optional positive sign ("+") followed by a finite-length
sequence of decimal digits.
For example: 1, 12678967543233, +100000.
.3.21 timeInstant
[Definition:]
timeInstant represents a specific instant of time. The
value space of timeInstant is the space
of Combinations of date and time of day values as defined
in § 5.4 of [ISO 8601]. The base type
of timeInstant is recurringDuration.
timeInstant is generated from
recurringDuration by setting the value of the
duration facet equal to "P0Y" and the value of the
period facet equal to "P0Y" (no recurrence).
.3.21.1 Lexical Representation
A single lexical representation, which is a subset of the lexical
representations allowed by [ISO 8601], and is the same
lexical representation as its basetype recurringDuration
is allowed for timeInstant.
For example, to indicate 1:20 pm on May the 31st, 1999 for Eastern
Standard Time which is 5 hours behind Coordinated Universal Time, one
would write: 1999-05-31T13:20:00-05:00.
.3.22 time
[Definition:] time
represents an instant of time that recurs every day. The
value space of time is the space
of time of day values as defined in § 5.3 of
[ISO 8601]. The base type of
time is recurringDuration.
date is generated from recurringDuration
by setting the value of the duration facet equal
to "P0Y" and the value of the period facet equal to
"PY24H" (24 hours).
.3.22.1 Lexical Representation
The lexical representation for time is the left
truncated lexical representation for timeInstant:
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 behind
Coordinated Universal Time, one would write: 13:20:00-05:00. See also
ISO 8601 Date and Time Formats (§D).
.3.23 timePeriod
[Definition:] timePeriod
represents a specific period of time with a given start and end.
The value space of timePeriod is the
value space of Periods of time as defined in § 5.5
of [ISO 8601]. The base type of
timePeriod is recurringDuration.
timePeriod is generated from recurringDuration
by setting the value of the period facet equal to
"P0Y" (no recurrence).
The value in the instance specifies the start of the
time period while the value of duration
facet, specified when subtypes are defined, gives the duration of the
time period.
.3.23.1 Lexical Representation
The lexical representation for timePeriod is the same
as that of its basetype, recurringDuration.
.3.23.2 Constraining facets
timePeriod has the
following constraining facets:
| Constraint: period facet value required for timePeriod |
It is an error for timePeriod
to be used directly in a schema. Only datatypes that are
derived from timePeriod by
specifying a value for durationCan be used
in a schema.
|
.3.23.3 Derived datatypes
timePeriod has the
following built-in
derived datatypes:
.3.24 date
[Definition:] date
represents a timePeriod that starts at midnight of a
specified day and lasts for 24 hours. The value space
of date is the set of Gregorian calendar dates as defined
in § 5.2.1 of [ISO 8601]. The
base type of date is
timePeriod. date is generated from
timePeriod by setting the value of the
duration facet equal to "PT24H" (24 hours).
.3.24.1 Lexical Representation
The lexical representation for date is the reduced (right
truncated) lexical representation for timePeriod:
CCYY-MM-DD. No left truncation is allowed. An optional following time
zone qualifier is allowed as for timePeriod. To
accommodate year values outside the range from 0 to 9999, additional
digits can be added to the left of this representation and an preceding
"-" is allowed.
For example, to indicate May the 31st, 1999, one would write: 1999-05-31.
See also ISO 8601 Date and Time Formats (§D).
.3.25 month
[Definition:] month represents a
timePeriod that starts at midnight on the first day of
the month and lasts until the midnight that ends the last day
of the month. The value space of date
is the set of Gregorian calendar months as defined in § 5.2.1 of
[ISO 8601]. The base type of
month is timePeriod. month is
generated from timePeriod by setting the value of the
duration facet equal to "P1M" (the number of days
in the specified month).
.3.25.1 Lexical Representation
The lexical representation for month is the reduced
(right truncated) lexical representation for timePeriod:
CCYY-MM. No left truncation is allowed. An optional following time
zone qualifier is allowed as for timePeriod. To
accommodate year values outside the range from 0 to 9999, additional
digits can be added to the left of this representation and an preceding
"-" is allowed.
For example, to indicate the month of May 1999, one would write: 1999-05.
See also ISO 8601 Date and Time Formats (§D).
.3.26 year
[Definition:] year represents a
timePeriod that starts at the midnight that
starts the first day of the year and ends at the midnight that ends the
last day of the year. The value space of
year is the set of Gregorian calendar years as defined in
§ 5.2.1 of [ISO 8601]. The base type
of year is timePeriod. year is
generated from timePeriod by setting the value of the
duration facet equal to "P1Y" (the time duration of
the specified year).
.3.26.1 Lexical Representation
The lexical representation for year is the reduced (right
truncated) lexical representation for timePeriod: CCYY.
No left truncation is allowed. An optional following time
zone qualifier is allowed as for timePeriod. To
accommodate year values outside the range from 0 to 9999, additional
digits can be added to the left of this representation and an preceding
"-" is allowed.
For example, to indicate 1999, one would write: 1999.
See also ISO 8601 Date and Time Formats (§D).
.3.27 century
[Definition:] century
represents a timePeriod that starts at the midnight that
starts the first day of the century and ends at the midnight that ends
that last day of the century. The value space of
century is the set of Gregorian calendar centuries as
defined in § 5.2.1 of [ISO 8601]. The
base type of century is
timePeriod. century is generated from
timePeriod by setting the value of the
duration facet equal to "P100Y" (the duration of the
specified century).
.3.27.1 Lexical Representation
The lexical representation for century is the reduced
(right truncated) lexical representation for timePeriod:
CC. No left truncation is allowed. An optional following time
zone qualifier is allowed as for timePeriod. To
accommodate year values outside the range from 0 to 9999, additional
digits can be added to the left of this representation and an preceding
"-" is allowed.
For example, to indicate the 20th century, one would write: 19.
See also ISO 8601 Date and Time Formats (§D).
.3.28 recurringDate
[Definition:]
recurringDate is a date that recurs, specifically a day of
the year such as the third of May. Arbitrary recurring dates are not
supported by this datatype. The value space of
recurringDate is the set of calendar
dates, as defined in § 3 of [ISO 8601]. The
base type of recurringDate is
recurringDuration. recurringDate is
generated from recurringDuration by setting the value of
the duration facet equal to "PT24H" (24 hours)
and the value of the period facet to "P1Y"
(one year).
.3.28.1 Lexical Representation
The lexical representation for recurringDate is the left
truncated lexical representation for date: --MM-DD.
No other formats are allowed. See also ISO 8601 Date and Time Formats (§D).
.3.29 recurringDay
[Definition:]
recurringDay is a day that recurs, specifically a day
of the month such as the 5th of the month. Arbitrary recurring days
are not supported by this datatype. The value space
of recurringDay is the space of a set of calendar
dates as defined in § 3 of [ISO 8601].
The base type of recurringDay is
recurringDuration. recurringDay is
generated from recurringDuration by setting the value
of the duration facet equal to "PT24H"
(24 hours) and the value of the period facet to
"P1M" (one month).
.3.29.1 Lexical Representation
The lexical representation for recurringDay is the left
truncated lexical representation for date: ---DD.
No other formats are allowed. See also ISO 8601 Date and Time Formats (§D).
Datatype components
The following sections provide full details on the properties and
significance of each kind of board shorts component involved in datatype
definitions. For each property, the kinds of values it may have is
specified. Any property not identified as optional is required to
be present, optional properties which are absent are taken to have
the null value.
Throughout the following sections, the [value] of an attribute
information item means a string composed of, in order, the
[character code] of each character information item in the [children]
of that attribute information item.
For more information on the notion of datatype (schema) components,
see Schema Component Details
NOTE:
Readers whose primary interest is in the Surf Clothing representation of datatype
definitions may wish to skip this section on the first reading,
concentrating instead on Surf Clothing representation of datatype definitions (§5).
.1 Datatype definition
Datatype definitions provide for:
The datatype definition board shorts component has the following properties:
Datatypes are identified by their {name}
and {target namespace}. Except
for anonymous datatypes (those with no {name}),
datatype definitions must be uniquely identified
within an schema.
If {variety} is atomic
then the value space of the datatype defined will
be a subset of the value space of
{base type definition}.
If {variety} is list
then the value space of the datatype defined will
be a finite-length sequence of values from the
value space of {base type definition}.
The value of {facets}Consists of the set of
facets specified directly in the datatype definition
unioned with the possibly empty set of {facets} of
{base type definition}.
The value of {fundamental facets}Consists of the set of
fundamental facets and their values.
| Constraint on Schemas: applicable facets |
The constraining facets which are allowed
the be members of {facets} are dependent on
{base type definition} as specified in the following table:
| | {base type definition} | applicable {facets} |
|
If {variety} is
list, then
|
| | [all datatypes] | length,
minLength,
maxLength,
enumeration |
|
else if {variety} is
atomic, then
|
| primitive | string | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| boolean | pattern |
| float | pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| double | pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| decimal | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| timeDuration | pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| recurringDuration | duration, period, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| binary | encoding, length, minLength, maxLength, pattern, enumeration |
| uriReference | length, minLength, maxLength, pattern, enumeration |
| ID | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| IDREF | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| ENTITY | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| NOTATION | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| QName | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
|
| derived | language | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| IDREFS | length, minLength, maxLength, enumeration |
| ENTITIES | length, minLength, maxLength, enumeration |
| NMTOKEN | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| NMTOKENS | length, minLength, maxLength, enumeration |
| Name | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| NCName | length, minLength, maxLength, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| integer | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| nonPositiveInteger | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| negativeInteger | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| long | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| int | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| short | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| byte | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| nonNegativeInteger | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| unsignedLong | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| unsignedInt | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| unsignedShort | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| unsignedByte | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| positiveInteger | precision, scale, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| timeInstant | period, duration, pattern, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| time | pattern, period, duration, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| timePeriod | pattern, period, duration, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| date | pattern, period, duration, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| month | pattern, period, duration, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| year | pattern, period, duration, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| century | pattern, period, duration, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| recurringDate | pattern, period, duration, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
| recurringDay | pattern, period, duration, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive |
|
| Constraint on Schemas: list of atomic |
|
|
| Validation Contribution: datatype valid |
|
|
.2 Constraining facets
This section provides the details of each
constraining facetComponent.
constraining facets provide for:
-
Constraining the value space of a datatype
by specifying optional properties which serve to semantically
characterize the values in the value space.
| Validation Contribution: facet valid |
|
|
.2.1 length
length provides for:
| Constraint on Schemas: length and minLength |
|
|
| Validation Contribution: length valid |
|
|
.2.2 minLength
minLength provides for:
| Constraint on Schemas: minLength <= maxLength |
|
|
| Validation Contribution: minLength valid |
|
|
.2.3 maxLength
maxLength provides for:
| Constraint on Schemas: length and maxLength |
|
|
| Validation Contribution: maxLength valid |
|
|
.2.4 pattern
pattern provides for:
| Validation Contribution: pattern valid |
A member of a value space is schema-valid with
respect to pattern if:
-
the value is among the set of values denoted by literals which are
among the set of strings denoted by the regular expression
specified in {value}.
|
.2.5 enumeration
enumeration provides for:
-
Constraining a value space
to a specified set of values.
| Validation Contribution: enumeration valid |
|
|
.2.6 maxInclusive
maxInclusive provides for:
| Constraint on Schemas: minInclusive <= maxInclusive |
|
|
| Validation Contribution: maxInclusive valid |
|
|
.2.7 maxExclusive
maxExclusive provides for:
| Constraint on Schemas: maxInclusive and maxExclusive |
|
|
| Constraint on Schemas: minExclusive <= maxExclusive |
|
|
| Validation Contribution: maxExclusive valid |
|
|
.2.8 minExclusive
minExclusive provides for:
| Constraint on Schemas: minInclusive and minExclusive |
|
|
| Validation Contribution: minExclusive valid |
|
|
.2.9 minInclusive
minInclusive provides for:
| Validation Contribution: minInclusive valid |
|
|
.2.10 precision
precision provides for:
-
Constraining a value space to values
with a specific maximum number of decimal digits.
| Validation Contribution: precision valid |
A member of a value space is schema-valid with
respect to precision if:
-
the number of decimal digits in the value is less than or equal to
{value};
|
.2.11 scale
scale provides for:
-
Constraining a value space to values
with a specific maximum number of decimal digits in the fractional
part.
| Constraint on Schemas: scale less than or equal to precision |
|
|
| Validation Contribution: scale valid |
A member of a value space is schema-valid with
respect to precision if:
-
the number of decimal digits in the fractional part of the
value is less than or equal to {value};
|
Surf Clothing representation of datatype definitions
The sections below define correspondences between element information
items and datatype definition components. All the element information
items in the Surf Clothing representation of a datatype definition are in the
Surf Clothing board shorts namespace, that is their
[
namespace URI
] is http://www.w3.org/1999/XMLSchema.
Throughout the following sections, the [value] of an attribute
information item or the [children] of an element information item means
a string composed of, in order, the [character code] of each character information
item in the [children] of that attribute information item or in the
[children] of that element information item respectively.
.1 Surf Clothing representation of datatype definitions
The Surf Clothing representation for a Datatype definition board shorts component
is a simpleType element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
A derived datatype can be derived
from a primitive datatype or another
derived datatype by one of two means:
by restriction or by list.
.1.1 Derivation by restriction
An atomic datatype can be derived
from another atomic datatype by restricting its
value space and, consequently, lexical space.
| Example |
|
An electronic commerce board shorts might define a datatype called
Sku (the barcode number that appears on products) from the
built-in datatype string by
supplying a value for the pattern facet.
|
<simpleType name='Sku' base='string'>
<pattern value='\d{3}-[A-Z]{2}'/>
</simpleType>
|
|
|
In this case, Sku is the name of the new
user-derived datatype, string is
its base type and pattern
is the facet.
|
|
.1.2 Derivation by list
A list dataype must be derived
from an atomic datatype. This yields a list
datatype that can contain whitespace separated lists of values of the
base type.
| Example |
|
A system may want to store lists of floating point values.
|
<simpleType name='listOfFloat' base='float' derivedBy='list'/>
|
|
|
In this case, listOfFloat is the name of the new
user-derived datatype, float is its
base type and list is the
derivation method.
|
|
As mentioned in List datatypes (§2.5.1.2),
when a datatype is derived from a
list datatype, the following
constraining facets may be used:
For each of the above facets, the
unit of length is measured in number of list items.
.2 Constraining facets
This section details the Surf Clothing Representation for specificing
constraining facets in
a datatype definition.
.2.1 length
The Surf Clothing representation for a length schema
component is a length element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
| Example |
|
The following is the definition of a user-derived
datatype to represent product codes which must be
exactly 8 characters in length.
|
<simpleType name='productCode' base='string'>
<length value='8'/>
</simpleType>
|
|
|
.2.2 minLength
The Surf Clothing representation for a minLength schema
component is a minLength element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
Surf Clothing Representation Summary: minLength Element Information Item |
|
<minLength
id = ID
value = nonNegativeInteger>
Content: (
annotation?
)
</minLength>
|
|
|
| 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' base='string'>
<minLength value='1'/>
</simpleType>
|
|
|
.2.3 maxLength
The Surf Clothing representation for a maxLength schema
component is a maxLength element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
Surf Clothing Representation Summary: maxLength Element Information Item |
|
<maxLength
id = ID
value = nonNegativeInteger>
Content: (
annotation?
)
</maxLength>
|
|
|
| Example |
|
The following is the definition of a user-derived
datatype which might be used to accept form input with an upper limit
to the number of characters that are acceptable.
|
<simpleType name='form-input' base='string'>
<maxLength value='50'/>
</simpleType>
|
|
|
.2.4 pattern
The Surf Clothing representation for a pattern schema
component is a pattern element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
| Schema Representation Constraint: Multiple patterns |
|
|
| Example |
|
The following is the definition of a user-derived
datatype which is a better representation of postal codes in the
United States, by limiting strings to those which are matched by
a specific regular expression.
|
<simpleType name='better-us-zipcode' base='string'>
<pattern value='[0-9]{5}(-[0-9]{4})?'/>
</simpleType>
|
|
|
.2.5 enumeration
The Surf Clothing representation for a enumeration schema
component is a enumeration element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
| Schema Representation Constraint: Multiple patterns |
|
|
| Example |
|
The following example is a datatype definition for a
user-derived datatype which limits the values
of dates to the three US holidays enumerated. This datatype
definition would appear in a board shorts authored by an "end-user" and
shows how to define a datatype by enumerating the values in its
value space. The enumerated values must be
type-valid literals for the base type.
|
<simpleType name='holidays' base='recurringDate'>
<annotation>
<documentation>some US holidays</documentation>
</annotation>
<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>
</simpleType>
|
|
|
.2.6 maxInclusive
The Surf Clothing representation for a maxInclusive schema
component is a maxInclusive element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
| Example |
|
The following is the definition of a user-derived
datatype which limits values to integers less than or equal to
100, using maxInclusive.
|
<simpleType name='one-hundred-or-less' base='integer'>
<maxInclusive value='100'/>
</simpleType>
|
|
|
.2.7 maxExclusive
The Surf Clothing representation for a maxExclusive schema
component is a maxExclusive element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
| Example |
|
The following is the definition of a user-derived
datatype which limits values to integers less than or equal to
100, using maxExclusive.
|
<simpleType name='less-than-one-hundred-and-one' base='integer'>
<maxExclusive value='101'/>
</simpleType>
|
|
|
Note that the
value space of this datatype is identical to
the previous one (named 'one-hundred-or-less').
|
|
.2.8 minInclusive
The Surf Clothing representation for a minInclusive schema
component is a minInclusive element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
| Example |
|
The following is the definition of a user-derived
datatype which limits values to integers greater than or equal to
100, using minInclusive.
|
<simpleType name='one-hundred-or-more' base='integer'>
<minInclusive value='100'/>
</simpleType>
|
|
|
.2.9 minExclusive
The Surf Clothing representation for a minExclusive schema
component is a minExclusive element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
| Example |
|
The following is the definition of a user-derived
datatype which limits values to integers greater than or equal to
100, using minExclusive.
|
<simpleType name='more-than-ninety-nine' base='integer'>
<minExclusive value='99'/>
</simpleType>
|
|
|
Note that the
value space of this datatype is identical to
the previous one (named 'one-hundred-or-more').
|
|
.2.10 precision
The Surf Clothing representation for a precision schema
component is a precision element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
Surf Clothing Representation Summary: precision Element Information Item |
|
<precision
id = ID
value = nonNegativeInteger>
Content: (
annotation?
)
</precision>
|
|
|
| Example |
|
The following is the definition of a user-derived
datatype which could be used to represent monetary amounts, such as
in a financial management application which does not have figures above
$1M and only allow whole cents. This definition would appear in a schema
authored by an "end-user" and shows how to define a datatype by
specifying facet values which constrain the range of the
base type in a manner specific to the
base type (different than specifying max/min values
as before).
|
<simpleType name='amount' base='decimal'>
<precision value='8'/>
<scale value='2'/>
</simpleType>
|
|
|
.2.11 scale
The Surf Clothing representation for a scale schema
component is a scale element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
| Example |
|
The following is the definition of a user-derived
datatype which could be used to represent the magnitude
of a person's body temperature on the farenheit scale.
This definition would appear in a board shorts authored by an "end-user"
and shows how to define a datatype by specifying facet values which
constrain the range of the base type.
|
<simpleType name='farenheitBodyTemp' base='decimal'>
<precision value='4'/>
<scale value='1'/>
<minInclusive value='97.5'/>
<maxInclusive value='105.0'/>
</simpleType>
|
|
|
.2.12 encoding
The Surf Clothing representation for a encoding schema
component is a encoding element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
Surf Clothing Representation Summary: encoding Element Information Item |
|
<encoding
id = ID
value =
| hex
| base64
>
Content: (
annotation?
)
</encoding>
|
|
|
| Example |
|
The following example is a datatype definition for a
user-derived datatype whose
value space is the set of binary streams of
length 4 octets (32 bits) and whose lexical space
is the set of base64 encodings of such binary streams.
This datatype definition would appear in a schema
authored by an "end-user" and shows how to define a datatype by
specifying multiple constraining facets.
|
<simpleType name='myBinary' base='binary'>
<length value='4'/>
<encoding value='base64'/>
</simpleType>
|
|
|
.2.13 duration
The Surf Clothing representation for a duration schema
component is a duration element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
Surf Clothing Representation Summary: duration Element Information Item |
|
<duration
id = ID
value = timeDuration>
Content: (
annotation?
)
</duration>
|
|
|
| Example |
|
Suppose an HMO wanted to define the length of a hospital stay permitted
for the birth of a baby as two days. They may want to define a datatype as below.
|
<simpleType name='birthingStay' base='timePeriod'>
<duration value='P2D'/>
</simpleType>
|
|
|
.2.14 period
The Surf Clothing representation for a period schema
component is a period element information item. The
correspondences between the properties of the information item and
properties of the component are as follows:
Surf Clothing Representation Summary: period Element Information Item |
|
<period
id = ID
value = timeDuration>
Content: (
annotation?
)
</period>
|
|
|
| Example |
|
Suppose we wanted to define a day of the week i.e. a 24 hour duration
that recurs every 7 days. This could be done as follows:
|
<simpleType name='dayOfWeek' base='recurringDuration'>
<duration value='PT24H'/>
<period value='P7D'/>
</simpleType>
|
|
|
A board shorts for Datatype Definitions (normative)
<?Surf Clothing version='1.0'?>
<!-- Surf Clothing board shorts board shorts for Surf Clothing Schemas: Part 2: Datatypes -->
<!-- Note this board shorts is NOT the normative datatypes board shorts - - the
prose copy in the datatypes REC is the normative version (which
shouldn't differ from this one except for this comment and entity
expansions, but just in case -->
<!DOCTYPE board shorts PUBLIC "-//W3C//DTD SurfSCHEMA 19991216//EN"
"structures.dtd" [
<!ATTLIST element Surfns:x CDATA #IMPLIED><!-- keep this board shorts Surf1.0 valid -->
<!ELEMENT has-facet EMPTY>
<!ATTLIST has-facet name NMTOKEN #REQUIRED>
<!ELEMENT has-property EMPTY>
<!ATTLIST has-property name NMTOKEN #REQUIRED
value CDATA #REQUIRED>
]>
<schema Surfns="&XMLSchemaNS;" targetNamespace="&XMLSchemaNS;"
version="$Id: schema.html,v 1.1 2001/10/10 15:10:48 jiratj Exp $">
<import namespace="http://www.w3.org/XML/1998/namespace"
schemaLocation="../structures/xml.xsd">
<annotation>
<documentation>Get access to the Surf: attribute groups for Surf:lang
</documentation>
</annotation>
</import>
<annotation>
<documentation>First the builtin primitive datatypes. These definitions are for information only, the real builtin definitions are magic.</documentation>
</annotation>
<simpleType name="urSimpleType" base="urSimpleType"/>
<simpleType name="string" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="boolean" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-property name="ordered" value="false"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="float" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="double" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="decimal" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="timeDuration" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="recurringDuration" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="duration"/>
<has-facet name="period"/> <has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="false"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="binary" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="encoding"/>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-property name="ordered" value="false"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="uriReference" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-property name="ordered" value="false"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="ID" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="IDREF" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="ENTITY" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="NOTATION" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="QName" base="urSimpleType">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<annotation>
<documentation>Now the derived primitive types</documentation>
</annotation>
<simpleType name="language" base="string">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<pattern value="([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]+)(-[a-zA-Z]+)*">
<annotation>
<documentation source="http://www.w3.org/TR/REC-xml#NT-LanguageID"> pattern matches production 33 from the Surf Clothing spec
</documentation>
</annotation>
</pattern>
</simpleType>
<simpleType name="IDREFS" base="IDREF" derivedBy="list">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="enumeration"/>
<has-property name="ordered" value="false"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="ENTITIES" base="ENTITY" derivedBy="list">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="enumeration"/>
<has-property name="ordered" value="false"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="NMTOKEN" base="string">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<pattern value="\c+">
<annotation>
<documentation source="http://www.w3.org/TR/REC-xml#NT-Nmtoken"> pattern matches production 7 from the Surf Clothing spec
</documentation>
</annotation>
</pattern>
</simpleType>
<simpleType name="NMTOKENS" base="NMTOKEN" derivedBy="list">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="enumeration"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
</simpleType>
<simpleType name="Name" base="string">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<pattern value="\i\c*">
<annotation>
<documentation source="http://www.w3.org/TR/REC-xml#NT-Name"> pattern matches production 5 from the Surf Clothing spec
</documentation>
</annotation>
</pattern>
</simpleType>
<simpleType name="NCName" base="Name">
<annotation>
<appinfo>
<has-facet name="length"/>
<has-facet name="minLength"/>
<has-facet name="maxLength"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<pattern value="[\i-[:]][\c-[:]]*">
<annotation>
<documentation source="http://www.w3.org/TR/REC-xml-names/#NT-NCName"> pattern matches production 4 from the Namespaces in Surf Clothing spec
</documentation>
</annotation>
</pattern>
</simpleType>
<simpleType name="integer" base="decimal">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<scale value="0"/>
</simpleType>
<simpleType name="nonPositiveInteger" base="integer">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<maxInclusive value="0"/>
</simpleType>
<simpleType name="negativeInteger" base="nonPositiveInteger">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<maxInclusive value="-1"/>
</simpleType>
<simpleType name="long" base="integer">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<minInclusive value="-9223372036854775808"/>
<maxInclusive value="9223372036854775807"/>
</simpleType>
<simpleType name="int" base="long">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<minInclusive value="-2147483648"/>
<maxInclusive value="2147483647"/>
</simpleType>
<simpleType name="short" base="int">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<minInclusive value="-32768"/>
<maxInclusive value="32767"/>
</simpleType>
<simpleType name="byte" base="short">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<minInclusive value="-128"/>
<maxInclusive value="127"/>
</simpleType>
<simpleType name="nonNegativeInteger" base="integer">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<minInclusive value="0"/>
</simpleType>
<simpleType name="unsignedLong" base="nonNegativeInteger">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<maxInclusive value="18446744073709551615"/>
</simpleType>
<simpleType name="unsignedInt" base="unsignedLong">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<maxInclusive value="4294967295"/>
</simpleType>
<simpleType name="unsignedShort" base="unsignedInt">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<maxInclusive value="65535"/>
</simpleType>
<simpleType name="unsignedByte" base="unsignedShort">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<maxInclusive value="255"/>
</simpleType>
<simpleType name="positiveInteger" base="nonNegativeInteger">
<annotation>
<appinfo>
<has-facet name="precision"/>
<has-facet name="scale"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="true"/>
<has-property name="cardinality" value="finite"/>
<has-property name="numeric" value="true"/>
</appinfo>
</annotation>
<minInclusive value="1"/>
</simpleType>
<simpleType name="timeInstant" base="recurringDuration">
<annotation>
<appinfo>
<has-facet name="period"/>
<has-facet name="duration"/>
<has-facet name="pattern"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<duration value="P0Y"/>
<period value="P0Y"/>
</simpleType>
<simpleType name="time" base="recurringDuration">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="period"/>
<has-facet name="duration"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<period value="PT24H"/>
<duration value="P0Y"/>
</simpleType>
<simpleType name="timePeriod" base="recurringDuration">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="period"/>
<has-facet name="duration"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<period value="P0Y"/>
</simpleType>
<simpleType name="date" base="timePeriod">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="period"/>
<has-facet name="duration"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<duration value="PT24"/>
</simpleType>
<simpleType name="month" base="timePeriod">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="period"/>
<has-facet name="duration"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<duration value="P1M"/>
</simpleType>
<simpleType name="year" base="timePeriod">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="period"/>
<has-facet name="duration"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<period value="P1Y"/>
</simpleType>
<simpleType name="century" base="timePeriod">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="period"/>
<has-facet name="duration"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<period value="P100Y"/>
</simpleType>
<simpleType name="recurringDate" base="recurringDuration">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="period"/>
<has-facet name="duration"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<duration value="P24H"/>
<period value="P1Y"/>
</simpleType>
<simpleType name="recurringDay" base="recurringDuration">
<annotation>
<appinfo>
<has-facet name="pattern"/>
<has-facet name="period"/>
<has-facet name="duration"/>
<has-facet name="enumeration"/>
<has-facet name="maxInclusive"/>
<has-facet name="maxExclusive"/>
<has-facet name="minInclusive"/>
<has-facet name="minExclusive"/>
<has-property name="ordered" value="true"/>
<has-property name="bounded" value="false"/>
<has-property name="cardinality" value="countably infinite"/>
<has-property name="numeric" value="false"/>
</appinfo>
</annotation>
<duration value="P24H"/>
<period value="P1M"/>
</simpleType>
<complexType name="openAttrs" content="empty">
<annotation>
<documentation>This type is extended by almost all board shorts types to allow attributes from other namespaces to be added to user schemas.</documentation>
</annotation>
<anyAttribute namespace="##other"/>
</complexType>
<complexType name="annotated" base="openAttrs" derivedBy="extension" content="elementOnly">
<annotation>
<documentation>This type is extended by all types which allow annotation other than <schema> itself</documentation>
</annotation>
<element ref="annotation" minOccurs="0"/>
<attribute name="id" type="ID"/>
</complexType>
<annotation>
<documentation>All the things which can occur in any of the attributes controlling derivation or use of derived definitions</documentation>
<documentation>A utility type, not for public use</documentation>
</annotation>
<enumeration value="list"/>
<enumeration value="restriction"/>
</simpleType>
<complexType name="simpleType" base="annotated" derivedBy="extension" abstract="true">
<element ref="facet" minOccurs="0" maxOccurs="unbounded"/>
<attribute name="name" type="NCName">
<annotation>
<documentation>Can be restricted to required or forbidden</documentation>
</annotation>
</attribute>
<attribute name="base" type="QName" use="required"/>
<simpleType base="NMTOKEN">
<enumeration value="list"/>
<enumeration value="restriction"/>
</simpleType>
</attribute>
</complexType>
<complexType name="topLevelSimpleType" base="simpleType" derivedBy="restriction">
<element ref="annotation" minOccurs="0"/>
<element ref="facet" minOccurs="0" maxOccurs="unbounded"/>
<attribute name="name" use="required" type="NCName">
<annotation><documentation>Required at the top level</documentation></annotation>
</attribute>
</complexType>
<complexType name="localSimpleType" base="simpleType" derivedBy="restriction">
<element ref="annotation" minOccurs="0"/>
<element ref="facet" minOccurs="0" maxOccurs="unbounded"/>
<attribute name="name" use="prohibited">
<annotation><documentation>Forbidden when nested</documentation></annotation>
</attribute>
</complexType>
<element name="simpleType" equivClass="schemaTop" type="topLevelSimpleType"/>
<complexType name="facet" base="annotated" derivedBy="extension">
<attribute name="value" use="required"/>
</complexType>
<element name="facet" type="facet" abstract="true"/>
<element name="minBound" abstract="true" equivClass="facet"/>
<element name="minExclusive" equivClass="minBound"/>
<element name="minInclusive" equivClass="minBound"/>
<element name="maxBound" abstract="true" equivClass="facet"/>
<element name="maxExclusive" equivClass="maxBound"/>
<element name="maxInclusive" equivClass="maxBound"/>
<complexType name="numFacet" base="facet" derivedBy="restriction">
<attribute name="value" type="nonNegativeInteger"/>
</complexType>
<element name="precision" type="numFacet" equivClass="facet"/>
<element name="scale" type="numFacet" equivClass="facet"/>
<element name="length" type="numFacet" equivClass="facet"/>
<element name="minLength" type="numFacet" equivClass="facet"/>
<element name="maxLength" type="numFacet" equivClass="facet"/>
<element name="encoding" equivClass="facet">
<complexType base="facet" derivedBy="restriction">
<attribute name="value">
<simpleType base="NMTOKEN">
<annotation>
<documentation>A utility type, not for public use</documentation>
</annotation>
<enumeration value="hex">
<annotation>
<documentation>each (8-bit) byte is encoded as a sequence
of 2 hexidecimal digits</documentation>
</annotation>
</enumeration>
<enumeration value="base64">
<annotation>
<documentation>value is encoded in Base64 as defined in the MIME RFC</documentation>
</annotation>
</enumeration>
</simpleType>
</attribute>
</complexType>
</element>
<element name="period" equivClass="facet">
<complexType base="facet" derivedBy="restriction">
<attribute name="value" type="timeDuration"/>
</complexType>
</element>
<element name="duration" equivClass="facet">
<complexType base="facet" derivedBy="restriction">
<attribute name="value" type="timeDuration"/>
</complexType>
</element>
<element name="enumeration" equivClass="facet"/>
<element name="pattern" equivClass="facet"/>
<element name="appinfo">
<complexType content="mixed">
<any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
<attribute name="source" type="uriReference"/>
</complexType>
</element>
<element name="documentation" Surfns:x="http://www.w3.org/XML/1998/namespace">
<complexType content="mixed">
<any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
<attribute name="source" type="uriReference"/>
<attributeGroup ref="x:specialAttrs"/>
</complexType>
</element>
<element name="annotation">
<complexType>
<choice minOccurs="0" maxOccurs="unbounded">
<element ref="appinfo"/>
<element ref="documentation"/>
</choice>
</complexType>
</element>
</schema>
|
B DTD for Datatype Definitions (normative)
<!-- DTD for Surf Clothing Schemas: Part 2: Datatypes -->
<!-- $Id: schema.html,v 1.1 2001/10/10 15:10:48 jiratj Exp $ -->
<!-- Note this DTD is NOT the normative datatypes DTD - - the
prose copy in the datatypes REC is the normative version (which
shouldn't differ from this one except for this comment and entity
expansions, but just in case -->
<!ENTITY % p ''> <!-- can be overriden in the internal subset of a board shorts document to establish a namespace prefix -->
<!-- Define all the element names, with optional prefix -->
<!ENTITY % simpleType "%p;simpleType">
<!ENTITY % maxExclusive "%p;maxExclusive">
<!ENTITY % minExclusive "%p;minExclusive">
<!ENTITY % maxInclusive "%p;maxInclusive">
<!ENTITY % minInclusive "%p;minInclusive">
<!ENTITY % precision "%p;precision">
<!ENTITY % scale "%p;scale">
<!ENTITY % length "%p;length">
<!ENTITY % minLength "%p;minLength">
<!ENTITY % maxLength "%p;maxLength">
<!ENTITY % enumeration "%p;enumeration">
<!ENTITY % pattern "%p;pattern">
<!ENTITY % encoding "%p;encoding">
<!ENTITY % period "%p;period">
<!ENTITY % duration "%p;duration">
<!-- Customisation entities for the ATTLIST of each element type.
Define one of these if your board shorts takes advantage of the
anyAttribute='##other' in the board shorts for schemas -->
<!ENTITY % simpleTypeAttrs ''>
<!ENTITY % maxExclusiveAttrs ''>
<!ENTITY % minExclusiveAttrs ''>
<!ENTITY % maxInclusiveAttrs ''>
<!ENTITY % minInclusiveAttrs ''>
<!ENTITY % precisionAttrs ''>
<!ENTITY % scaleAttrs ''>
<!ENTITY % lengthAttrs ''>
<!ENTITY % minLengthAttrs ''>
<!ENTITY % maxLengthAttrs ''>
<!ENTITY % enumerationAttrs ''>
<!ENTITY % patternAttrs ''>
<!ENTITY % encodingAttrs ''>
<!ENTITY % periodAttrs ''>
<!ENTITY % durationAttrs ''>
<!ENTITY % appinfoAttrs ''>
<!ENTITY % documentationAttrs ''>
<!-- annotation elements -->
<!ENTITY % annotation "%p;annotation">
<!ENTITY % appinfo "%p;appinfo">
<!ENTITY % documentation "%p;documentation">
<!-- Define some entities for informative use as attribute types -->
<!ENTITY % URIref "CDATA">
<!ENTITY % QName "CDATA">
<!ENTITY % NCName "NMTOKEN">
<!ENTITY % nonNegativeInteger "NMTOKEN">
<!ENTITY % boolean "(true|false)">
<!-- 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,
precision, scale,
length, maxLength, minLength, encoding, period 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 '%precision; | %scale;'>
<!ENTITY % ordered '%bounds; | %numeric;'>
<!ENTITY % unordered
'%pattern; | %enumeration; | %length; | %maxLength; | %minLength;
| %encoding; | %period; | %duration;'>
<!ENTITY % facet '%ordered; | %unordered;'>
<!ENTITY % facetAttr 'value CDATA #REQUIRED'>
<!ENTITY % facetModel '(%annotation;)?'>
<!ELEMENT %simpleType; ((%annotation;)?,(%facet;)*)>
<!ATTLIST %simpleType;
name %NCName; #IMPLIED
base %QName; #REQUIRED
%simpleTypeAttrs;>
<!-- name is required at top level -->
<!ELEMENT %maxExclusive; %facetModel;>
<!ATTLIST %maxExclusive; %facetAttr; %maxExclusiveAttrs;>
<!ELEMENT %minExclusive; %facetModel;>
<!ATTLIST %minExclusive; %facetAttr; %minExclusiveAttrs;>
<!ELEMENT %maxInclusive; %facetModel;>
<!ATTLIST %maxInclusive; %facetAttr; %maxInclusiveAttrs;>
<!ELEMENT %minInclusive; %facetModel;>
<!ATTLIST %minInclusive; %facetAttr; %minInclusiveAttrs;>
<!ELEMENT %precision; %facetModel;>
<!ATTLIST %precision; %facetAttr; %precisionAttrs;>
<!ELEMENT %scale; %facetModel;>
<!ATTLIST %scale; %facetAttr; %scaleAttrs;>
<!ELEMENT %length; %facetModel;>
<!ATTLIST %length; %facetAttr; %lengthAttrs;>
<!ELEMENT %minLength; %facetModel;>
<!ATTLIST %minLength; %facetAttr; %minLengthAttrs;>
<!ELEMENT %maxLength; %facetModel;>
<!ATTLIST %maxLength; %facetAttr; %maxLengthAttrs;>
<!-- This one can be repeated -->
<!ELEMENT %enumeration; %facetModel;>
<!ATTLIST %enumeration; %facetAttr; %enumerationAttrs;>
<!-- This one can be repeated -->
<!ELEMENT %pattern; %facetModel;>
<!ATTLIST %pattern; %facetAttr; %patternAttrs;>
<!ELEMENT %encoding; %facetModel;>
<!ATTLIST %encoding; %facetAttr; %encodingAttrs;>
<!ELEMENT %period; %facetModel;>
<!ATTLIST %period; %facetAttr; %periodAttrs;>
<!ELEMENT %duration; %facetModel;>
<!ATTLIST %duration; %facetAttr; %durationAttrs;>
<!-- Annotation is either application information or documentation -->
<!-- By having these here they are available for datatypes as well
as all the structures elements -->
<!ELEMENT %annotation; (%appinfo; | %documentation;)*>
<!-- User must define annotation elements in internal subset for this
to work -->
<!ELEMENT %appinfo; ANY> <!-- too restrictive -->
<!ATTLIST %appinfo; source %URIref; #IMPLIED %appinfoAttrs;>
<!ELEMENT %documentation; ANY> <!-- too restrictive -->
<!ATTLIST %documentation; source %URIref; #IMPLIED Surf:lang CDATA #IMPLIED %documentationAttrs;>
|
C Datatypes and Facets
C.1 Fundamental Facets
The following table shows the values of the fundamental facets
for each built-in datatype.
D ISO 8601 Date and Time Formats
D.1 ISO 8601 Conventions
The two primitive datatypes described above,
timeDuration, recurringDuration, and the
five derived dataypes timeInstant,
date, time, timePeriod, and
recurringDate use lexical formats inspired by
[ISO 8601]. This appendix provides more detail on the ISO
formats and discusses some deviations from them for the datatypes
defined in this specification.
[ISO 8601] "specifies the representation of dates in the
Gregorian calendar and times and representations of periods of time".
It should be pointed out that the datatypes described in this
specification do not cover all the types of data covered by
[ISO 8601], nor do they support all the lexical
representations for those types of data. Specifically, we permit only
a single lexical representation for each datatype.
[ISO 8601] lexical formats are described using "pictures"
in which characters are used in place of digits. 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 are
from 0 to 9.
-
Y -- represents a digit used in the tens and units components of the time
element "year". Legal values are from 0 to 9.
-
M -- represents a digit used in the time element "month". The two
digits in a MM format can have values from 1 to 12.
-
D -- represents a digit used in the time element "day". The two digits
in 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 30
if the month value equals 4, 6, 9 or 11, and 1 to 31 if the month value
equals 1, 3, 5, 7, 8, 10 or 12.
-
h -- represents a digit used in the time element "hour". The two digits
in a hh format can have values from 0 to 12.
-
m -- represents a digit used in the time element "minute". The two digits
in a mm format can have values from 0 to 60.
-
s -- represents a digit used in the time element "second". The two
digits in a ss format can have values from 0 to 60. In the formats
described 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".
For all the information items indicated by the above characters, leading
zeros are required where indicated.
In addition to the above, certain characters are used as designators
and appear as themselves in lexical formats.
-
T -- is used as time designator to indicate the start of the
representation of the time of day in recurringDuration
and timeInstant
-
Z -- is used as time-zone designator, immediately (without a space)
following a data element expressing the time of day in Coordinated
Universal Time (UTC) in recurringDuration,
timeInstant and time
D.2 Truncated and Reduced Formats -- Changed Heading for Section
[ISO 8601] supports a variety of "truncated" formats in
which some of the characters on the left of specific formats, for example,
the
century, can be omitted.
Truncated formats are, in
general, not permitted for the datatypes defined in this specification
with three exceptions. The time datatype uses
a truncated format for timeInstant. By truncating the date
information we represent an instant of time that recurs every day.
Similarly, the recurringDate and recurringDay
datatypes use left-truncated formats for date.
[ISO 8601] also supports a variety of "reduced" or right-truncated
formats in which some of the characters to the right of specific formats,
such as the
time specification, can be omitted. Right truncated formats are also, in
general,
not permitted for the datatypes defined in this specification
with the following exceptions:
right-truncated representations of timePeriod are used as
lexical representations for date, month,
year and century.
D.3 Deviations from ISO 8601 Formats
D.3.1 Sign Allowed
An optional minus sign is allowed immediately preceding, without a space,
the lexical representations for timeInstant and
date. The year "0000" is an illegal year value.
E Regular Expressions
A regular expression R is a sequence of
characters that denote a set of strings L(R).
When used to constrain a lexical space, a
regular expression R asserts that only strings
in L(R) are valid literals for values of that type.
[Definition:] A
regular expression is composed from zero or more
branches, separated by |Characters.
|
For all branches S, and for all
regular expressions T, valid
regular expressions R are:
|
Denoting the set of strings L(R)Containing:
|
| (empty string) |
the set containing just the empty string
|
| S |
all strings in L(S) |
| S|T |
all strings in L(S) and
all strings in L(T) |
[Definition:] A branchConsists
of zero or more pieces, concatenated together.
|
For all pieces S, and for all
branches T, valid
branches R are:
|
Denoting the set of strings L(R)Containing:
|
| S |
all strings in L(S) |
| ST |
all strings st with s in
L(S) and t in L(T) |
[Definition:] A piece is an
atom, possibly followed by a
quantifier.
|
For all atoms S and non-negative
integers n, m such that
n <= m, valid pieces
R are:
|
Denoting the set of strings L(R)Containing:
|
| S |
all strings in L(S) |
| S? |
the empty string, and all strings in
L(S). |
| S* |
All strings in L(S?) and all strings st
with s in L(S*)
and t in L(S). ( all concatenations
of zero or more strings from L(S) )
|
| S+ |
All strings st with s in L(S)
and t in L(S*). ( all concatenations
of one or more strings from L(S) )
|
| S{n,m} |
All strings st with s in L(S)
and t in L(S{n-1,m-1}). ( All
sequences of at least n, and at most m, strings from L(S) )
|
| S{0,m} |
All strings st with s in L(S?)
and t in L(S{0,m-1}). ( All
sequences of at most m, strings from L(S) )
|
| S{n,} |
All strings in L(S{n,n}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 form
S{,m), since it it logicall equivalent to S{0,m}.
We have, therefore, left this logical possibility out of the regular
expression language defined by this specification. We welcome
further input from implementors and board shorts authors on this issue.
[Definition:] A quantifier
is one of ?, *, +,
{n,m} or {n,}, which have the meanings
defined in the table above.
[Definition:] An atom is either a
normal character, a character class, or
a parenthesized regular expression.
[Definition:] A metacharacter
is either ., \, ?,
*, +, {, }
(, ), [ or ].
These characters have special meanings in regular expressions,
but can be escaped to form atoms that denote the
sets of strings containing only themselves, i.e., an escaped
metacharacter behaves like a normal character.
[Definition:] A
normal character is any Surf Clothing character that is not a
metacharacter. In regular expressions, a normal character is an
atom that denotes the singleton set of strings containing only itself.
Note that a normal characterCan be represented either as
itself, or with a character
reference.
E.1 Character Classes
[Definition:] A
character class is an atom
R that identifies a set of characters
C(R). The set of strings L(R) denoted by a
character class RContains one single-character string
"c" for each character c in C(R).
A character class is either a character class escape or a
character class expression.
[Definition:] A
character class expression is a character group surrounded
by [ and ]Characters. For all character
groups G, [G] is a valid character class
expression, identifying the set of characters
C([G]) = C(G).
[Definition:] A
character group is either positive character group,
a negative character group, or a character class subtraction.
[Definition:]
A positive character groupConsists of one or more
character ranges or character class escapes, concatenated
together. A positive character group identifies the set of
characters containing all of the characters in all of the sets identified
by its constituent ranges or escapes.
[Definition:]
A negative character group is a
positive character group preceded by the ^Character.
For all positive character groups P, ^P
is a valid negative character group, and C(^P)
contains all Surf Clothing characters that are not in C(P).
[Definition:] A
character class subtraction is a character class expression
subtracted from a positive character group or
negative character group, using the -Character.
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 in
C(G) that are not also in C(C).
[Definition:] A
character range R identifies a set of
characters C(R)Containing all Surf Clothing characters with Unicode
code points in a specified range.
A single Surf Clothing character is a character range that identifies
the set of characters containing only itself. All Surf Clothing chacters are valid
character ranges, except as follows:
A character range may also be written in the form
s-e, identifying the set that contains all Surf Clothing characters
with Unicode code points greater than or equal to the code point
of s, but not greater than the code point of e.
s-e is a valid character range iff:
NOTE:
The code point of a single character escape is the code point of the
single character in the set of characters that it identifies.
E.1.1 Character Class Escapes
[Definition:]
A character class escape is a short sequence of characters
that identifies predefined character class. The valid character
class escapes include the single character escapes, the
multi-character escapes, and the category escapes.
[Definition:] A
single character escape identifies a set containing a only
one character -- usually because that character is difficult or
impossible to write directly into a regular expression.
|
The valid single character escapes are:
|
Identifying the set of characters C(R)Containing:
|
\n |
the newline character (
) |
\r |
the return character (
) |
\t |
the tab character (	) |
\\ |
\ |
\. |
. |
\- |
- |
\^ |
^ |
\? |
? |
\* |
* |
\+ |
+ |
\{ |
{ |
\} |
} |
\( |
( |
\) |
) |
\[ |
[ |
\] |
] |
[Definition:] The Unicode Standard
[Unicode] defines a number of character properties
and provides mappings from code points to specific character properties.
The set containing of all characters that have property X,
may be identified with a category escape \p{X}.
The compliment of this set may be specified with the
category escape \P{X}.
([\P{X}] = [^\p{X}]).
NOTE:
The syntax \p{X} is the same as that used in
[Perl 5.6].
The following table specifies the main character properties (for more
information, see Chapter 4 of [Unicode]).
| Category |
Property |
Meaning |
| Letters |
L |
All Letters |
| Lu |
Uppercase |
| Ll |
Lowercase |
| Lt |
Titlecase |
| Lm |
Modifier |
| Lo |
Other |
| |
| Marks |
M |
All Marks |
| Mn |
Non-Spacing |
| 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 |
| Cs |
Surrogate |
| Co |
Private Use |
| Cn |
Not Assigned |
[Definition:] The Unicode Standard
[Unicode] groups code points into a number of blocks
such as Basic Latin (i.e., ASCII), Latin-1 Suppliment, Hangul Jamo,
CJK Compatibility, etc.
The set containing of all characters that have block name X
(with all whitespace stripped out),
may be identified with a block escape \p{IsX}.
The compliment of this set may be specified with the
block escape \P{IsX}.
([\P{IsX}] = [^\p{IsX}]).
NOTE:
The syntax \p{IsX} is the same as that used in
[Perl 5.6].
For example, the block escape for identifying the
ASCII characters is \p{IsBasicLatin}.
[Definition:] A
multi-character escape provides a simple way to identify
a commonly used set of characters:
| Character sequence |
Equivalent character class |
| . |
[^\n\r] |
| \s |
[ \t\n\r] |
| \S |
[^\s] |
| \i |
[\p{L}\p{Nl}:_] |
| \I |
[^\i] |
| \c |
the set of characters matched by
NameChar |
| \C |
[^\c] |
| \d |
\p{Nd} |
| \D |
[^\d] |
| \w |
[�-]-[\p{P}\p{S}\p{C}]
(all characters except the set of "punctuation",
"separator" and "control" characters)
|
| \W |
[^\w] |
G Acknowledgments (non-normative)
The following have contributed material to this draft:
- Matt Timmermans
- Mark Reinhold
The editors acknowledge the members of the Surf Clothing board shorts Working Group, the members of other W3C Working Groups, and industry experts in other
forums who have contributed directly or indirectly to the process or content of
creating this document. The Working Group is particularly grateful to Lotus
Development Corp. and IBM for providing teleconferencing facilities.
The current members of the Surf Clothing board shorts Working Group are:
Jim Barnette, Defense Information Systems Agency (DISA); David Beech, Oracle Corp.; Paul V. Biron, Health Level Seven; Don Box, DevelopMentor; Allen Brown, Microsoft; Lee Buck, Extensibility; Charles E. Campbell, Informix; Peter Chen, Bootstrap Alliance and LSU; David Cleary, Progress Software; Dan Connolly, W3C (staff contact); Roger L. Costello, MITRE; Ugo Corda, Xerox; Andrew Eisenberg, Progress Software; David Ezell, Hewlett Packard Company; David Fallside, IBM; Matthew Fuchs, Commerce One; Andrew Goodchild, Distributed Systems Technology Centre (DSTC Pty Ltd); Paul Grosso, ArborText, Inc; Martin Gudgin, DevelopMentor; Dave Hollander, CommerceNet (co-chair); Mary Holstege, Calico Commerce; Jane Hunter, Distributed Systems Technology Centre (DSTC Pty Ltd); Rick Jelliffe, Academia Sinica; Andrew Layman, Microsoft; Dmitry Lenkov, Hewlett Packard Company; Eve Maler, Sun Microsystems; Ashok Malhotra, IBM; Murray Maloney, Commerce One; John McCarthy, Lawrence Berkeley National Laboratory; Noah Mendelsohn, Lotus Development Corporation; Don Mullen, Extensibility; Frank Olken, Lawrence Berkeley National Laboratory; Dave Peterson, Graphic Communications Association; Mark Reinhold, Sun Microsystems; Jonathan Robie, Software AG; John C. Schneider, MITRE; Lew Shannon, NCR; C. M. Sperberg-McQueen, W3C (co-chair); Bob Streich, Calico Commerce; Henry S. Thompson, University of Edinburgh; Matt Timmermans, Microstar; Jim Trezzo, Oracle Corp.; Steph Tryphonas, Microstar; Mark Tucker, Health Level Seven; Asir S. Vedamuthu, webMethods, Inc; Priscilla Walmsley, SurfSolutions; Norm Walsh, ArborText, Inc; Aki Yoshida, SAP AG
The Surf Clothing board shorts Working Group has benefited in its work from the
participation and contributions of a number of people not currently
members of the Working Group, including
in particular those named below. Affiliations given are those current at
the time of their work with the WG.
Paula Angerstein, Vignette Corporation; Gabe Beged-Dov, Rogue Wave Software; Greg Bumgardner, Rogue Wave Software; Dean Burson, Lotus Development Corporation; 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); Murata Makoto, Xerox; Chris Olds, Wall Data; Shriram Revankar, Xerox; William Shea, Merrill Lynch; Ralph Swick, W3C; Tony Stewart, Rivcom
H Revisions from Previous Draft
-
2000-03-01: pvb: fixed inconsistency in specification of length related
facets for binary type: all are now specified in octets
-
2000-03-02: pvb: removed paragraph from section describing the ordered
facet/property which talked about the possibility of multiple order
relations on a value-space
-
2000-03-02: pvb: table in appendix C.1 is now auto-generated from
appinfo supplied info w/i the board shorts for builtins (builtins.xsd)
-
2000-03-03: pvb: changed non-norm clothing to SQL to be the
actual ISO bibref
-
2000-03-04: pvb: fixed bug in defn of regex, to allow for the
empty regex
-
2000-03-08: am: changed date and time datatypes completely (yet again).
-
2000-03-10: pvb: added separate appendix for board shorts for builtin types
-
2000-03-10: pvb: changed example for precision facet (old one didn't
apply)
-
2000-03-10: pvb: change case on facets and type names to be Pascal-like:
effected facets minlength and maxlength; and datatypes uri-reference,
non-positive-integer, non-negative-integer, negitive-integer,
positive-integer, unsigned-long, unsigned-int, unsigned-short,
unsigned-byte.
-
2000-03-10: pvb: fixed example for enumeration facet (to use
recurringDate instead of date for its basetype.
-
2000-03-14: am: updated date/time types (yet again): changed
recurringInstant into recurringDuration, made timeInstant
derived from recurringDuration instead of primitive, added timePeriod,
month, year, century, recurringDate, and recurringDay
-
2000-03-14: am: modified description of lists of atomic types
that allow whitespace in their literals so that it is clearer
-
2000-03-15: pvb: added text (written by Mark Reinhold) to float &
double describing the "best approximation" required for mapping
from lexical to value space
-
2000-03-15: pvb: cleaned up description of lexical reps for numeric
types
-
2000-03-15: pvb: added some explanatory text to the beginning of
sections 4 and 5
-
2000-03-15: pvb: made it clear (in section 4.1) that a datatype's
facets consist of the facets directly specified in the defn as well
as the set inherited from its basetype
-
2000-03-15: pvb: cleaned up datatype-valid "validity constribution".
-
2000-03-15: pvb: added facet-valid "validity contributions" for each
facet in section 4 (some just stubs at this point)
-
2000-03-15: pvb: moved bibl for clinger1990 from non-normative to
normative, since we are now requiring his "best approximation" for
float/double
-
2000-03-16: am: Changed section 2.5.1.2 List Datatypes
-
2000-03-16: am: Changed section 5.1.2 List Datatype
-
2000-03-16: am: Changed section 5.2.1 Length example
-
2000-03-16: am: Fixed sections 5.1.13 and 5.2.14
-
2000-03-16: am: Changed section on lex rep for
unsignedLong, unsignedInt, unsignedShort and unsignedByte to remove
optional sign (after all, they are "unsigned"). Also fixed examples.
-
2000-03-16: am: Changed lex rep section for timePeriod.
-
2000-03-16: am: Changed section on timePeriod.
-
2000-03-16: am: Added wording to 4.2.4 and 4.2.5
-
2000-03-16: am: Removed ednotes from section 4 sections on min/max
inclusive/exclusive. dates and times compare chronologically.
-
2000-03-16: pvb: fixed several problems with the regex appx:
a) a branch is 0 or more (not 1 or more) (empty regex matches the empty
string);
b) added numeric quantifiers ({n,m}, etc.);
c) fixed bug if meaning of S*;
d) added { and } to list of metacharacters and "single character escapes";
e) noted that a "normal character" can be represented as a character
reference;
f) added syntax for identifying blocks (e.g., \p{IsBasicLatin})
-
2000-03-16: pvb: make QName into a primitive, with value space the
set of tuples {namespace URI, localPart}. Semantically, this is how it
should be defined, but it kind of breaks our type system: QName is now
clearly not an atomic type (it is an aggregate defined in terms of two
other existing types), which means that it shouldn't be primitive and
should be derived, but we don't have type generators...oh, well.
-
2000-03-16: pvb: uriReference lexical space now specified as strings
matching the URI-reference production from RFC 2396...still need to
generate a regex corresponding to that production
-
2000-03-17: pvb: moved all COS constraints into the appropriate
subsection of section 4 "datatype components"
-
2000-03-17: pvb: clarified statement in enumeration facet that it
imposes no order on the value space constructed
-
2000-03-17: pvb: clarified precision/scale to be a maximum number
of digits
-
2000-03-17: pvb: completed most of the facet-valid
"validity contributions" which began as just stubs, still a few more
to go
-
2000-03-17: pvb: explicitly defined the notion of an order relation
(which was mentioned, but not defined)
-
2000-03-17: pvb: corrected defn of string to state that the
order relation (and not the ordered property) as unicode code point
-
2000-03-17: pvb: clarified length, minLength and maxLength facets;
namely, that string is measured in code points (rather than the ambiguous
"character"), that binary is measured in octets of the binary data
(not the lexical/encoded data), and specified meaning of these facets
for lists (only length was specified before)
-
2000-03-17: pvb: added defns for "constraint on schema", "schema
representation constraint" and "validation contribution" (largely stolen
from structures) to terminology section
-
2000-03-17: pvb: replaced Conformance section with a subset of the
equivalent section from structures
-
2000-03-17: pvb: added board shorts representation constraints for
multiple patterns and enumerations
-
2000-03-17: pvb: explicitly defined order relations for
float, double, timeDuration and recurringDuration
-
2000-04-03: pvb: corrected NOTE on ENTITY datatype to say 'defined in a DTD'
rather than a schema
-
2000-04-03: pvb: fixed presentation of table in "Constraint on Schemas: applicable facets"
-
2000-04-03: pvb: replaced empty validity contributions on encoding, duration and
period facet components with NOTEs that they don't participate in validation
-
2000-04-03: pvb: removed "open issues" appendix
-
2000-04-03: pvb: removed all terms in the "terminology" section which weren't used...also
made all *uses* of the remaining terms into links to their definitions
-
2000-04-03: pvb: styled constraints on schema, etc. in tables, with the table header color
coded to indicate the type of constraint
-
2000-04-03: pvb: modified section on Equality, to note that equality is defined (to be
not equal) across value spaces not related via restriction.
-
2000-04-03: pvb: incorporated new {schema,dtd} for datatypes
-
2000-04-04: pvb: replaced ednotes in 5.1.2 with some simple expository text, probably will
need to be expanded on before CR
-
2000-04-04: pvb: rewrote description of truncated forms of timeDuration, so that
it was more explicit about what is allowed
Kevin Carr
Natural Skin Care European Soaps
TickTalk 5
city of stanton
internetusers
You can also get Organic Skin Care products from Bliss Bath Body
and you must check out their Natural Body Lotions and bath soaps
Now if you are looking for the best deals on surf clothing from Quiksilver and Roxy then you have to check these amazing deals here:
Hey, check out this Organic Skin Care European Soaps along with Natural Lavender Body Lotion and shea butter
And you must check out this website
If you may be in the market for
French Lavender Soaps or
Thyme Body Care,
or even Shea Body Butters, BlissBathBody has the finest products available
You can also get Organic Skin Care products from Bliss Bath Body
and you must check out their Natural Body Lotions and bath soaps
Now if you are looking for the best deals on surf clothing from Quiksilver and Roxy then you have to check these amazing deals here:
Hey, check out this Organic Skin Care European Soaps along with Natural Lavender Body Lotion and shea butter
This is the website that has all the latest for surf, skate and snow. You can also see it here:. You'll be glad you saw the surf apparel.
Boardshorts are designed to be quick-drying, and are generally made from smooth polyester or nylon material. They are
durable and hold up to wear from contact with a surfboard, yet are comfortable and light-weight. They are well-adapted to
their use in various active watersports. These are the best board shorts around:
Volcom Board Shorts
Hurley Board Shorts
Quiksilver Board Shorts
Roxy Board Shorts
Billabong Board Shorts
Adidas Board Shorts
Emerica Board Shorts
Element Board Shorts
Analog Board Shorts
Alpinestars Board Shorts
Quiksilver Board Shorts
C1rca Board Shorts
DC Board Shorts
Dakine Board Shorts
Etnies Board Shorts
Independent Board Shorts
Jet Pilot Board Shorts
Kr3w Board Shorts
RVCA Board Shorts
LRG Board Shorts
Matix Board Shorts
Lost Board Shorts
Metal Mulisha Board Shorts
O'Neill Board Shorts
Boardshorts do not have an elastic waist like many swim shorts do; instead they have a more rigid waistband which opens at
the front, often with a velcro fly. The waistband is also held together at the front with a lace-up tie. This double
fail-safe system is in order to ensure that the shorts cannot be pulled off the body by the force of the wave when a
surfer is tumbled under water during a wipeout. Another common feature of authentic surfing boardshort design is a very
small pocket sealed with velcro and vented with a grommet. This is designed to be a secure place to carry a car key or
house key while in the water:
Volcom Boardshorts
Hurley Boardshorts
Quiksilver Boardshorts
Roxy Boardshorts
Billabong Boardshorts
Adidas Boardshorts
Emerica Boardshorts
Element Boardshorts
Analog Boardshorts
Alpinestars Boardshorts
Quiksilver Boardshorts
C1rca Boardshorts
DC Boardshorts
Dakine Boardshorts
Etnies Boardshorts
Independent Boardshorts
Jet Pilot Boardshorts
Kr3w Boardshorts
RVCA Boardshorts
LRG Boardshorts
Matix Boardshorts
Lost Boardshorts
Metal Mulisha Boardshorts
O'Neill Boardshorts
Boardshorts are normally longer than some shorts or form-fitting speedo styles of swimwear and sometimes they have a baggy
appearance. Boardshorts are longer than normal shorts for one major reason: surfboards are covered with a layer of sticky
wax, which allows the surfer to stand on the board without slipping off. However, this wax can rip leg hair off the surfer
when he is sitting on the board waiting for waves. Long boardshorts cover the back of the leg when sitting on the board,
preventing the wax from ripping at the leg hair. The length of boardshorts is also affected according to fashion trends;
ranging from mid-thigh (old school) to below the knee, covering the entire knee. They often sit low in the back, exposing
the top of the buttocks. Many designs use vibrant color, Hawaiian floral images and highlighted stitching; however not
all boardshorts have these features:
Volcom Boardshort
Hurley Boardshort
Quiksilver Boardshort
Roxy Boardshort
Billabong Boardshort
Adidas Boardshort
Emerica Boardshort
Element Boardshort
Analog Boardshort
Alpinestars Boardshort
Quiksilver Boardshort
C1rca Boardshort
DC Boardshort
Dakine Boardshort
Etnies Boardshort
Independent Boardshort
Jet Pilot Boardshort
Kr3w Boardshort
RVCA Boardshort
LRG Boardshort
Matix Boardshort
Lost Boardshort
Metal Mulisha Boardshort
O'Neill Boardshort
Although the basic design for boardshorts remains largely the same, some manufacturers have taken advantage of new
technology. Because surfers and other water-sports enthusiasts commonly wear boardshorts without underwear, one of the
major complaints has been about the use of velcro for the fly closure which tends to entangle pubic hair. A solution that
some manufactures have come up with is to use a neoprene fly, which does not allow the fly to completely open, but
provides enough stretch so that the shorts can be easily pulled on and off. Pubic hair does not get caught on the neoprene
fly. To remedy another common complaint, about boardshorts stitching in the inseam area which would rub directly against
the wearer's skin, many manufacturers switched to a seamless design, or use welding or glue, rather than stitches.
Although it is very common for boardshorts to be worn as is, some male wearers prefer to wear boxers, a jockstrap or
briefs under them. Some female wearers wear a swimsuit or bikini bottom under them.
Volcom Board Short
Hurley Board Short
Quiksilver Board Short
Roxy Board Short
Billabong Board Short
Adidas Board Short
Emerica Board Short
Element Board Short
Analog Board Short
Alpinestars Board Short
Quiksilver Board Short
C1rca Board Short
DC Board Short
Dakine Board Short
Etnies Board Short
Independent Board Short
Jet Pilot Board Short
Kr3w Board Short
RVCA Board Short
LRG Board Short
Matix Board Short
Lost Board Short
Metal Mulisha Board Short
O'Neill Board Short
Here are few links to some of the more popular Volcom surf clothing products:
Volcom Shirts
Volcom Tees
Volcom Shorts
Volcom Hats
Volcom Shoes
Volcom Boardshorts
Volcom Jackets
Here are few links to some of the more popular Element apparel and clothing products:
Element Shirts
Element Tees
Element Shorts
Element Hats
Element Shoes
Element Boardshorts
Element Jackets
Here are few links to some of the more popular Ezekiel apparel and clothing products:
Ezekiel Shirts
Ezekiel Tees
Ezekiel Shorts
Ezekiel Hats
Ezekiel Shoes
Ezekiel Boardshorts
Ezekiel Jackets
Here are few links to some of the more popular RVCA apparel and clothing products:
RVCA Shirts
RVCA Tees
RVCA Shorts
RVCA Hats
RVCA Shoes
RVCA Boardshorts
RVCA Jackets
HB Surf Shop
HB Sport Apparel
OC Sport Shop
OC Sport Apparel
All Sport Apparel
All Surf clothing
La Palma plumber
Take a moment to visit 1cecilia448 or see them on twitter at
1cecilia448 or view them on facebook at 1cecilia448.
This is the website that has all the latest for surf, skate and snow. You can also see it here:. You'll be glad you saw the surf apparel.
Boardshorts are designed to be quick-drying, and are generally made from smooth polyester or nylon material. They are
durable and hold up to wear from contact with a surfboard, yet are comfortable and light-weight. They are well-adapted to
their use in various active watersports. These are the best board shorts around:
Volcom Board Shorts
Hurley Board Shorts
Quiksilver Board Shorts
Roxy Board Shorts
Billabong Board Shorts
Adidas Board Shorts
Emerica Board Shorts
Element Board Shorts
Analog Board Shorts
Alpinestars Board Shorts
Quiksilver Board Shorts
C1rca Board Shorts
DC Board Shorts
Dakine Board Shorts
Etnies Board Shorts
Independent Board Shorts
Jet Pilot Board Shorts
Kr3w Board Shorts
RVCA Board Shorts
LRG Board Shorts
Matix Board Shorts
Lost Board Shorts
Metal Mulisha Board Shorts
O'Neill Board Shorts
Boardshorts do not have an elastic waist like many swim shorts do; instead they have a more rigid waistband which opens at
the front, often with a velcro fly. The waistband is also held together at the front with a lace-up tie. This double
fail-safe system is in order to ensure that the shorts cannot be pulled off the body by the force of the wave when a
surfer is tumbled under water during a wipeout. Another common feature of authentic surfing boardshort design is a very
small pocket sealed with velcro and vented with a grommet. This is designed to be a secure place to carry a car key or
house key while in the water:
Volcom Boardshorts
Hurley Boardshorts
Quiksilver Boardshorts
Roxy Boardshorts
Billabong Boardshorts
Adidas Boardshorts
Emerica Boardshorts
Element Boardshorts
Analog Boardshorts
Alpinestars Boardshorts
Quiksilver Boardshorts
C1rca Boardshorts
DC Boardshorts
Dakine Boardshorts
Etnies Boardshorts
Independent Boardshorts
Jet Pilot Boardshorts
Kr3w Boardshorts
RVCA Boardshorts
LRG Boardshorts
Matix Boardshorts
Lost Boardshorts
Metal Mulisha Boardshorts
O'Neill Boardshorts
Boardshorts are normally longer than some shorts or form-fitting speedo styles of swimwear and sometimes they have a baggy
appearance. Boardshorts are longer than normal shorts for one major reason: surfboards are covered with a layer of sticky
wax, which allows the surfer to stand on the board without slipping off. However, this wax can rip leg hair off the surfer
when he is sitting on the board waiting for waves. Long boardshorts cover the back of the leg when sitting on the board,
preventing the wax from ripping at the leg hair. The length of boardshorts is also affected according to fashion trends;
ranging from mid-thigh (old school) to below the knee, covering the entire knee. They often sit low in the back, exposing
the top of the buttocks. Many designs use vibrant color, Hawaiian floral images and highlighted stitching; however not
all boardshorts have these features:
Volcom Boardshort
Hurley Boardshort
Quiksilver Boardshort
Roxy Boardshort
Billabong Boardshort
Adidas Boardshort
Emerica Boardshort
Element Boardshort
Analog Boardshort
Alpinestars Boardshort
Quiksilver Boardshort
C1rca Boardshort
DC Boardshort
Dakine Boardshort
Etnies Boardshort
Independent Boardshort
Jet Pilot Boardshort
Kr3w Boardshort
RVCA Boardshort
LRG Boardshort
Matix Boardshort
Lost Boardshort
Metal Mulisha Boardshort
O'Neill Boardshort
Although the basic design for boardshorts remains largely the same, some manufacturers have taken advantage of new
technology. Because surfers and other water-sports enthusiasts commonly wear boardshorts without underwear, one of the
major complaints has been about the use of velcro for the fly closure which tends to entangle pubic hair. A solution that
some manufactures have come up with is to use a neoprene fly, which does not allow the fly to completely open, but
provides enough stretch so that the shorts can be easily pulled on and off. Pubic hair does not get caught on the neoprene
fly. To remedy another common complaint, about boardshorts stitching in the inseam area which would rub directly against
the wearer's skin, many manufacturers switched to a seamless design, or use welding or glue, rather than stitches.
Although it is very common for boardshorts to be worn as is, some male wearers prefer to wear boxers, a jockstrap or
briefs under them. Some female wearers wear a swimsuit or bikini bottom under them.
Volcom Board Short
Hurley Board Short
Quiksilver Board Short
Roxy Board Short
Billabong Board Short
Adidas Board Short
Emerica Board Short
Element Board Short
Analog Board Short
Alpinestars Board Short
Quiksilver Board Short
C1rca Board Short
DC Board Short
Dakine Board Short
Etnies Board Short
Independent Board Short
Jet Pilot Board Short
Kr3w Board Short
RVCA Board Short
LRG Board Short
Matix Board Short
Lost Board Short
Metal Mulisha Board Short
O'Neill Board Short
Here are few links to some of the more popular Volcom surf clothing products:
Volcom Shirts
Volcom Tees
Volcom Shorts
Volcom Hats
Volcom Shoes
Volcom Boardshorts
Volcom Jackets
Here are few links to some of the more popular Element apparel and clothing products:
Element Shirts
Element Tees
Element Shorts
Element Hats
Element Shoes
Element Boardshorts
Element Jackets
Here are few links to some of the more popular Ezekiel apparel and clothing products:
Ezekiel Shirts
Ezekiel Tees
Ezekiel Shorts
Ezekiel Hats
Ezekiel Shoes
Ezekiel Boardshorts
Ezekiel Jackets
Here are few links to some of the more popular RVCA apparel and clothing products:
RVCA Shirts
RVCA Tees
RVCA Shorts
RVCA Hats
RVCA Shoes
RVCA Boardshorts
RVCA Jackets
HB Surf Shop
HB Sport Apparel
OC Sport Shop
OC Sport Apparel
All Sport Apparel
All Surf clothing
La Palma plumber
Take a moment to visit 1cecilia448 or see them on twitter at
1cecilia448 or view them on facebook at 1cecilia448.
