Class: RDF::XSD
- Inherits:
-
Vocabulary
- Object
- Vocabulary
- RDF::XSD
- Defined in:
- vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/lib/rdf/vocab/xsd.rb
Overview
Vocabulary for http://www.w3.org/2001/XMLSchema#
Defined Under Namespace
Modules: VERSION
Instance Attribute Summary collapse
-
#anyAtomicType ⇒ RDF::Vocabulary::Term
readonly
anyAtomicType
is a special restriction ofanySimpleType
. -
#anySimpleType ⇒ RDF::Vocabulary::Term
readonly
The definition of
anySimpleType
is a special restriction ofanyType
. -
#anyType ⇒ RDF::Vocabulary::Term
readonly
The root of the [XML Schema 1.1] datatype heirarchy.
-
#anyURI ⇒ RDF::Vocabulary::Term
readonly
anyURI
represents an Internationalized Resource Identifier Reference (IRI). -
#base64Binary ⇒ RDF::Vocabulary::Term
readonly
base64Binary
represents arbitrary Base64-encoded binary data. -
#boolean ⇒ RDF::Vocabulary::Term
readonly
boolean
represents the values of two-valued logic. -
#byte ⇒ RDF::Vocabulary::Term
readonly
byte
is derived fromshort
by setting the value ofmaxInclusive
to be127
andminInclusive
to be-128
. -
#date ⇒ RDF::Vocabulary::Term
readonly
date
represents top-open intervals of exactly one day in length on the timelines ofdateTime
, beginning on the beginning moment of each day, up to but not including the beginning moment of the next day). -
#dateTime ⇒ RDF::Vocabulary::Term
readonly
dateTime
represents instants of time, optionally marked with a particular time zone offset. -
#dateTimeStamp ⇒ RDF::Vocabulary::Term
readonly
The
dateTimeStamp
datatype is derived fromdateTime
by giving the value required to itsexplicitTimezone
facet. -
#dayTimeDuration ⇒ RDF::Vocabulary::Term
readonly
dayTimeDuration
is a datatype derived fromduration
by restricting its lexical representations to instances ofdayTimeDurationLexicalRep
. -
#decimal ⇒ RDF::Vocabulary::Term
readonly
decimal
represents a subset of the real numbers, which can be represented by decimal numerals. -
#double ⇒ RDF::Vocabulary::Term
readonly
The
double
datatype is patterned after the IEEE double-precision 64-bit floating point datatype [IEEE 754-2008]. -
#duration ⇒ RDF::Vocabulary::Term
readonly
duration
is a datatype that represents durations of time. -
#ENTITIES ⇒ RDF::Vocabulary::Term
readonly
ENTITIES
represents theENTITIES
attribute type from [XML]. -
#ENTITY ⇒ RDF::Vocabulary::Term
readonly
ENTITY
represents theENTITY
attribute type from [XML]. -
#float ⇒ RDF::Vocabulary::Term
readonly
The
float
datatype is patterned after the IEEE single-precision 32-bit floating point datatype [IEEE 754-2008]. -
#gDay ⇒ RDF::Vocabulary::Term
readonly
gDay
represents whole days within an arbitrary month—days that recur at the same point in each (Gregorian) month. -
#gMonth ⇒ RDF::Vocabulary::Term
readonly
gMonth
represents whole (Gregorian) months within an arbitrary year—months that recur at the same point in each year. -
#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. -
#gYear ⇒ RDF::Vocabulary::Term
readonly
gYear
represents Gregorian calendar years. -
#gYearMonth ⇒ RDF::Vocabulary::Term
readonly
gYearMonth
represents specific whole Gregorian months in specific Gregorian years. -
#hexBinary ⇒ RDF::Vocabulary::Term
readonly
hexBinary` represents arbitrary hex-encoded binary data.
-
#ID ⇒ RDF::Vocabulary::Term
readonly
ID
represents theID
attribute type from [XML]. -
#IDREF ⇒ RDF::Vocabulary::Term
readonly
IDREF
represents theIDREF
attribute type from [XML]. -
#IDREFS ⇒ RDF::Vocabulary::Term
readonly
IDREFS
represents theIDREFS
attribute type from [XML]. -
#int ⇒ RDF::Vocabulary::Term
readonly
int
is derived fromlong
by setting the value ofmaxInclusive
to be2147483647
andminInclusive
to be-2147483648
. -
#integer ⇒ RDF::Vocabulary::Term
readonly
integer
is derived fromdecimal
by fixing the value offractionDigits
to be0
and disallowing the trailing decimal point. -
#language ⇒ RDF::Vocabulary::Term
readonly
language
represents formal natural language identifiers, as defined by BCP 47 or its successor(s). -
#long ⇒ RDF::Vocabulary::Term
readonly
long
is derived frominteger
by setting the value ofmaxInclusive
to be9223372036854775807
andminInclusive
to be-9223372036854775808
. -
#Name ⇒ RDF::Vocabulary::Term
readonly
Name
represents XML Names. -
#NCName ⇒ RDF::Vocabulary::Term
readonly
NCName
represents XML "non-colonized" Names. -
#negativeInteger ⇒ RDF::Vocabulary::Term
readonly
negativeInteger
is derived fromnonPositiveInteger
by setting the value ofmaxInclusive
to be-1
. -
#NMTOKEN ⇒ RDF::Vocabulary::Term
readonly
NMTOKEN
represents theNMTOKEN
attribute type from [XML]. -
#NMTOKENS ⇒ RDF::Vocabulary::Term
readonly
NMTOKENS
represents theNMTOKENS
attribute type from [XML]. -
#nonNegativeInteger ⇒ RDF::Vocabulary::Term
readonly
nonNegativeInteger
is derived frominteger
by setting the value ofminInclusive
to be0
. -
#nonPositiveInteger ⇒ RDF::Vocabulary::Term
readonly
nonPositiveInteger
is derived frominteger
by setting the value ofmaxInclusive
to be0
. -
#normalizedString ⇒ RDF::Vocabulary::Term
readonly
normalizedString
represents white space normalized strings. -
#NOTATION ⇒ RDF::Vocabulary::Term
readonly
NOTATION
represents theNOTATION
attribute type from [XML]. -
#positiveInteger ⇒ RDF::Vocabulary::Term
readonly
positiveInteger
is derived fromnonNegativeInteger
by setting the value ofminInclusive
to be1
. -
#QName ⇒ RDF::Vocabulary::Term
readonly
QName
represents XML qualified names. -
#short ⇒ RDF::Vocabulary::Term
readonly
short
is derived fromint
by setting the value ofmaxInclusive
to be32767
andminInclusive
to be-32768
. -
#string ⇒ RDF::Vocabulary::Term
readonly
The
string
datatype represents character strings in XML. -
#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. -
#token ⇒ RDF::Vocabulary::Term
readonly
token
represents tokenized strings. -
#unsignedByte ⇒ RDF::Vocabulary::Term
readonly
unsignedByte
is derived fromunsignedShort
by setting the value ofmaxInclusive
to be255
. -
#unsignedInt ⇒ RDF::Vocabulary::Term
readonly
unsignedInt
is derived fromunsignedLong
by setting the value ofmaxInclusive
to be4294967295
. -
#unsignedLong ⇒ RDF::Vocabulary::Term
readonly
unsignedLong
is derived fromnonNegativeInteger
by setting the value ofmaxInclusive
to be18446744073709551615
. -
#unsignedShort ⇒ RDF::Vocabulary::Term
readonly
unsignedShort
is derived fromunsignedInt
by setting the value ofmaxInclusive
to be65535
. -
#yearMonthDuration ⇒ RDF::Vocabulary::Term
readonly
yearMonthDuration
is a datatype derived fromduration
by restricting its lexical representations to instances ofyearMonthDurationLexicalRep
.
Method Summary
Methods inherited from Vocabulary
#[], [], __prefix__, __prefix__=, _orig_each, _orig_from_sym, camelize, each, each_statement, enum_for, expand_pname, find, find_term, from_graph, from_sym, imported_from, imports, #initialize, inspect, #inspect, limit_vocabs, list, #method_missing, method_missing, ontology, properties, property, register, strict?, to_html, to_iri, to_jsonld, to_s, #to_s, to_ttl, #to_uri, to_uri, value_to_html, 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.
50 51 52 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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 anySimpleType
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.
54 55 56 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
58 59 60 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
62 63 64 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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].
66 67 68 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/lib/rdf/vocab/xsd.rb', line 66 def base64Binary @base64Binary end |
#boolean ⇒ RDF::Vocabulary::Term (readonly)
boolean
represents the values of two-valued logic.
70 71 72 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
74 75 76 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
78 79 80 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
82 83 84 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
86 87 88 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
90 91 92 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
94 95 96 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
98 99 100 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
102 103 104 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
6 7 8 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
10 11 12 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
106 107 108 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.)
110 111 112 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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).
114 115 116 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.)
118 119 120 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/lib/rdf/vocab/xsd.rb', line 118 def gMonthDay @gMonthDay end |
#gYear ⇒ RDF::Vocabulary::Term (readonly)
gYear
represents Gregorian calendar years.
122 123 124 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
126 127 128 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/lib/rdf/vocab/xsd.rb', line 126 def gYearMonth @gYearMonth end |
#hexBinary ⇒ RDF::Vocabulary::Term (readonly)
hexBinary` represents arbitrary hex-encoded binary data.
130 131 132 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
14 15 16 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
18 19 20 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
22 23 24 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
134 135 136 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
138 139 140 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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 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})*
.
142 143 144 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
146 147 148 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
42 43 44 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
26 27 28 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
150 151 152 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
30 31 32 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
34 35 36 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
154 155 156 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
158 159 160 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
162 163 164 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
).
38 39 40 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
166 167 168 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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 {namespace 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].
46 47 48 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
170 171 172 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/lib/rdf/vocab/xsd.rb', line 170 def short @short end |
#string ⇒ RDF::Vocabulary::Term (readonly)
The string
datatype represents character strings in XML.
174 175 176 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
178 179 180 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
182 183 184 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
186 187 188 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
190 191 192 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
194 195 196 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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
.
198 199 200 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/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.
202 203 204 |
# File 'vendor/bundler/ruby/3.3.0/bundler/gems/rdf-cfdeb1f47544/lib/rdf/vocab/xsd.rb', line 202 def yearMonthDuration @yearMonthDuration end |