RDFa Core 1.1

4.1 RDFa Processor Conformance

A conforming RDFa Processor must make available to a consuming application a single RDF graph containing all possible triples generated by using the rules in the Processing Model section. This specification uses the term default output graph to mean all of the triples asserted by a document according to the Processing Model section. The term processor graph is used to denote the collection of all informational, warning, and error triples that may be generated by the RDFa Processor to report its status . The default output graph and the processor graph are separate graphs and must not be stored in the same graph by the RDFa Processor.

A conforming RDFa Processor may make available additional triples that have been generated using rules not described here, but these triples must not be made available in the default output graph . (Whether these additional triples are made available in one or more additional RDF graph s is implementation-specific, and therefore not defined here.)

A conforming RDFa Processor must preserve white space in both plain literal s and XML literals . However, it may be the case that the architecture in which a processor operates has made changes to the white space in a document before that document ever reaches the RDFa Processor (e.g., [ XMLSCHEMA-1 ] processors are permitted to 'normalize' white space in attribute values - see section 3.1.4). To ensure maximum consistency between processing environments, authors should remove any unnecessary white space in their plain and XML Literal content.

A conforming RDFa Processor must examine the media type of a document it is processing to determine the document's Host Language. If the RDFa Processor is unable to determine the media type, or does not support the media type, the RDFa Processor must process the document as if it were media type application/xml . See XML+RDFa Document Conformance . A Host Language may specify additional announcement mechanisms.

A conforming RDFa Processor may use additional mechanisms (e.g., the DOCTYPE, a file extension, the root element) to attempt to determine the Host Language if the media type is unavailable. These mechanisms are unspecified.

4.2 RDFa Host Language Conformance

Host Languages that incorporate RDFa must adhere to the following:

• All of the facilities required in this specification must be included in the Host Language.
• The attributes defined in this specification must be included in the content model of the Host Language.
• If the Host Language uses XML Namespaces [ XML-NAMES ], the attributes in this specification should be defined in 'no namespace'. (e.g., when the attributes are used on elements in the Host Language's namespace, they can be used with no qualifying prefix: <myml:myElement property="next"> property="next"> ). When a Host Language does not use the attributes in 'no namespace', they must be referenced via the XHTML Namespace ( http://www.w3.org/1999/xhtml ).
• If the Host Language has its own definition for any attribute defined in this specification, that definition must be such that the processing required by this specification remains possible when the attribute is used in a way consistent with the requirements herein.
• The Host Language may require the automatic inclusion of one or more default RDFa Profiles. If it does, the RDFa Profile triples that establish term or URI mappings must not change without changing the associated profile URI. RDFa Processors may embed, cache, or retrieve the RDFa Profile triples associated with that profile. Maintainers of Host Languages are required to change specify an initial context (e.g., the URI definition of terms, IRI mappings, and/or a default profile if items are removed from the default profile document. The URI change is required to accommodate RDFa Processors that statically embed vocabulary IRI). Such an initial context should be defined using the terms conventions defined in the profile. The working group expects default RDFa Profiles to change very rarely. Initial Contexts .

4.3 XML+RDFa Document Conformance

This specification does not define a stand-alone document type. The attributes herein are intended to be integrated into other host languages (e.g., HTML+RDFa or XHTML+RDFa). However, this specification does define processing rules for generic XML documents - that is, those documents delivered as media types text/xml or application/xml . Such documents must meet all of the following criteria:

1. The document must be well-formed as defined in [ XML10-4e ].
2. The document must use the attributes defined in this specification in 'no namespace'. through references to the XHTML namespace ( http://www.w3.org/1999/xhtml ).

When an RDFa Processor processes an XML+RDFa document, it does so in via the following context: initial context :

1. The default vocabulary URI There is undefined. The no default collection of terms terms.
2. There are no default IRI mappings.
3. There is defined via an RDFa Profile document at http://www.w3.org/profile/rdfa-1.1 . no default vocabulary IRI.
4. The base can be set using the @xml:base attribute as defined in [ XML10-4e ].
5. The current language can be set using @xml:lang attribute.

5.1 White space within attribute values

Many attributes accept a white space separated list of tokens. This specification defines white space as:

whitespace      ::=  (#x20 | #x9 | #xD | #xA)+ 

When attributes accept a white space separated list of tokens, an RDFa Processor must ignore any leading or trailing white space.

This definition is consistent with the definition found in [ XML10 ].

7.1 Overview

Evaluating a document for RDFa triples is carried out by starting at the document object, and then visiting each of its child elements in turn, in document order, applying processing rules. Processing is recursive in that for each child element the processor also visits each of its child elements, and applies the same processing rules.

In some environments there will be little difference between starting at the root element of the document, and starting at the document object itself. It is defined this way because in some environments important information is present at the document object level which is not present on the root element.

As processing continues, rules are applied which may generate triples, and may also change the evaluation context information that will then be used when processing descendant elements.

This specification does not say anything about what should happen to the triples generated, or whether more triples might be generated during processing than are outlined here. However, to be conforming, an RDFa Processor must act as if at a minimum the rules in this section are applied, and a single RDF graph produced. As described in the RDFa Processor Conformance section, any additional triples generated must not appear in the default output graph .

7.2 Evaluation Context

During processing, each rule is applied using information provided by an evaluation context . An initial context is created when processing begins. That context has the following members:

• The base . This will usually be the URI IRI of the document being processed, but it could be some other URI, IRI, set by some other mechanism, such as the (X)HTML base element. The important thing is that it establishes a URI an IRI against which relative paths can be resolved.
• The parent subject . The initial value will be the same as the initial value of base , but it will usually change during the course of processing.
• The parent object . In some situations the object of a statement becomes the subject of any nested statements, and this property is used to convey this value. Note that this value may be a bnode , since in some situations a number of nested statements are grouped together on one bnode . This means that the bnode must be set in the containing statement and passed down, and this property is used to convey this value.
• A list of current, in-scope URI IRI mappings .
• A list of incomplete triple s. A triple can be incomplete when no object resource is provided alongside a predicate that requires a resource (i.e., @rel or @rev ). The triples can be completed when a resource becomes available, which will be when the next subject is specified (part of the process called chaining ).
• A list mapping mapping IRIs to lists.
• The language . Note that there is no default language.
• The term mappings , a list of terms and their associated URIs. IRIs. This specification does not define an initial list. Host Languages may define an initial list. If a Host Language provides an initial list, it should do so via an RDFa Profile.
• The default vocabulary , a value to use as the prefix URI IRI when a term is used. This specification does not define an initial setting for the default vocabulary. Host Languages may define an initial setting. If a Host Language defines an initial setting, it should do so via an RDFa Profile document.

During the course of processing, new evaluation context s are created which are passed to each child element. The rules described below will determine the values of the items in the context. Additionally, some rules will cause new triples to be created by combining information provided by an element with information from the evaluation context .

During the course of processing a number of locally scoped values are needed, as follows:

• An initially empty list of URI IRI mapping s, called the local list of URI IRI mappings .
• An initially empty list of incomplete triples , called the local list of incomplete triples .
• An initially empty language value.
• A skip element flag, which indicates whether the current element can safely be ignored since it has no relevant RDFa attributes. Note that descendant elements will still be processed.
• A new subject value, which once calculated will set the parent subject property in an evaluation context , as well as being used to complete any incomplete triple s, as described in the next section.
• A value for the current object literal , the literal to use when creating triples that have a literal object.
• A value for the current object resource , the resource to use when creating triples that have a resource object.
• The local term mappings , a list of terms and their associated URIs. IRIs.
• The local list mapping , mapping IRIs to lists
• A local default vocabulary , a URI an IRI to use as a prefix mapping when a term is used.

7.3 Chaining

Statement chaining is an RDFa feature that allows the author to link RDF statements together while avoiding unnecessary repetitive markup. For example, if an author were to add statements as children of an object that was a resource, these statements should be interpreted as being about that resource:

<div about="http://dbpedia.org/resource/Albert_Einstein">
  <span property="foaf:name">Albert Einstein</span>
  <span property="dbp:dateOfBirth" datatype="xsd:date">1879-03-14</span>
  <div rel="dbp:birthPlace" resource="http://dbpedia.org/resource/German_Empire">
    <span property="dbp:conventionalLongName">the German Empire</span>

  </div>
</div>

In this example we can see that an object resource ('German_Empire'), has become the subject for nested statements. This markup also illustrates the basic chaining pattern of 'A has a B has a C' (i.e., Einstein has a birth place of the German Empire, which has a long name of "the "the German Empire"). Empire").

It's also possible for the subject of nested statements to provide the object for containing statements — essentially the reverse of the example we have just seen. To illustrate, we'll take an example of the type of chaining just described, and show how it could be marked up more efficiently. To start, we mark up the fact that Albert Einstein had, at some point in his life, a residence both in the German Empire and in Switzerland:

<div about="http://dbpedia.org/resource/Albert_Einstein">
  <div rel="dbp-owl:residence" resource="http://dbpedia.org/resource/German_Empire"></div>
  <div rel="dbp-owl:residence" resource="http://dbpedia.org/resource/Switzerland"></div>
</div>

Now, we show the same information, but this time we create an incomplete triple from the residence part, and then use any number of further subjects to 'complete' that triple, as follows:

<div about="http://dbpedia.org/resource/Albert_Einstein" rel="dbp-owl:residence">
  <span about="http://dbpedia.org/resource/German_Empire"></span>
  <span about="http://dbpedia.org/resource/Switzerland"></span>
</div>

In this example, the incomplete triple actually gets completed twice, once for the German Empire and once for Switzerland, giving exactly the same information as we had in the earlier example:

<http://dbpedia.org/resource/Albert_Einstein>
  dbp-owl:residence <http://dbpedia.org/resource/German_Empire> .
<http://dbpedia.org/resource/Albert_Einstein>
dbp-owl:residence
<http://dbpedia.org/resource/Switzerland>
.

Chaining can sometimes involve elements containing relatively minimal markup, for example showing only one resource, or only one predicate. Here the img element is used to carry a picture of Einstein:

<div about="http://dbpedia.org/resource/Albert_Einstein">
  <div rel="foaf:depiction">
    <img src="http://en.wikipedia.org/wiki/Image:Albert_Einstein_Head.jpg" />

  </div>
</div>

When such minimal markup is used, any of the resource-related attributes could act as a subject or an object in the chaining:

<div about="http://dbpedia.org/resource/Albert_Einstein">
  <div rel="dbp-owl:residence">
    <span about="http://dbpedia.org/resource/German_Empire"></span>
    <span about="http://dbpedia.org/resource/Switzerland"></span>

  </div>
</div>

7.4 CURIE and URI IRI Processing

Since RDFa is ultimately a means for transporting RDF, a key concept is the resource and its manifestation as a URI. IRI. RDF deals with complete URIs IRIs (not relative paths); when converting RDFa to triples, any relative URIs IRIs must be resolved relative to the base URI, IRI, using the algorithm defined in section 5 6.5 of RFC 3986 3987 [ URI RFC3987 ], Reference Resolution . The values of RDFa attributes that refer to URIs IRIs use three different datatypes: URI , SafeCURIEorCURIEorURI SafeCURIEorCURIEorIRI , or TERMorCURIEorAbsURI TERMorCURIEorAbsIRI . All these attributes are mapped, after processing, to URIs. IRIs. The handling of these attributes is as follows:

URI

The content is a URI, and is used as such.

SafeCURIEorCURIEorURI SafeCURIEorCURIEorIRI

• When the value is surrounded by square brackets, then the content within the brackets is evaluated as a CURIE according to the CURIE Syntax definition . If it is not a valid CURIE, the value must be ignored.
• Otherwise, the value is evaluated as a CURIE. If it is a valid CURIE, the resulting URI IRI is used; otherwise, the value is processed as a URI. an IRI.

TERMorCURIEorAbsURI TERMorCURIEorAbsIRI

• If the value is an NCName , then it is evaluated as a term according to General Use of Terms in Attributes . Note that this step may mean that the value is to be ignored.
• If the value is a valid CURIE, then the resulting URI IRI is used.
• If the value is an absolute URI, IRI, that value is used.
• Otherwise, the value is ignored.

Note that it is possible for all values in an attribute to be ignored. When that happens, the attribute must be treated as if it were empty.

For example, the full URI IRI for Albert Einstein on DBPedia is:

http://dbpedia.org/resource/Albert_Einstein

This can be shortened by authors to make the information easier to manage, using a CURIE. The first step is for the author to create a prefix mapping that links a prefix to some leading segment of the URI. IRI. In RDFa these mappings are expressed using the XML namespace syntax:

<div prefix="db: http://dbpedia.org/">
  ...
</div>

Once the prefix has been established, an author can then use it to shorten a URI an IRI as follows:

<div prefix="db: http://dbpedia.org/">
  <div about="db:resource/Albert_Einstein">

    ...
  </div>
</div>

The author is free to split the URI IRI at any point, as long as it begins at the left end. However, since a common use of CURIEs is to make available libraries of terms and values, the prefix will usually be mapped to some common segment that provides the most re-use, often provided by those who manage the library of terms. For example, since DBPedia contains an enormous list of resources, it is more efficient to create a prefix mapping that uses the base location of the resources:

<div prefix="dbr: http://dbpedia.org/resource/">
  <div about="dbr:Albert_Einstein">

    ...
  </div>
  <div about="">

  <div about="dbr:Baruch_Spinoza">

    ...
  </div>
</div>

<div prefix="dbr: http://dbpedia.org/resource/">
  <div about="dbr:Albert_Einstein">

    ...
  </div>
</div>
<div >
  <div about="">

<div prefix="dbr: http://someotherdb.org/resource/">
  <div about="dbr:Albert_Einstein">

    ...
  </div>
</div>

<div about="http://dbpedia.org/resource/Albert_Einstein">
  ...
</div>

<div about="dbr:Albert_Einstein">
  ...
</div>

<div about="[dbr:Albert_Einstein]">
  ...
</div>

<div about="[Albert_Einstein]">
  ...
</div>

<div about="Albert_Einstein">
  ...
</div>

term     ::=  NCName

<link rel="next" href="http://example.org/page2.html" />
<link
rel="

rel="


xhv:next

"
href="http://example.org/page2.html"

"
href="http://example.org/page2.html"

/>

<>
<http://www.w3.org/1999/xhtml/vocab#next>
<http://example.org/page2.html>
.

<link about="_:john" rel="foaf:mbox"
  href="mailto:john@example.org" />
<link about="_:sue" rel="foaf:mbox"
  href="mailto:sue@example.org" />
<link about="_:john" rel="foaf:knows"
resource="_:sue"

/>

_:john foaf:mbox <mailto:john@example.org> .
_:sue foaf:mbox <mailto:sue@example.org> .
_:john
foaf:knows
_:sue
.

7.5 Sequence

Processing would normally begin after the document to be parsed has been completely loaded. However, there is no requirement for this to be the case, and it is certainly possible to use a stream-based approach, such as SAX [ SAX ] to extract the RDFa information. However, if some approach other than the DOM traversal technique defined here is used, it is important to ensure that Host Language-specific processing rules are applied (e.g., XHTML+RDFa [ XHTML-RDFA ] indicates the base element can be used, and base will affect the interpretation of URIs IRIs in meta or link elements even if those elements are before the base element in the stream).

At the beginning of processing, an initial evaluation context is created, as follows:

• the base is set to the URI IRI of the document (or another value specified in a language specific manner such as the HTML base element);
• the parent subject is set to the base value;
• the parent object is set to null;
• the list of incomplete triples is empty;
• the list mapping is empty;
• the language is set to null.
• the list of URI IRI mappings is empty (or a list defined in the Host Language-defined default RDFa Profile).
• the term mappings is set to null (or a list defined in the Host Language-defined default RDFa Profile).
• the default vocabulary is set to null (or a URI an IRI defined in the Host Language-defined default RDFa Profile).

Processing begins by applying the processing rules below to the document object, in the context of this initial evaluation context . All elements in the tree are also processed according to the rules described below, depth-first, although the evaluation context used for each set of rules will be based on previous rules that may have been applied.

This specification defines processing rules for optional attributes that may not be present in all Host Languages (e.g., @xmlns: ). If these attributes are not supported in the Host Language, then the corresponding processing rules are not relevant for that language.

The processing rules are:

1. First, the local values are initialized, as follows:
   • the skip element flag is set to 'false';
   • new subject is set to null;
   • current object resource is set to null;
   • the local list of URI IRI mappings is set to the list of URI IRI mappings from the evaluation context ;
   • the local list of incomplete triples is set to null;
   • the list mapping is set to (a reference of) the list mapping from the evaluation context ;
   • the current language value is set to the language value from the evaluation context .
   • the local term mappings is set to the term mappings from the evaluation context .
   • the local default vocabulary is set to the default vocabulary from the evaluation context .
   Note that some of the local variables are temporary containers for values that will be passed to descendant elements via an evaluation context . In some cases the containers will have the same name, so to make it clear which is being acted upon in the following steps, the local version of an item will generally be referred to as such.
Next the current element is parsed for any updates to the local term mappings , default vocabulary , and local list of URI mappings via @profile . If @profile is present, its value is processed as defined in RDFa Profiles . If any referenced RDFa Profile is not recognized , then the current element and its children must not place any triples in the default graph . Any new terms or URI mappings are merged into respective local lists. They are in effect for this element and for its children.
2. Next the current element is examined for any change to the default vocabulary via @vocab . If @vocab is present and contains a value, its value updates the local default vocabulary . If the value is empty, then the local default vocabulary must be reset to the Host Language defined default. default (if any).
   The value of @vocab is used to generate a triple as follows:

   subject

   base

   predicate

   http://www.w3.org/ns/rdfa#hasVocabulary

   object

   value from @vocab

   A Host Language is not required to define a default vocabulary. In such a case, setting @vocab to the empty value has the effect of clearing the local default vocabulary .
3. Next, the current element is examined for URI IRI mapping s and these are added to the local list of URI IRI mappings . Note that a URI IRI mapping will simply overwrite any current mapping in the list that has the same name;
   Mappings are defined via @prefix . Values in this attribute are evaluated from beginning to end (e.g., left to right in typical documents). For backward compatibility, RDFa Processors should also permit the definition of mappings via @xmlns . In this case, the value to be mapped is set by the XML namespace prefix, and the value to map is the value of the attribute — a URI. an IRI. (Note that prefix mapping via @xmlns is deprecated, and may be removed in a future version of this specification.) When xmlns is supported, such mappings must be processed before processing an mappings from @prefix on the same element. Regardless of how the mapping is declared, the value to be mapped must be converted to lower case , and the URI IRI is not processed in any way; in particular if it is a relative path it must not be resolved against the current base . Authors should not use relative paths as the URI. IRI.
4. The current element is also parsed for any language information, and if present, current language is set accordingly;
   Host Languages that incorporate RDFa may provide a mechanism for specifying the natural language of an element and its contents (e.g., XML provides the general-purpose XML attribute @xml:lang ).
5. If the current element contains no @rel or @rev attribute, then the next step is to establish a value for new subject . Any of the attributes that can carry a resource can set new subject ;
   new subject is set to the URI IRI obtained from the first match from the following rules:

   • by using the URI IRI from @about , if present, obtained according to the section on CURIE and URI IRI Processing ;
   • otherwise , by using the URI IRI from @src @resource , if present, obtained according to the section on CURIE and URI IRI Processing . ;
   • otherwise , by using the URI from @resource @href , if present, obtained according to the section on CURIE and URI IRI Processing ; .
   • otherwise , by using the URI from @href @src , if present, obtained according to the section on CURIE and URI IRI Processing .

   If no URI IRI is provided by a resource attribute, then the first match from the following rules will apply:

   • if the element is the root element of the document, then act as if there is an empty @about present, and process it according to the rule for @about , above;
   • if @typeof is present, then new subject is set to be a newly created bnode .
   • otherwise , if parent object is present, new subject is set to the value of parent object . Additionally, if @property is not present then the skip element flag is set to 'true';
6. If the current element does contain a @rel or @rev attribute, then the next step is to establish both a value for new subject and a value for current object resource :
   new subject is set to the URI IRI obtained from the first match from the following rules:

   • by using the URI IRI from @about , if present, obtained according to the section on CURIE and URI IRI Processing ;
   otherwise , by using the URI from @src , if present, obtained according to the section on CURIE and URI Processing .

   If no URI IRI is provided then the first match from the following rules will apply:

   • if the element is the root element of the document then act as if there is an empty @about present, and process it according to the rule for @about , above;
   • if @typeof is present, then new subject is set to be a newly created bnode ;
   • otherwise , if parent object is present, new subject is set to that.

   Then the current object resource is set to the URI IRI obtained from the first match from the following rules:

   • by using the URI IRI from @resource , if present, obtained according to the section on CURIE and URI IRI Processing ;
   • otherwise , by using the URI from @href , if present, obtained according to the section on CURIE and URI Processing .
   • otherwise , by using the IRI from @src , if present, obtained according to the section on CURIE and IRI Processing .

   Note that final value of the current object resource will either be null (from initialization) or a full URI. IRI.

7. If in any of the previous steps a new subject was set to a non-null value, it is now used to provide a subject for type values;
   One or more 'types' for the new subject can be set by using @typeof . If present, the attribute may contain one or more URIs, IRIs, obtained according to the section on URI and CURIE and IRI Processing , each of which is used to generate a triple as follows:

   subject

   new subject

   predicate

   http://www.w3.org/1999/02/22-rdf-syntax-ns#type

   object

   full URI IRI of 'type'

   Note that none of this block is executed if there is no new subject value, i.e., new subject remains null.
8. If in any of the previous steps a new subject was set to a non-null value different from the parent object ;
   The list mapping taken from the evaluation context is set to a new, empty mapping.
9. If in any of the previous steps a current object resource was set to a non-null value, it is now used to generate triples: triples and add entries to the local list mapping :
   If the element contains both the @inlist and the @rel attributes: the @rel may contain one or more IRIs, obtained according to the section on CURIE and IRI Processing each of which is used to add an entry to the list mapping as follows:

   • if the local list mapping does not contain a list associated with the IRI, instantiate a new list and add to local list mappings
   • add the current object resource to the list associated with the IRI in the local list mapping
   Predicates for the current object resource can be set by using one or both of the @rel and the @rev attributes: attributes but, in case of the @rel attribute, only if the @inlist is not present:

   • If present, @rel may contain one or more URIs, IRIs, obtained according to the section on CURIE and URI IRI Processing each of which is used to generate a triple as follows:

     subject

     new subject

     predicate

     full URI IRI

     object

     current object resource

   • If present, @rev may contain one or more URIs, IRIs, obtained according to the section on CURIE and URI IRI Processing each of which is used to generate a triple as follows:

     subject

     current object resource

     predicate

     full URI IRI

     object

     new subject

10. If however current object resource was set to null, but there are predicates present, then they must be stored as incomplete triple s, pending the discovery of a subject that can be used as the object. Also, current object resource should be set to a newly created bnode ;
    Predicates for incomplete triple s can be set by using one or both of the @rel and @rev attributes:

    • If present, @rel must contain one or more URIs, IRIs, obtained according to the section on CURIE and URI IRI Processing each of which is added to the local list of incomplete triples as follows:
      • If the element contains the @inlist attribute, then
        • if the local list mapping does not contain a list associated with the IRI, instantiate a new list and add to local list mappings.
        • Add:

          list

          list from local list mapping for this IRI

          direction

          none

      • Otherwise add:

        • predicate

          full URI IRI

          direction

          forward

    • If present, @rev must contain one or more URIs, IRIs, obtained according to the section on CURIE and URI IRI Processing , each of which is added to the local list of incomplete triples as follows:

      predicate

      full URI IRI

      direction

      reverse

11. The next step of the iteration is to establish any current object literal ;
    Predicates for the current object literal can be set by using @property . If present, one or more URIs IRIs are obtained according to the section on CURIE and URI IRI Processing , and then the actual literal value is obtained as follows:

    • as a typed literal if @datatype is present, does not have an empty value according to the section on CURIE and URI IRI Processing , and is not set to XMLLiteral in the vocabulary http://www.w3.org/1999/02/22-rdf-syntax-ns# .

      The actual literal is either the value of @content (if present) or a string created by concatenating the value of all descendant text nodes, of the current element in turn. The final string includes the datatype URI, IRI, as described in [ RDF-CONCEPTS ], which will have been obtained according to the section on CURIE and URI IRI Processing .

    • as an XML literal if @datatype is present and is set to XMLLiteral in the vocabulary http://www.w3.org/1999/02/22-rdf-syntax-ns# .

      The value of the XML literal is a string created by serializing to text, all nodes that are descendants of the current element , i.e., not including the element itself, and giving it a datatype of XMLLiteral in the vocabulary http://www.w3.org/1999/02/22-rdf-syntax-ns# . The format of the resulting serialized content is as defined in Exclusive XML Canonicalization Version [ XML-EXC-C14N ].

      In order to maintain maximum portability of this literal, any children of the current node that are elements must have the current XML namespace declarations (if any) declared on the serialized element. Since the child element node could also declare new XML namespaces, the RDFa Processor must be careful to merge these together when generating the serialized element definition. For avoidance of doubt, any re-declarations on the child node must take precedence over declarations that were active on the current node.

    • otherwise as a plain literal .

      Additionally, if there is a value for current language then the value of the plain literal should include this language information, as described in [ RDF-CONCEPTS ]. The actual literal is either the value of @content (if present) or a string created by concatenating the text content of each of the descendant elements of the current element in document order.

    The current object literal is then used with each predicate as follows:

    • If the element also includes the @inlist attribute, the current object literal is added to the local list mapping as follows:
      • if the local list mapping does not contain a list associated with the predicate IRI, instantiate a new list and add to local list mappings
      • add the current object literal to the list associated with the predicate IRI in the local list mapping
    • Otherwise the current object literal is used to generate a triple as follows:

      subject

      new subject

      predicate

      full URI IRI

      object

      current object literal

12. If the skip element flag is 'false', and new subject was set to a non-null value, then any incomplete triple s within the current context should be completed:
    The list of incomplete triples from the current evaluation context ( not the local list of incomplete triples ) will contain zero or more predicate URIs. IRIs. This list is iterated, iterated and is and each of the predicates is used with parent subject and new subject to generate a triple. triple or add a new element to the local list mapping . Note that at each level there are two lists of incomplete triple s; one for the current processing level (which is passed to each child element in the previous step), and one that was received as part of the evaluation context . It is the latter that is used in processing during this step.
    Note that each incomplete triple has a direction value that it used to determine what will become the subject, and what will become the object, of each generated triple:

    • If direction is 'none', the new subject is added to the list from the iterated incomplete triple .
    • If direction is 'forward' then the following triple is generated:

      subject

      parent subject

      predicate

      the predicate from the iterated incomplete triple

      object

      new subject

    • If direction is not neither 'forward' nor 'none' then this is the triple generated:

      subject

      new subject

      predicate

      the predicate from the iterated incomplete triple

      object

      parent subject

13. Next, all elements that are children of the current element are processed using the rules described here, using a new evaluation context , initialized as follows:
    • If the skip element flag is 'true' then the new evaluation context is a copy of the current context that was passed in to this level of processing, with the language and list of URI IRI mappings values replaced with the local values;
    • Otherwise, the values are:
      • the base is set to the base value of the current evaluation context ;
      • the parent subject is set to the value of new subject , if non-null, or the value of the parent subject of the current evaluation context ;
      • the parent object is set to value of current object resource , if non-null, or the value of new subject , if non-null, or the value of the parent subject of the current evaluation context ;
      • the list of URI IRI mappings is set to the local list of URI IRI mappings ;
      • the list of incomplete triples is set to the local list of incomplete triples ;
      • language the list mapping is set to the value of current language . local list mapping ;
      • the term mappings language is set to the value of the local term mappings current language .
      • the default vocabulary is set to the value of the local default vocabulary .
14. Once all the child elements have been traversed, list triples are generated, if necessary.
    For each IRI in the local list mapping , if the equivalent list does not exist in the evaluation context , indicating that the list was originally defined on the current element, use the list as follows:

    • Create a new ‘bnode’ array containing newly created bnode s, one for each element in the list
    • For each pair of bnode and IRI from the list the following triple is generated:

      subject

      bnode

      predicate

      http://www.w3.org/1999/02/22-rdf-syntax-ns#first

      object

      full IRI

    • For each element in the ‘bnode’ array the following triple is generated:

      subject

      bnode

      predicate

      http://www.w3.org/1999/02/22-rdf-syntax-ns#rest

      object

      next element in the ‘bnode’ array or, if that does not exist, http://www.w3.org/1999/02/22-rdf-syntax-ns#nil

    • A single additional triple is generated:

      subject

      current subject

      predicate

      full IRI of the local list mapping associated with this list

      object

      first element of the ‘bnode’ array

7.6 Processor Status

The processing rules covered in the previous section are designed to extract as many triples as possible from a document. The RDFa Processor is designed to continue processing, even in the event of errors. For example, failing to resolve a prefix mapping or term would result in the RDFa Processor skipping the generation of a triple and continuing with document processing. There are cases where knowing each RDFa Processor warning or error would be beneficial to authors. The processor graph is designed as a possible mechanism to capture all informational, warning, and error messages as triples from the RDFa Processor. These status triples may be retrieved and used to aid RDFa authoring or automated error detection.

If an RDFa Processor supports the generation of a processor graph, then it must generate a set of triples when the following processing issues occur:

• An rdfa:Error must be generated when the document fails to be fully processed as a result of non-conformant host language markup.
An rdfa:Error must be generated when a referenced RDFa Profile is not recognized , as described in RDFa Profiles .
• A rdfa:Warning must be generated when a CURIE prefix fails to be resolved.
• A rdfa:Warning must be generated when a Term fails to be resolved.

Other implementation-specific rdfa:Info, rdfa:Warning, or rdfa:Error triples may be generated by the RDFa Processor.

@prefix rdfa:    <http://www.w3.org/ns/rdfa#> .
@prefix xsd:     <http://www.w3.org/2001/XMLSchema#> .
@prefix dcterms: <http://purl.org/dc/terms/> .
[] a rdfa:ProfileReferenceError ;
   dcterms:description "The @profile value could not be deferenced" ;
dcterms:date
"2010-06-30T13:40:23"^^xsd:dateTime

@prefix dc: <http://purl.org/dc/terms/> .
[] a rdfa:DocumentError ;
   dc:description "The document could not be parsed due to parsing errors" ;
dc:date
"2010-06-30T13:40:23"^^xsd:dateTime

.

@prefix rdfa:    <http://www.w3.org/ns/rdfa#> .
@prefix xsd:     <http://www.w3.org/2001/XMLSchema#> .
@prefix dcterms: <http://purl.org/dc/terms/> .

@prefix dc: <http://purl.org/dc/terms/> .

@prefix ptr:     <http://www.w3.org/2009/pointers#> .
@prefix http:    <http://www.w3.org/2006/http#> .
 
[] a rdfa:ProfileReferenceError ;
   dcterms:description "The @profile value could not be deferenced" ;
   dcterms:date "2010-06-30T13:40:23"^^xsd:dateTime ;
   rdfa:context <http://www.example.org/profile> ;

[] a rdfa:DocumentError ;
   dc:description "The document could not be parsed due to parsing errors" ;
   dc:date "2010-06-30T13:40:23"^^xsd:dateTime ;
   rdfa:context <http://www.example.org/doc> ;

   rdfa:context [
      a ptr:Pointer ;
      # detailed xpointer/xpath information provided here to locate the 
      # DOM node with the @profile attribute

      # error

   ] ;
   rdfa:context [
      a http:Response ;
      http:responseCode <http://www.w3.org/2006/http#404>
      # Get the HTTP response headers on the request for the profile file.

      # Get the HTTP response headers on the request for the source file.

].

7.7 Vocabulary Expansion

Processors may perform limited RDFS entailment rules to perform vocabulary expansion, as described in RDFa Vocabulary Expansion .