Class: RDF::XSD

Inherits:
Vocabulary show all
Defined in:
lib/rdf/vocab/xsd.rb

Overview

Vocabulary for <www.w3.org/2001/XMLSchema#>

Instance Attribute Summary collapse

Method Summary

Methods inherited from Vocabulary

#[], [], __prefix__, __prefix__=, each, each_statement, enum_for, expand_pname, find, find_term, from_graph, from_sym, imported_from, imports, #initialize, #inspect, inspect, limit_vocabs, ontology, properties, property, register, strict?, to_iri, to_s, #to_s, to_uri, #to_uri, vocab_map

Constructor Details

This class inherits a constructor from RDF::Vocabulary

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class RDF::Vocabulary

Instance Attribute Details

#anyAtomicType ⇒ RDF::Vocabulary::Term (readonly)

‘anyAtomicType` is a special restriction of `anySimpleType`. The value and _lexical spaces_ of `anyAtomicType` are the unions of the value and _lexical spaces_ of all the primitive datatypes, and `anyAtomicType` is their _base type_.

Returns:



50
51
52
 
# File 'lib/rdf/vocab/xsd.rb', line 50

def anyAtomicType
  @anyAtomicType
end

#anySimpleType ⇒ RDF::Vocabulary::Term (readonly)

The definition of ‘anySimpleType` is a special restriction of `anyType`. The _lexical space_ of a`nySimpleType` is the set of all sequences of Unicode characters, and its _value space_ includes all _atomic values_ and all finite-length lists of zero or more _atomic values_.

Returns:



54
55
56
 
# File 'lib/rdf/vocab/xsd.rb', line 54

def anySimpleType
  @anySimpleType
end

#anyType ⇒ RDF::Vocabulary::Term (readonly)

The root of the [XML Schema 1.1] datatype heirarchy.

Returns:



58
59
60
 
# File 'lib/rdf/vocab/xsd.rb', line 58

def anyType
  @anyType
end

#anyURI ⇒ RDF::Vocabulary::Term (readonly)

‘anyURI` represents an Internationalized Resource Identifier Reference (IRI). An `anyURI` value can be absolute or relative, and may have an optional fragment identifier (i.e., it may be an IRI Reference). This type should be used when the value fulfills the role of an IRI, as defined in [RFC 3987] or its successor(s) in the IETF Standards Track.

Returns:



62
63
64
 
# File 'lib/rdf/vocab/xsd.rb', line 62

def anyURI
  @anyURI
end

#base64Binary ⇒ RDF::Vocabulary::Term (readonly)

‘base64Binary` represents arbitrary Base64-encoded binary data. For `base64Binary` data the entire binary stream is encoded using the `Base64` Encoding defined in [RFC 3548], which is derived from the encoding described in [RFC 2045].

Returns:



66
67
68
 
# File 'lib/rdf/vocab/xsd.rb', line 66

def base64Binary
  @base64Binary
end

#boolean ⇒ RDF::Vocabulary::Term (readonly)

‘boolean` represents the values of two-valued logic.

Returns:



70
71
72
 
# File 'lib/rdf/vocab/xsd.rb', line 70

def boolean
  @boolean
end

#byte ⇒ RDF::Vocabulary::Term (readonly)

‘byte` is derived from `short` by setting the value of `maxInclusive` to be `127` and `minInclusive` to be `-128`. The _base type_ of `byte` is `short`.

Returns:



74
75
76
 
# File 'lib/rdf/vocab/xsd.rb', line 74

def byte
  @byte
end

#date ⇒ RDF::Vocabulary::Term (readonly)

‘date` represents top-open intervals of exactly one day in length on the timelines of `dateTime`, beginning on the beginning moment of each day, up to but not including the beginning moment of the next day). For non-timezoned values, the top-open intervals disjointly cover the non-timezoned timeline, one per day. For timezoned values, the intervals begin at every minute and therefore overlap.

Returns:



78
79
80
 
# File 'lib/rdf/vocab/xsd.rb', line 78

def date
  @date
end

#dateTime ⇒ RDF::Vocabulary::Term (readonly)

‘dateTime` represents instants of time, optionally marked with a particular time zone offset. Values representing the same instant but having different time zone offsets are equal but not identical.

Returns:



82
83
84
 
# File 'lib/rdf/vocab/xsd.rb', line 82

def dateTime
  @dateTime
end

#dateTimeStamp ⇒ RDF::Vocabulary::Term (readonly)

The ‘dateTimeStamp` datatype is derived from `dateTime` by giving the value required to its `explicitTimezone` facet. The result is that all values of `dateTimeStamp` are required to have explicit time zone offsets and the datatype is totally ordered.

Returns:



86
87
88
 
# File 'lib/rdf/vocab/xsd.rb', line 86

def dateTimeStamp
  @dateTimeStamp
end

#dayTimeDuration ⇒ RDF::Vocabulary::Term (readonly)

‘dayTimeDuration` is a datatype derived from `duration` by restricting its _lexical representations_ to instances of `dayTimeDurationLexicalRep`. The _value space_ of `dayTimeDuration` is therefore that of `duration` restricted to those whose `months` property is `0`. This results in a `duration` datatype which is totally ordered.

Returns:



90
91
92
 
# File 'lib/rdf/vocab/xsd.rb', line 90

def dayTimeDuration
  @dayTimeDuration
end

#decimal ⇒ RDF::Vocabulary::Term (readonly)

‘decimal` represents a subset of the real numbers, which can be represented by decimal numerals. The _value space_ of decimal is the set of numbers that can be obtained by dividing an integer by a non-negative power of ten, i.e., expressible as `i / 10n` where `i` and `n` are integers and `n ≥ 0`. Precision is not reflected in this value space; the number `2.0` is not distinct from the number `2.00`. The order relation on `decimal` is the order relation on real numbers, restricted to this subset.

Returns:



94
95
96
 
# File 'lib/rdf/vocab/xsd.rb', line 94

def decimal
  @decimal
end

#double ⇒ RDF::Vocabulary::Term (readonly)

The ‘double` datatype is patterned after the IEEE double-precision 64-bit floating point datatype [IEEE 754-2008]. Each floating point datatype has a value space that is a subset of the rational numbers. Floating point numbers are often used to approximate arbitrary real numbers.

Returns:



98
99
100
 
# File 'lib/rdf/vocab/xsd.rb', line 98

def double
  @double
end

#duration ⇒ RDF::Vocabulary::Term (readonly)

‘duration` is a datatype that represents durations of time. The concept of duration being captured is drawn from those of [ISO 8601], specifically durations without fixed endpoints. For example, “15 days” (whose most common lexical representation in duration is `“’P15D’”‘) is a duration value; “15 days beginning 12 July 1995” and “15 days ending 12 July 1995” are not duration values. duration can provide addition and subtraction operations between duration values and between duration/dateTime value pairs, and can be the result of subtracting dateTime values. However, only addition to `dateTime` is required for XML Schema processing and is defined in the function `dateTimePlusDuration`.

Returns:



102
103
104
 
# File 'lib/rdf/vocab/xsd.rb', line 102

def duration
  @duration
end

#ENTITIES ⇒ RDF::Vocabulary::Term (readonly)

‘ENTITIES` represents the `ENTITIES` attribute type from [XML]. The _value space_ of `ENTITIES` is the set of finite, non-zero-length sequences of `ENTITY` values that have been declared as unparsed entities in a document type definition. The _lexical space_ of `ENTITIES` is the set of space-separated lists of tokens, of which each token is in the _lexical space_ of `ENTITY`. The _item type_ of `ENTITIES` is `ENTITY`. `ENTITIES` is derived from `anySimpleType` in two steps: an anonymous list type is defined, whose _item type_ is `ENTITY`; this is the _base type_ of `ENTITIES`, which restricts its value space to lists with at least one item.

Returns:



6
7
8
 
# File 'lib/rdf/vocab/xsd.rb', line 6

def ENTITIES
  @ENTITIES
end

#ENTITY ⇒ RDF::Vocabulary::Term (readonly)

‘ENTITY` represents the `ENTITY` attribute type from [XML]. The _value space_ of `ENTITY` is the set of all strings that match the `NCName` production in [Namespaces in XML] and have been declared as an unparsed entity in a document type definition. The _lexical space_ of ENTITY is the set of all strings that match the NCName production in [Namespaces in XML]. The _base type_ of ENTITY is NCName.

Returns:



10
11
12
 
# File 'lib/rdf/vocab/xsd.rb', line 10

def ENTITY
  @ENTITY
end

#float ⇒ RDF::Vocabulary::Term (readonly)

The ‘float` datatype is patterned after the IEEE single-precision 32-bit floating point datatype [IEEE 754-2008]. Its value space is a subset of the rational numbers. Floating point numbers are often used to approximate arbitrary real numbers.

Returns:



106
107
108
 
# File 'lib/rdf/vocab/xsd.rb', line 106

def float
  @float
end

#gDay ⇒ RDF::Vocabulary::Term (readonly)

‘gDay` represents whole days within an arbitrary month—days that recur at the same point in each (Gregorian) month. This datatype is used to represent a specific day of the month. To indicate, for example, that an employee gets a paycheck on the 15th of each month. (Obviously, days beyond 28 cannot occur in all months; they are nonetheless permitted, up to 31.)

Returns:



110
111
112
 
# File 'lib/rdf/vocab/xsd.rb', line 110

def gDay
  @gDay
end

#gMonth ⇒ RDF::Vocabulary::Term (readonly)

‘gMonth` represents whole (Gregorian) months within an arbitrary year—months that recur at the same point in each year. It might be used, for example, to say what month annual Thanksgiving celebrations fall in different countries (`–11` in the United States, `–10` in Canada, and possibly other months in other countries).

Returns:



114
115
116
 
# File 'lib/rdf/vocab/xsd.rb', line 114

def gMonth
  @gMonth
end

#gMonthDay ⇒ RDF::Vocabulary::Term (readonly)

‘gMonthDay` represents whole calendar days that recur at the same point in each calendar year, or that occur in some arbitrary calendar year. (Obviously, days beyond 28 cannot occur in all Februaries; 29 is nonetheless permitted.)

Returns:



118
119
120
 
# File 'lib/rdf/vocab/xsd.rb', line 118

def gMonthDay
  @gMonthDay
end

#gYear ⇒ RDF::Vocabulary::Term (readonly)

‘gYear` represents Gregorian calendar years.

Returns:



122
123
124
 
# File 'lib/rdf/vocab/xsd.rb', line 122

def gYear
  @gYear
end

#gYearMonth ⇒ RDF::Vocabulary::Term (readonly)

‘gYearMonth` represents specific whole Gregorian months in specific Gregorian years.

Returns:



126
127
128
 
# File 'lib/rdf/vocab/xsd.rb', line 126

def gYearMonth
  @gYearMonth
end

#hexBinary ⇒ RDF::Vocabulary::Term (readonly)

hexBinary` represents arbitrary hex-encoded binary data.

Returns:



130
131
132
 
# File 'lib/rdf/vocab/xsd.rb', line 130

def hexBinary
  @hexBinary
end

#ID ⇒ RDF::Vocabulary::Term (readonly)

‘ID` represents the `ID` attribute type from [XML]. The _value space_ of `ID` is the set of all strings that match the `NCName` production in [Namespaces in XML]. The _lexical space_ of `ID` is the set of all strings that match the `NCName` production in [Namespaces in XML]. The _base type_ of `ID` is `NCName`.

Returns:



14
15
16
 
# File 'lib/rdf/vocab/xsd.rb', line 14

def ID
  @ID
end

#IDREF ⇒ RDF::Vocabulary::Term (readonly)

‘IDREF` represents the `IDREF` attribute type from [XML]. The _value space_ of `IDREF` is the set of all strings that match the `NCName` production in [Namespaces in XML]. The _lexical space_ of `IDREF` is the set of strings that match the `NCName` production in [Namespaces in XML]. The _base type_ of `IDREF` is `NCName`.

Returns:



18
19
20
 
# File 'lib/rdf/vocab/xsd.rb', line 18

def IDREF
  @IDREF
end

#IDREFS ⇒ RDF::Vocabulary::Term (readonly)

‘IDREFS` represents the `IDREFS` attribute type from [XML]. The _value space_ of `IDREFS` is the set of finite, non-zero-length sequences of `IDREF`s. The _lexical space_ of `IDREFS` is the set of space-separated lists of tokens, of which each token is in the _lexical space_ of `IDREF`. The _item type_ of `IDREFS` is `IDREF`. `IDREFS` is derived from `anySimpleType` in two steps: an anonymous list type is defined, whose _item type_ is `IDREF`; this is the _base type_ of `IDREFS`, which restricts its value space to lists with at least one item.

Returns:



22
23
24
 
# File 'lib/rdf/vocab/xsd.rb', line 22

def IDREFS
  @IDREFS
end

#int ⇒ RDF::Vocabulary::Term (readonly)

‘int` is derived from `long` by setting the value of `maxInclusive` to be `2147483647` and `minInclusive` to be `-2147483648`. The _base type_ of `int` is `long`.

Returns:



134
135
136
 
# File 'lib/rdf/vocab/xsd.rb', line 134

def int
  @int
end

#integer ⇒ RDF::Vocabulary::Term (readonly)

‘integer` is derived from `decimal` by fixing the value of `fractionDigits` to be `0` and disallowing the trailing decimal point. 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`.

Returns:



138
139
140
 
# File 'lib/rdf/vocab/xsd.rb', line 138

def integer
  @integer
end

#language ⇒ RDF::Vocabulary::Term (readonly)

‘language` represents formal natural language identifiers, as defined by [BCP 47] (currently represented by [RFC 4646] and [RFC 4647]) or its successor(s). The _value space_ and _lexical space_ of `language` are the set of all strings that conform to the pattern `[a-zA-Z]1,8(-[a-zA-Z0-9]1,8)*`.

Returns:



142
143
144
 
# File 'lib/rdf/vocab/xsd.rb', line 142

def language
  @language
end

#long ⇒ RDF::Vocabulary::Term (readonly)

‘long` is derived from `integer` by setting the value of `maxInclusive` to be `9223372036854775807` and `minInclusive` to be `-9223372036854775808`. The _base type_ of `long` is `integer`.

Returns:



146
147
148
 
# File 'lib/rdf/vocab/xsd.rb', line 146

def long
  @long
end

#Name ⇒ RDF::Vocabulary::Term (readonly)

‘Name` represents XML Names. The _value space_ of `Name` is the set of all strings which match the `Name` production of [XML]. The _lexical space_ of `Name` is the set of all strings which match the `Name` production of [XML]. The _base type_ of `Name` is `token`.

Returns:



42
43
44
 
# File 'lib/rdf/vocab/xsd.rb', line 42

def Name
  @Name
end

#NCName ⇒ RDF::Vocabulary::Term (readonly)

‘NCName` represents XML “non-colonized” Names. The _value space_ of `NCName` is the set of all strings which match the `NCName` production of [Namespaces in XML]. The _lexical space_ of `NCName` is the set of all strings which match the `NCName` production of [Namespaces in XML]. The _base type_ of `NCName` is `Name`.

Returns:



26
27
28
 
# File 'lib/rdf/vocab/xsd.rb', line 26

def NCName
  @NCName
end

#negativeInteger ⇒ RDF::Vocabulary::Term (readonly)

‘negativeInteger` is derived from `nonPositiveInteger` by setting 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`.

Returns:



150
151
152
 
# File 'lib/rdf/vocab/xsd.rb', line 150

def negativeInteger
  @negativeInteger
end

#NMTOKEN ⇒ RDF::Vocabulary::Term (readonly)

‘NMTOKEN` represents the `NMTOKEN` attribute type from [XML]. The _value space_ of `NMTOKEN` is the set of tokens that match the `Nmtoken` production in [XML]. The _lexical space_ of `NMTOKEN` is the set of strings that match the Nmtoken production in [XML]. The _base type_ of `NMTOKEN` is `token`.

Returns:



30
31
32
 
# File 'lib/rdf/vocab/xsd.rb', line 30

def NMTOKEN
  @NMTOKEN
end

#NMTOKENS ⇒ RDF::Vocabulary::Term (readonly)

‘NMTOKENS` represents the `NMTOKENS` attribute type from [XML]. The _value space_ of `NMTOKENS` is the set of finite, non-zero-length sequences of `NMTOKEN`s. The _lexical space_ of `NMTOKENS` is the set of space-separated lists of tokens, of which each token is in the _lexical space_ of `NMTOKEN`. The _item type_ of `NMTOKENS` is `NMTOKEN`. `NMTOKENS` is derived from `anySimpleType` in two steps: an anonymous list type is defined, whose _item type_ is `NMTOKEN`; this is the _base type_ of `NMTOKENS`, which restricts its value space to lists with at least one item.

Returns:



34
35
36
 
# File 'lib/rdf/vocab/xsd.rb', line 34

def NMTOKENS
  @NMTOKENS
end

#nonNegativeInteger ⇒ RDF::Vocabulary::Term (readonly)

‘nonNegativeInteger` is derived from `integer` by setting the value of `minInclusive` to be `0`. This results in 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`.

Returns:



154
155
156
 
# File 'lib/rdf/vocab/xsd.rb', line 154

def nonNegativeInteger
  @nonNegativeInteger
end

#nonPositiveInteger ⇒ RDF::Vocabulary::Term (readonly)

‘nonPositiveInteger` is derived from `integer` by setting 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`.

Returns:



158
159
160
 
# File 'lib/rdf/vocab/xsd.rb', line 158

def nonPositiveInteger
  @nonPositiveInteger
end

#normalizedString ⇒ RDF::Vocabulary::Term (readonly)

‘normalizedString` represents white space normalized strings. The _value space_ of `normalizedString` is the set of strings that do not contain the carriage return (`#xD`), line feed (`#xA`) nor tab (`#x9`) characters. The _lexical space_ of `normalizedString` is the set of strings that do not contain the carriage return (`#xD`), line feed (`#xA`) nor tab (`#x9`) characters. The _base type_ of `normalizedString` is `string`.

Returns:



162
163
164
 
# File 'lib/rdf/vocab/xsd.rb', line 162

def normalizedString
  @normalizedString
end

#NOTATION ⇒ RDF::Vocabulary::Term (readonly)

‘NOTATION` represents the `NOTATION` attribute type from [XML]. The _value space_ of `NOTATION` is the set of `QNames` of notations declared in the current schema. The _lexical space_ of `NOTATION` is the set of all names of notations declared in the current schema (in the form of `QNames`).

Returns:



38
39
40
 
# File 'lib/rdf/vocab/xsd.rb', line 38

def NOTATION
  @NOTATION
end

#positiveInteger ⇒ RDF::Vocabulary::Term (readonly)

‘positiveInteger` is derived from `nonNegativeInteger` by setting 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`.

Returns:



166
167
168
 
# File 'lib/rdf/vocab/xsd.rb', line 166

def positiveInteger
  @positiveInteger
end

#QName ⇒ RDF::Vocabulary::Term (readonly)

‘QName` represents XML qualified names. The _value space_ of `QName` is the set of tuples `name, local part`, where namespace name is an `anyURI` and local part is an `NCName`. The _lexical space_ of `QName` is the set of strings that match the `QName` production of [Namespaces in XML].

Returns:



46
47
48
 
# File 'lib/rdf/vocab/xsd.rb', line 46

def QName
  @QName
end

#short ⇒ RDF::Vocabulary::Term (readonly)

‘short` is derived from `int` by setting the value of `maxInclusive` to be `32767` and `minInclusive` to be `-32768`. The _base type_ of `short` is `int`.

Returns:



170
171
172
 
# File 'lib/rdf/vocab/xsd.rb', line 170

def short
  @short
end

#string ⇒ RDF::Vocabulary::Term (readonly)

The ‘string` datatype represents character strings in XML.

Returns:



174
175
176
 
# File 'lib/rdf/vocab/xsd.rb', line 174

def string
  @string
end

#time ⇒ RDF::Vocabulary::Term (readonly)

‘time` represents instants of time that recur at the same point in each calendar day, or that occur in some arbitrary calendar day.

Returns:



178
179
180
 
# File 'lib/rdf/vocab/xsd.rb', line 178

def time
  @time
end

#token ⇒ RDF::Vocabulary::Term (readonly)

‘token` represents tokenized strings. The _value space_ of `token` is the set of strings that do not contain the carriage return (`#xD`), line feed (`#xA`) nor tab (`#x9`) characters, that have no leading or trailing spaces (`#x20`) and that have no internal sequences of two or more spaces. The _lexical space_ of `token` is the set of strings that do not contain the carriage return (`#xD`), line feed (`#xA`) nor tab (`#x9`) characters, that have no leading or trailing spaces (`#x20`) and that have no internal sequences of two or more spaces. The _base type_ of `token` is `normalizedString`.

Returns:



182
183
184
 
# File 'lib/rdf/vocab/xsd.rb', line 182

def token
  @token
end

#unsignedByte ⇒ RDF::Vocabulary::Term (readonly)

‘unsignedByte` is derived from `unsignedShort` by setting the value of `maxInclusive` to be `255`. The _base type_ of `unsignedByte` is `unsignedShort`.

Returns:



186
187
188
 
# File 'lib/rdf/vocab/xsd.rb', line 186

def unsignedByte
  @unsignedByte
end

#unsignedInt ⇒ RDF::Vocabulary::Term (readonly)

‘unsignedInt` is derived from `unsignedLong` by setting the value of `maxInclusive` to be `4294967295`. The _base type_ of `unsignedInt` is `unsignedLong`.

Returns:



190
191
192
 
# File 'lib/rdf/vocab/xsd.rb', line 190

def unsignedInt
  @unsignedInt
end

#unsignedLong ⇒ RDF::Vocabulary::Term (readonly)

‘unsignedLong` is derived from `nonNegativeInteger` by setting the value of `maxInclusive` to be `18446744073709551615`. The _base type_ of `unsignedLong` is `nonNegativeInteger`.

Returns:



194
195
196
 
# File 'lib/rdf/vocab/xsd.rb', line 194

def unsignedLong
  @unsignedLong
end

#unsignedShort ⇒ RDF::Vocabulary::Term (readonly)

‘unsignedShort` is derived from `unsignedInt` by setting the value of `maxInclusive` to be `65535`. The _base type_ of `unsignedShort` is `unsignedInt`.

Returns:



198
199
200
 
# File 'lib/rdf/vocab/xsd.rb', line 198

def unsignedShort
  @unsignedShort
end

#yearMonthDuration ⇒ RDF::Vocabulary::Term (readonly)

‘yearMonthDuration` is a datatype derived from `duration` by restricting its _lexical representations_ to instances of `yearMonthDurationLexicalRep`. The _value space_ of `yearMonthDuration` is therefore that of `duration` restricted to those whose `seconds` property is `0`. This results in a `duration` datatype which is totally ordered.

Returns:



202
203
204
 
# File 'lib/rdf/vocab/xsd.rb', line 202

def yearMonthDuration
  @yearMonthDuration
end