| CARVIEW |
[contents]
Pointer Methods in RDF 1.0
W3C Editors Draft 27 April 2011
- This version:
- https://www.w3.org/WAI/ER/Pointers/WD-Pointers-in-RDF-20110427
- Latest published version:
- https://www.w3.org/TR/Pointers-in-RDF10/
- Latest internal version:
- https://www.w3.org/WAI/ER/Pointers-in-RDF/
- Previous published version:
- https://www.w3.org/TR/2009/WD-Pointers-in-RDF10-20091029/
- Previous internal version:
- https://www.w3.org/WAI/ER/Pointers/WD-Pointers-20090518
- Editors:
- Carlos Iglesias, Fundación CTIC
- Previous Editors:
- Michael Squillace (until October 2009 while at IBM Corporation)
The terms defined by this document are also provided in RDF Schema format.
Copyright © 2011 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
Abstract
This specification contains a framework for representing pointers - entities that permit identifying a portion or segment of a piece of content - making use of the Resource Description Framework (RDF). It also describes a number of specific types of pointers that permit portions of a document to be referred to in different ways. When referring to a specific part of, say, a piece of web content, it is useful to be able to have a consistent manner by which to refer to a particular segment of a web document, to have a variety of ways by which to refer to that same segment, and to make the reference robust in the face of changes to that document. This specification is part of the Evaluation And Report Language (EARL) but can be reused in other contexts too.
Status of this document
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at https://www.w3.org/TR/.
This 27 April 2011 Editors Draft of the Pointer Methods in RDF 1.0 vocabulary is an update of the previous Pointer Methods in RDF Working Draft of 29 October 2009, and it incorporates all comments received since. This document is part of the Evaluation And Report Language (EARL) but can be reused in other contexts too. This document is intended to be published and maintained as a W3C Working Group Note after review and refinement.
The Evaluation and Repair Tools Working Group (ERT WG) believes it has addressed all issues brought forth through previous Working Draft iterations. The Working Group encourages feedback about this document, Pointer Methods in RDF 1.0, by developers and researchers who have interest in software-supported evaluation and validation of websites, and by developers and researchers who have interest in Semantic Web technologies for content description, annotation, and adaptation. In particular, feedback from the groups involved in the W3C Semantic Web Activity, especially the Semantic Web Coordination Group, the Semantic Web Deployment Working Group, and the Semantic Web Interest Group would be greatly appreciated.
Please send comments on this Pointer Methods in RDF 1.0 document by @@@ to public-earl10-comments@w3.org (publicly visible mailing list archive).
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document has been produced by the Evaluation and Repair Tools Working Group (ERT WG) as part of the Web Accessibility Initiative (WAI) Technical Activity.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. The group does not expect this document to become a W3C Recommendation. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
Table of Contents
- Introduction
- 1.1. Namespaces
- 1.2. Document conventions
- 1.3. Use Cases
- 1.4. Pre-requisites
- Classes
- Properties
- 3.1 groupPointer Property
- 3.2 reference Property
- 3.3 expression Property
- 3.4 version Property
- 3.5 namespace Property
- 3.6 prefix Property
- 3.7 namespaceName Property
- 3.8 offset Property
- 3.9 lineNumber Property
- 3.10 charNumber Property
- 3.12 startPointer Property
- 3.13 endPointer Property
- 3.14 charOffset Property
- 3.15 byteOffset Property
Appendices
1. Introduction
This specification introduces a vocabulary constructed using the Resource Description Framework (RDF), to enable certain parts within a document, particularly HTML and XML documents, to be pointed to in an accurate way. The document introduces a series of RDF classes and properties that can be used to point to parts of a document in different ways.
Note that some pointers may be more appropriated to operate on the character or byte serialization of the resources and others for structured documents, such as XML documents, where character or byte based pointing mechanisms may be considered a bad practice.
The terms defined by this document can be used as part of the W3C Evaluation And Report Language (EARL) and in other contexts too. Developer Guide for Evaluation and Report Language (EARL) 1.0 explains how to implement and use EARL, including conformance requirements for software tools.
1.1. Namespaces
The namespace for Pointer Methods in RDF as specified in this draft is https://www.w3.org/2009/pointers# and uses the ptr prefix. Other namespaces typically used by Pointer Methods in RDF include the following:
cnt- The Representing Content in RDF namespace
https://www.w3.org/2011/content#described in [Content] rdf- The RDF namespace
https://www.w3.org/1999/02/22-rdf-syntax-ns#described in [RDF] rdfs- The RDF Schema namespace
https://www.w3.org/2000/01/rdf-schema#described in [RDFS]
1.2. Document conventions
The keywords must, required, recommended, should, may, and optional are used in accordance with [RFC 2119].
1.3. Use cases
One motivation for this vocabulary stems from methods for reporting test results such as the Evaluation and Report Language (EARL) [EARL] but this need not be its only application. Other typical applications could include:
- Applications dealing with retrieving content and then storing that content in an alternative format
- Applications dealing with the testing and/or repairing of content
- Content-authoring tools that would aid authors in finding problematic or incomplete portions of the content being created or edited
- Aggregation, comparison, or synopsis of the results of applications, such as the aggregation, comparison, or synopsis of test results or reparations
This list is not meant to be exhaustive. This vocabulary is extensible, providing for alternative or enhanced methods for referring to portions of content and for referring to a variety of content types.
1.4. Pre-requisites
Pointer Methods in RDF is defined as an RDF vocabulary. The Resource Description Framework (RDF) is a general-purpose language for describing information in a way that is machine-understandable. The examples will be serialized with the abbreviated RDF/XML notation.
This document assumes the following background knowledge:
- Basic knowledge about the Semantic Web and RDF. For references, consult [RDF], [RDF-PRIMER] and [RDFS].
- Basic knowledge of XML [XML] and its associated technologies.
- Why RDF model is different from the XML model [RDF-XML-DIFFS].
2. Classes
2.1 Pointer Class
Pointer - a method that could be used to point out different parts of electronic documents. It is an abstract class which is intended to be subclassed into more specific ones, and every other type of pointer must be a ptr:Pointer subclass.
This abstract class can not be used directly, one of the more specific refinements contained in this document must be used instead.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
- none
2.2 PointersGroup Class
Pointers Group - a generic container for a group of pointers without any specific relationship between them.
Related Properties
Properties defined by this document:
- in domain of:
- none
- in range of:
Related Classes
While the generic PointersGroup class can be used directly, one of the following more specific refinements should be used instead to provide more information about the existing relationship between the group members:
ptr:RelatedPointers- A group of related pointers you use together for some purpose.
ptr:EquivalentPointers- A group of pointers that point simultaneously to the same part of the document.
2.2.1 RelatedPointers Class
Related Pointers - a group of pointers to be grouped together for some purpose, indicating that the group members (presumably pointing to different parts of the document) have some relationship because they have a meaning as a whole. This is a subclass of the PointersGroup class
Related Properties
Properties defined by this document:
- in domain of:
- none
- in range of:
- none
Examples:
Example 1: A group of related pointers.
<ptr:RelatedPointers rdf:about="#relatedGroup"> <ptr:groupPointer rdf:resource="#relatedPointer1"/> <ptr:groupPointer rdf:resource="#relatedPointer2"/> ... </ptr:RelatedPointers>
2.2.2 EquivalentPointers Class
Equivalent Pointers - a group of pointers that point simultaneously to the same part of the document, so that they can be considered equivalent. Put another way, each pointer in a set of pointers that are identified as equivalent must identify or pick out the same piece of content. This is a subclass of the PointersGroup class
In order to achieve the maximum level of flexibility and interoperability, it is recommended to provide as much equivalent pointers as possible for any case.
Related Properties
Properties defined by this document:
- in domain of:
- none
- in range of:
- none
Examples:
Example 2: A series of equivalent pointers.
<ptr:EquivalentPointers rdf:about="#equivalentGroup"> <ptr:groupPointer rdf:resource="#equivalentPointer1"/> <ptr:groupPointer rdf:resource="#equivalentPointer2"/> <ptr:groupPointer rdf:resource="#equivalentPointer3"/> ... </ptr:EquivalentPointers>
2.3 SinglePointer Class
Single Pointer - a pointing method made up of a unique pointer. This is an abstract single pointer that provides the necessary framework, but it does not provide any kind of pointer, so more specific subclasses must be used.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
Related Classes
This vocabulary already provides several subclasses that refine the SinglePointer class in relation to the way the pointer is defined.
ptr:ExpressionPointer- A single pointer that makes use of expression languages to point out parts of a document.
ptr:OffsetPointer- A single pointer that points out parts of a document by means of an offset number counting from the start of the reference.
ptr:LineCharPointer- A single pointer that points out a part of a document by means of the line number and character position where it is located.
2.3.1 ExpressionPointer Class
Expression Pointer - a single pointer that makes use of expression languages to point out parts of a document. This is a generic expression pointer that could be subclassed for extensibility, more specific subclasses should be used where suitable.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
- none
Related Classes
This vocabulary already provides several subclasses of the ExpressionPointer class depending on the language that is used to define the pointer expression.
ptr:XPathPointer- An expression pointer that makes use of XPath expressions to point out parts of a document.
ptr:CSSSelectorPointer- An expression pointer that points out different parts of a document by means of CSS selectors.
2.3.1.1 XPathPointer Class
XPath Pointer - An expression pointer that makes use of XPath [XPath] expressions to point out parts of a document.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
- none
Related Classes
ptr:NamespaceMapping- An XML Namespace.
ptr:XPointerPointer- An expression pointer that makes use of the XPointer Framework expressions to point out parts of a document.
Examples:
Example 3: An XPathPointer resource with namespace reference.
<ptr:XPathPointer rdf:about="#xPathPointer"> <ptr:version>2.0</ptr:version> <ptr:expression>/html/body/div[@id='header']/img[1]</ptr:expression> <ptr:reference rdf:resource="https://example.org/doc1.html"/> <ptr:namespace rdf:resource="#NamespaceMapping1"/> </ptr:XPathPointer>
2.3.1.1.1 NamespaceMapping Class
Namespace Mapping - an XML namespace mapping as defined by [Namespaces].
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
Examples:
Example 4: A NamespaceMapping resource indicating prefix and name.
<ptr:NamespaceMapping rdf:about="#NamespaceMapping1"> <ptr:prefix>eg</ptr:prefix> <ptr:namespaceName>https://example.org/ns/</ptr:namespaceName> </ptr:NamespaceMapping>
2.3.1.1.2 XPointerPointer Class
XPointer Pointer - an expression pointer that makes use of xpointer() scheme [XPointer-SCH] expressions to point out parts of a document.
Related Properties
Properties defined by this document:
- in domain of:
- none
- in range of:
- none
Examples:
Example 5: An XPointerPointer resource.
<ptr:XPointerPointer rdf:about="#xPointerPointer"> <ptr:expression>string-range(//P,"Thomas Pynchon")[3],"P",1,0)</ptr:expression> <ptr:reference rdf:resource="https://example.org/doc1.html"/> </ptr:XPointerPointer>
2.3.1.2 CSSSelectorPointer Class
CSS Selector Pointer - an expression pointer that points out parts of a document by means of a CSS expression.
Related Properties
Properties defined by this document:
- in domain of:
- none
- in range of:
- none
Examples:
Example 6: A CSSSelector resource with version information.
<ptr:CSSSelectorPointer rdf:about="#cssSelectorPointer"> <ptr:reference rdf:resource="https://example.org/doc1.html"/> <ptr:expression>body > p#important</ptr:expression> <ptr:version>2.1</ptr:version> </ptr:CSSSelectorPointer>
2.3.2 OffsetPointer Class
Offset Pointer - a single pointer that points out parts of a document by means of an offset number counting from the start of the reference.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
- none
Related Classes
While the generic OffsetPointer class can be used directly, one of the following more specific refinements should be used instead to provide more information about the type of offset that is being used.
ptr:CharOffsetPointer- A single pointer that points out parts of a document by means of a character offset from the start of the reference.
ptr:ByteOffsetPointer- A single pointer that points out parts of a document by means of a byte offset from the start of the reference.
2.3.2.1 CharOffsetPointer Class
Char Offset Pointer - a single pointer that points out parts of a document by means of a character offset from the start of the reference.
Related Properties
Properties defined by this document:
- in domain of:
- none
- in range of:
- none
Examples:
Example 7: A CharOffsetPointer resource.
<ptr:CharOffsetPointer rdf:about="#charOffsetPointer"> <ptr:reference rdf:resource="https://example.org/doc1.html"/> <ptr:offset>335</ptr:offset> </ptr:CharOffsetPointer>
2.3.2.2 ByteOffsetPointer Class
Byte Offset Pointer - a single pointer that points out parts of a document by means of a byte offset from the start of the reference.
Related Properties
Properties defined by this document:
- in domain of:
- none
- in range of:
- none
Examples:
Example 8: A ByteOffsetPointer resource.
<ptr:ByteOffsetPointer rdf:about="#byteOffsetPointer"> <ptr:reference rdf:resource="https://example.org/doc1.html"/> <ptr:offset>52</ptr:offset> </ptr:ByteOffsetPointer>
2.3.3 LineCharPointer Class
Line Char Pointer - a single pointer that points out parts of a document by means of the line number and character position where the target is localized.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
- none
Examples:
Example 9: A LineCharPointer resource.
<ptr:LineCharPointer rdf:about="#lineCharPointer"> <ptr:reference rdf:resource="https://example.org/doc1.html"/> <ptr:lineNumber>5</ptr:lineNumber> <ptr:charNumber>18</ptr:charNumber> </ptr:LineCharPointer>
2.4 CompoundPointer Class
Compound Pointer - a pointing method made up of a pair of pointers that identify a well defined section within a document delimited by a begin and an end.
This is an abstract compound pointer that provides the necessary framework, but it does not constitute a complete compound pointer, as it only defines the start point of the section. One of the more specific subclasses must be used instead.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
- none
Related Classes
ptr:StartEndPointer- A compound pointer that points out parts of a document by means of a range delimited by a start point and an end point.
ptr:CharSnippetCompoundPointer- A compound pointer that points out parts of a document by means of a range delimited by a starting point and a character snippet from that starting point.
ptr:CharOffsetCompoundPointer- A compound pointer that points out parts of a document by means of a range delimited by a starting point and a character offset from that starting point.
ptr:ByteSnippetCompoundPointer- A compound pointer that points out parts of a document by means of a range delimited by a starting point and a byte snippet from that starting point.
ptr:ByteOffsetCompoundPointer- A compound pointer that points out parts of a document by means of a range delimited by a starting point and a byte offset from that starting point.
2.4.1 StartEndPointer Class
Start End Pointer - a compound pointer pointing out parts of a document by means of a range delimited by a pair of single pointers that define the start point and the end point.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
- none
Examples:
Example 10: A StartEndPointer resource making use of the CharOffsetPointer from example 7 and the LineCharPointer from example 9.
<ptr:StartEndPointer rdf:about="#startEndPointer"> <ptr:startPointer rdf:resource="#lineCharPointer"/> <ptr:endPointer rdf:resource="#charOffsetPointer"/> </ptr:StartEndPointer>
2.4.2 CharSnippetCompoundPointer Class
Char Snippet Compound Pointer - a compound pointer pointing out parts of a document by means of a range delimited by a single pointer that defines the start point and a character snippet from there.
Related Properties
Properties defined by this document:
- in domain of:
- none
- in range of:
- none
Properties not defined by this document:
cnt:chars
- Character string representing the character sequence of the given content.
Examples:
Example 11: A CharSnippetCompoundPointer resource.
<ptr:CharSnippetCompoundPointer rdf:about="#charSnippetCompoundPointer"> <ptr:startPointer rdf:resource="#charOffsetPointer"/> <cnt:chars><p>Some text.</p></cnt:chars> </ptr:CharSnippetCompoundPointer>
2.4.3 CharOffsetCompoundPointer Class
Char Offset Compound Pointer - a compound pointer pointing out parts of a document by means of a range delimited by a single pointer that defines the start point and a character offset from there.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
- none
Examples:
Example 12: A CharOffsetCompoundPointer resource.
<ptr:CharOffsetCompoundPointer rdf:about="#charOffsetCompoundPointer"> <ptr:startPointer rdf:resource="#XPathPointer"/> <ptr:charOffset>55</ptr:charOffset> </ptr:CharOffsetCompoundPointer>
2.4.4 ByteSnippetCompoundPointer Class
Byte Snippet Compound Pointer - a compound pointer pointing out parts of a document by means of a range delimited by a single pointer that defines the start point and a byte snippet from there.
Related Properties
Properties defined by this document:
- in domain of:
- none
- in range of:
- none
Properties not defined by this document:
cnt:bytes- Character string representing the Base64 encoded byte sequence of the given content.
Examples:
Example 13: A ByteSnippetCompoundPointer resource.
<ptr:ByteSnippetCompoundPointer rdf:about="#byteSnippetCompoundPointer">
<ptr:startPointer rdf:resource="#byteOffsetPointer"/>
<cnt:bytes>R0lGODlhtQAxAOYAAKynpv3t4v3j1P/59ZuXlveYZ/vDovvMsfBbGWRiYf7+{...}</cnt:bytes>
</ptr:ByteSnippetCompoundPointer>
2.4.5 ByteOffsetCompoundPointer Class
Byte Offset Compound Pointer - a compound pointer pointing out parts of a document by means of a range delimited by a single pointer that defines the start point and a byte offset from there.
Related Properties
Properties defined by this document:
- in domain of:
- in range of:
- none
Examples:
Example 14: A ByteOffsetCompoundPointer resource.
<ptr:ByteOffsetCompoundPointer rdf:about="#byteOffsetCompoundPointer"> <ptr:startPointer rdf:resource="#byteOffsetPointer"/> <ptr:byteOffset>255</ptr:byteOffset> </ptr:ByteOffsetCompoundPointer>
3. Properties
3.1 groupPointer Property
A reference to a specific pointer.
A PointersGroup will have one groupPointer property per each of the pointers it contains. As any group of pointers must have one or more pointers, instances of the PointersGroup class must have at least one instance of the groupPointer property.
- Domain:
ptr:PointersGroup- Range:
ptr:Pointer
3.2 reference Property
The document within which the pointer is applicable or meaningful.
A SinglePointer must have exactly one reference.
- Domain:
ptr:SinglePointer- Range:
- none
3.3 expression Property
The language expression used as pointer.
An ExpressionPointer must have exactly one expression.
- Domain:
ptr:ExpressionPointer- Range:
- Literal
3.4 version Property
The language version used in the pointer expression.
An ExpressionPointer must have at most one version.
- Domain:
ptr:ExpressionPointer- Range:
- Literal
3.5 namespace Property
The namespace within an XPath expression operates.
- Domain:
ptr:XPathPointer- Range:
ptr:NamespaceMapping
3.6 prefix Property
Associates element and attribute names with a namespace URI.
An NamespaceMapping must have exactly one prefix
- Domain:
ptr:NamespaceMapping- Range:
- none
3.7 namespaceName Property
Identifies the namespace.
A NamespaceMapping must have exactly one namespace
- Domain:
ptr:NamespaceMapping- Range:
- none
3.8 offset Property
The target position counting from the start of the referenced document. The count will start at one in each document.
An OffsetPointer must have exactly one offset
- Domain:
ptr:OffsetPointer- Range:
- Positive Integer
3.9 lineNumber Property
The line number where the target is localized. The line count will start at one in each document.
A LineCharPointer must have exactly one lineNumber.
- Domain:
ptr:LineCharPointer- Range:
- Positive Integer
3.10 charNumber Property
The character number where the target is localized within a line. The character count will start at one in each line.
A LineCharPointer must have at most one charNumber.
- Domain:
ptr:LineCharPointer- Range:
- Positive Integer
3.12 startPointer Property
Reference to the pointer that defines the beginning point for a range.
A CompoundPointer must have exactly one startPointer.
- Domain:
ptr:CompoundPointer- Range:
ptr:SinglePointer
3.13 endPointer Property
Reference to the pointer that defines the end point for a range.
A StartEndPointer must have exactly one endPointer.
- Domain:
ptr:StartEndPointer- Range:
ptr:SinglePointer
3.14 charOffset Property
The position of the end of a range from a startPointer, expressed by the number of characters that conform the range, and being the first character of the range that one indicated by the startPointer.
A CharOffsetCompoundPointer must have exactly one charOffset.
- Domain:
ptr:CharOffsetCompoundPointer- Range:
- Positive Integer
3.15 byteOffset Property
The position of the end of a range from a startPointer, expressed by the number of bytes that conform the range, and being the first byte of the range that one indicated by the startPointer.
A ByteOffsetCompoundPointer must have exactly one byteOffset.
- Domain:
ptr:ByteOffsetCompoundPointer- Range:
- Positive Integer
Appendix A: Vocabulary Terms
The following terms are defined by this specification:
Classes
| Class name | Label | Suggested types | Required properties | Optional properties |
|---|---|---|---|---|
ptr:ByteOffsetPointer |
Byte Offset Pointer | ptr:offset, ptr:reference |
||
ptr:ByteOffsetCompoundPointer |
Byte Offset Compound Pointer | ptr:byteOffset, ptr:startPointer |
||
ptr:ByteSnippetCompoundPointer |
Byte Snippet Compound Pointer | cnt:bytes , ptr:startPointer |
||
ptr:CharOffsetPointer |
Char Offset Pointer | ptr:offset, ptr:reference |
||
ptr:CharOffsetCompoundPointer |
Char Offset Compound Pointer | ptr:charOffset, ptr:startPointer |
||
ptr:CharSnippetCompoundPointer |
Char Snippet Compound Pointer | cnt:chars , ptr:startPointer |
||
ptr:CSSSelectorPointer |
CSS selector Pointer | ptr:expression, ptr:reference |
ptr:version |
|
ptr:EquivalentPointers |
Equivalent Pointers | ptr:groupPointer |
||
ptr:ExpressionPointer |
Expression Pointer | ptr:CSSSelectorPointer, ptr:XPathPointer, ptr:XPointerPointer | ptr:expression, ptr:reference |
ptr:version |
ptr:LineCharPointer |
Line-Char Pointer | ptr:lineNumber, ptr:reference |
ptr:charNumber |
|
ptr:NamespaceMapping |
NamespaceMapping | ptr:namespaceURI, ptr:prefix |
||
ptr:OffsetPointer |
Offset Pointer | ptr:ByteOffsetPointer, ptr:CharOffsetPointer | ptr:offset |
|
ptr:Pointer |
Pointer | ptr:PointersGroup, ptr:CompoundPointer, ptr:SinglePointer | ||
ptr:PointersGroup |
Pointers Group | ptr:EquivalentPointers, ptr:RelatedPointers | ptr:groupPointer |
|
ptr:CompoundPointer |
Compound Pointer | ptr:StartEndPointer, ptr:CharSnippetCompoundPointer, ptr:CharOffsetCompoundPointer, ptr:ByteSnippetCompoundPointer, ptr:ByteOffsetCompoundPointer | ptr:startPointer |
|
ptr:RelatedPointers |
Related Pointers | ptr:groupPointer |
||
ptr:SinglePointer |
Single Pointer | ptr:OffsetPointer, ptr:ExpressionPointer, ptr:LineCharPointer, | ptr:reference |
|
ptr:StartEndPointer |
Start-End Pointer | ptr:endPointer, ptr:startPointer |
||
ptr:XPathPointer |
XPath Pointer | ptr:expression, ptr:reference |
ptr:namespace, ptr:version |
|
ptr:XPointerPointer |
XPointer Pointer | ptr:expression, ptr:reference |
ptr:namespace, ptr:version |
Properties
| Property name | Label | Domain | Range | Restriction |
|---|---|---|---|---|
ptr:byteOffset |
byte offset | ptr:ByteOffsetCompoundPointer |
Positive Integer | Exactly one per ptr:ByteOffsetCompoundPointer |
ptr:charNumber |
char number | ptr:LineCharPointer |
Positive Integer | At most one per ptr:LineCharPointer |
ptr:charOffset |
char offset | ptr:CharOffsetCompoundPointer |
Positive Integer | Exactly one per ptr:CharOffsetCompoundPointer |
ptr:endPointer |
end pointer | ptr:StartEndPointer |
ptr:SinglePointer |
Exactly one per ptr:StartEndPointer |
ptr:expression |
expression | ptr:ExpressionPointer |
Literal | Exactly one per ptr:ExpressionPointer |
ptr:lineNumber |
line number | ptr:LineCharPointer |
Positive Integer | Exactly one per ptr:LineCharPointer |
ptr:namespace |
namespace | ptr:XPathPointer |
ptr:namespaceMapping |
|
ptr:namespaceURI |
namespace URI | ptr:NamespaceMapping |
Exactly one per ptr:NamespaceMapping |
|
ptr:offset |
offset | ptr:OffsetPointer |
Positive Integer | Exactly one per ptr:OffsetPointer and ptr:StartOffsetPointer |
ptr:groupPointer |
group pointer | ptr:PointersGroup |
ptr:Pointer |
At least one per ptr:PointerGroup |
ptr:prefix |
prefix | ptr:NamespaceMapping |
Literal | Exactly one per ptr:NamespaceMapping |
ptr:reference |
reference | ptr:SinglePointer |
Exactly one per ptr:SinglePointer |
|
ptr:startPointer |
start pointer | ptr:CompoundPointer |
ptr:SinglePointer |
Exactly one per ptr:CompoundPointer |
ptr:version |
version | ptr:ExpressionPointer |
Literal | At most one per ptr:ExpressionPointer |
Appendix B: References
- [Content]
- Representing Content in RDF
https://www.w3.org/TR/Content-in-RDF10/ - [EARL]
- Evaluation and Report Language (EARL) 1.0 Schema
https://www.w3.org/TR/EARL10-Schema/ - [Namespaces]
- Namespaces in XML 1.1 (Second Edition) - W3C Recommendation, 16 August 2006. T. Bray, D. Hollander, A. Layman, R. Tobin eds.
https://www.w3.org/TR/2006/REC-xml-names11-20060816 - [RDF]
- RDF/XML Syntax Specification (Revised) - W3C Recommendation, 10 February 2004. D. Beckett ed.
https://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210/ - [RDF-PRIMER]
- RDF Primer - W3C Recommendation, 10 February 2004. F. Manola, E.Miller eds.
https://www.w3.org/TR/rdf-primer/ - [RDFS]
- RDF Vocabulary Description Language 1.0: RDF Schema - W3C Recommendation, 10 February 2004. D. Brickley, R.V. Guha eds.
https://www.w3.org/TR/rdf-schema/ - [RDF-XML-DIFFS]
- Why RDF model is different from the XML model - Paper, September 1998. T. Berners-Lee.
https://www.w3.org/DesignIssues/RDF-XML - [RFC 2119]
- Key words for use in RFCs to Indicate Requirement Levels - IETF RFC, March 1997.
https://www.ietf.org/rfc/rfc2119.txt - [XML]
- Extensible Markup Language (XML) 1.0 (Fourth Edition). W3C Recommendation 16 August 2006, edited in place 29 September 2006. T. Bray, J. Paoli, C.M. Sperberg-McQueen, E. Maler, F. Yergeau eds.
https://www.w3.org/TR/xml/ - [XPath]
- XML Path Language (XPath) 1.0. W3C Recommendation 16 November 1999. J. Clark, S. DeRose eds.
https://www.w3.org/TR/1999/REC-xpath-19991116 - [XPointer-SCH]
- XPointer xpointer() scheme. W3C Working Draft 19 December 2002. S. DeRose, E. Maler, R. Daniel eds.
https://www.w3.org/TR/2002/WD-xptr-xpointer-20021219/
Appendix C: Contributors
Contributors to this Working Draft: Shadi Abou-Zahra, Sandor Herramhof, Carlos Iglesias, Nick Kew, Johannes Koch, Jim Ley, Charles McCathieNevile, Chris Ridpath, Christophe Strobbe, Michael Squillace and Carlos Velasco.
Appendix D: Document Changes
There are only editorial changes and references updates since 29 October, 2009 Working Draft