XForms 2.0: XPath expression module

2.2.1 3.2.1 Initializing the Static Context

The static context ^XP of an XPath expression appearing in a form is initialized as follows.

• XPath 1.0 compatibility mode ^XP is set to true if and only if the indicated XPath version on the model is 1.0 or the XForms conformance level is 1.0 or 1.1.
• The statically known namespaces ^XP are the namespace declarations that are in scope for the containing element.
• The default element/type namespace ^XP is the null namespace.
• The default function namespace ^XP is the standard function namespace, defined in [Functions and Operators] . This means that it is not necessary to declare this namespace in the form, nor is it necessary to use the prefix fn (or any other prefix) in calls to the core XPath functions.
• The in-scope schema definitions ^XP for the XPath expression are as specified in 5 Datatypes.
• The in-scope variables ^XP are defined by the variable binding elements that are in scope for the containing element (see The var element ).
• The function signatures ^XP are the core functions defined in [Functions and Operators] , the constructor functions for all the atomic types in the in-scope schema definitions ^XP , the additional functions defined in this specification, the custom functions defined in the Form, plus any extension functions bound using implementation-defined mechanisms.
• The statically known collations ^XP are implementation-defined. However, the set of in-scope collations must always include the Unicode codepoint collation, defined in 7.3 Equality and Comparison of Strings ^FO .
• The default collation ^XP is Unicode code point collation.
• The base URI ^XP is the base URI of the containing element. The concept of the base URI of a node is defined in Section 5.2 base-uri Accessor ^DM

2.2.2 3.2.2 Initializing the Dynamic Context

For convenience, the dynamic context is described in two parts: the focus, which represents the place in the instance document that is currently being referenced, and a collection of additional context variables.

A number of functions specified in [Functions and Operators] are defined to be stable ^FO , meaning that if they are called twice during the same execution scope ^FO , with the same arguments, then they return the same results (see "Section 1.7 Terminology ^FO ). In XForms, the [TODO] defines the execution scope. This means, for example, that if the function current-dateTime ^FO is called repeatedly during a transformation, it produces the same result each time. By implication, the components of the dynamic context on which these functions depend are also stable for [TODO]. Specifically, the following components defined in the section Dynamic Context ^XP must be stable: function implementations, current dateTime, implicit timezone, available documents, available collections, and default collection. The values of global variables are also stable for the execution of the form. The focus is not stable.

3.1.1 4.1.1 The boolean-from-string() Function

xf:boolean-from-string ( $value as xs:string ) as xs:boolean

Function boolean-from-string returns true if the required parameter matches "true" or "1" using case-insensitive comparison. Otherwise false is returned. This function is useful when referencing a Schema xsd:boolean datatype in an XPath expression.

3.1.2 4.1.2 The is-card-number() Function

xf:is-card-number ( $card-nr as xs:string? ) as xs:boolean

If the string parameter conforms to the pattern restriction of the xforms:card-number ^XF datatype, then this function applies the Luhn algorithm described in [Luhn Patent] and returns true if the number satisfies the formula. Otherwise, false is returned. If the parameter is omitted, it defaults to the string-value of the current context item.

Examples (see also 5.2.7 xforms:card-number ^XF ):

xf:is-card-number(.)

xf:is-card-number('4111111111111111')

xf:is-card-number('123')

4.1.3 The valid() Function

xf:valid() as xs:boolean

xf:valid($node as node()*) as xs:boolean

xf:valid($node as node()*, $relevant as xs:boolean) as xs:boolean

The valid() function returns the validity of nodes of instance data.

The function acts as if first selecting nodes in this sequence:

1. Selected nodes initially consist of each node referred to the $node parameter, if present, or the expression's context node, if absent.
2. Selected nodes and all nodes (including attribute nodes) for which the selected nodes are an ancestor are also selected.
3. If the $relevant attribute is omitted or set to true() , selected nodes which are non-relevant are deselected. The relevance information of an individual node is obtained by looking at the node's relevant property computed as per The xforms-recalculate Event ^XF .

If there are no resulting selected nodes, the function returns true() .

Otherwise the function computes the logical AND of the validity of all the selected nodes. The validity information of an individual node is obtained by looking at the node validity computed as per The xforms-revalidate Event ^XF .

If the function is used in a model binding expression ^XF the XForms Processor should terminate processing after dispatching the event xforms-binding-exception to the model. If the function is used in a computed expression ^XF the XForms Processor should terminate processing after dispatching the event xforms-compute-exception to the model.

<model>
  <instance>
    <data xmlns="">
      <node1/>
      <node2/>
    </data>
  </instance>
  <bind ref="*" type="xs:integer"/>
</model>
<repeat ref="*[not(valid())]">
  <output value=".">
    <label>Invalid value:</label>
  </output>
</repeat>

                                                        

4.1.4 The matches() Function

xf:matches ( $input as xs:string? , $pattern as xs:string ) as xs:boolean

xf:matches ( $input as xs:string? , $pattern as xs:string , $flags as xs:string ) as xs:boolean

The function returns true if $input matches the regular expression supplied as $pattern as influenced by the value of $flags. The function behavioral details, regular expression pattern syntax and flags are defined by XPath 2.0. This function from XPath 2.0 is included in the XForms function library for authoring ease and for XPath 1.0 expression compatibility.

Examples:

xf:matches("abracadabra", "bra")

xf:matches('(123) 456-7890', '^\(?(\d{3})\)? [-. ]?(\d{3}) [-. ]?(\d{4})$')

<model>
  <xf:instance xmlns="">
    <data>
      <phone>abc</phone>
    </data>
  </xf:instance>
  <bind ref="phone" constraint="xf:matches(., '^\(?(\d{3})\)? [-. ]?(\d{3}) [-. ]?(\d{4})$')"/>
</model>

                                                        

3.2.1 4.2.1 The avg() Function

xf:avg ( $arg as xs:anyAtomicType* ) as xs:integer

Function avg returns the arithmetic average of the result of converting the string-values of each item in the argument sequence to a number. The sum is computed with sum() , and divided with div by the value computed with count() . If the parameter is an empty sequence, or if any of the nodes evaluate to NaN , the return value is NaN .

3.2.2 4.2.2 The min() Function

xf:min ( $arg as xs:anyAtomicType* ) as xs:integer

Function min returns the minimum value of the result of converting the string-values of each item in the sequence argument to a number. "Minimum" is determined with the < operator. If the parameter is an empty sequence, or if any of the nodes evaluate to NaN , the return value is NaN .

3.2.3 4.2.3 The max() Function

xf:max ( $arg as xs:anyAtomicType* ) as xs:integer

Function max returns the maximum value of the result of converting the string-values of each item in the sequence argument to a number. "Maximum" is determined with the < operator. If the parameter is an empty sequence, or if any of the nodes evaluate to NaN , the return value is NaN .

3.2.4 4.2.4 The count-non-empty() Function

xf:count-non-empty ( $arg as node()* ) as xs:integer

Function count-non-empty returns the number of non-empty nodes in the first argument. A node is considered non-empty if it is convertible into a string with a greater-than zero length.

3.2.5 4.2.5 The index() Function

xf:index ( $repeat-id as xs:string ) as xs:integer

Function index takes a string argument that is the IDREF of a repeat and returns the current 1-based position of the repeat index for the identified repeat —see 9.3.1 The repeat Element ^XF for details on repeat and its associated repeat index. If the specified argument does not identify a repeat , the function returns NaN .

The function index introduces additional dependencies for the computational dependency data structure, see 4.9 Additional dependencies for the computational dependency data structure for details.

<trigger>
  <label>Add to Shopping Cart</label>
  <insert ev:event="DOMActivate" position="after"
          nodeset="items/item" at="xf:index('cartUI')"/>
</trigger>

3.2.6 4.2.6 The power() Function

xf:power ( $base as numeric , $exponent as numeric ) as xs:integer

Raises the first argument to the power of the second argument, returning the result. If the calculation does not result in a real number, then NaN is returned.

Examples:

xf:power(2, 3)

xf:power(-1, 0.5)

if (prin>0 and dur>0 and rate>0) then prin*rate/(1-xf:power(1+rate, -dur)) else 0

3.2.7 4.2.7 The random() Function

xf:random ( $seed as xs:boolean? ) as numeric

This function generates and returns a uniformly distributed random or pseudorandom number in the range from 0.0 up to but excluding 1.0. This function accepts an author-optional boolean parameter that is false by default. If true , the random number generator for this function is first seeded with a source of randomness before generating the return value. A typical implementation may seed the random number generator with the current system time in milliseconds when random(true) is invoked, and it may apply a linear congruential formula to generate return values on successive invocations of the function.

Example:

xf:random()

3.2.8 4.2.8 The compare() Function

xf:compare ( $arg1 as xs:string , $arg2 as xs:string ) as xs:integer

This function returns -1, 0, or 1, depending on whether the value of the first argument is respectively less than, equal to, or greater than the value of second argument based on lexicographic comparison using Unicode code point values [Unicode Collation Algorithm] .

Example:

xf:compare('apple', 'orange')

3.3.1 4.3.1 The case() Function

xf:case ( $switch-id as xs:string ) as xs:string?

Function case takes a string argument that is the IDREF of a switch and returns the ID of the selected case for the identified switch —see 9.2.1 The switch Element ^XF for details on switch .

The empty sequence is returned, if the specified argument does not identify a switch .

The function case introduces additional dependencies for the computational dependency data structure, see 4.9 Additional dependencies for the computational dependency data structure for details.

3.3.2 4.3.2 The property() Function

xf:property ( $property-name as xs:string ) as xs:string xs:string?

This function accepts a string identifying a property name. If the property name is not recognized, empty string sequence is returned. The property definitions for this function are as follows:

Examples:

xf:property('version')

xf:property('conformance-level')

3.3.3 4.3.3 The digest() Function

xf:digest ( $data as xs:string , $algo as xs:string , $encoding as xs:string? ) as xs:string

This function accepts a string of data, a string indicating a cryptographic hashing algorithm, and an author-optional string indicating an encoding method. The data string is serialized as UTF-8, the hash value is then computed using the indicated hash algorithm, and the hash value is then encoded by the indicated method, and the result is returned by the function. The following table presents the keywords for the second string parameter and the corresponding hash algorithms:

This recommendation defines the values hex and base64 for the third string parameter that indicates the encoding method. If the parameter is missing, then the default is base64 . The hex and base64 encoding methods of this function correspond to the encodings defined in [XML Schema part 2] for the datatypes hexBinary and base64Binary , respectively. For the hexadecimal encoding, the digits 'a' through 'f' are encoded with lower case letters. Any other string value given for the encoding method results in an exception (see 4 The XForms Function Library for the exception type).

xf:digest('abc', 'SHA-1', 'hex')

xf:digest('abc', 'MD5', 'hex')

xf:digest('abc', 'SHA-256', 'hex')

3.3.4 4.3.4 The hmac() Function

xf:hmac ( $secret as xs:string , $data as xs:string , $algo as xs:string , $encoding as xs:string? ) as xs:string

This function accepts a string for a key or shared secret, a string of data, a string indicating a cryptographic hashing algorithm, and an author-optional string indicating an encoding method. The key and data strings are serialized as UTF-8, and they are subjected to the HMAC algorithm defined in [HMAC] and parameterized by the the hash algorithm indicated by the third parameter. The result is encoded with the method indicated by the fourth parameter, and the result is returned by the function.

The following table presents the keywords for the third string parameter and the corresponding hash algorithms:

This recommendation defines the values hex and base64 for the fourth string parameter that indicates the encoding method. If the parameter is missing, then the default is base64 . The hex and base64 encoding methods of this function correspond to the encodings defined in [XML Schema part 2] for the datatypes hexBinary and base64Binary , respectively. For the hexadecimal encoding, the digits 'a' through 'f' are encoded with lower case letters. Any other string value given for the encoding method results in an exception (see 4 The XForms Function Library for the exception type).

xf:hmac('Jefe', 'what do ya want for nothing?', 'SHA-1', 'hex')

xf:hmac('Jefe', 'what do ya want for nothing?', 'MD5', 'hex')

xf:hmac('Jefe', 'what do ya want for nothing?', 'SHA-256', 'hex')

4.3.5 The replace() Function

xf:replace ( $input as xs:string? , $pattern as xs:string , $replacement as xs:string ) as xs:string

xf:replace ( $input as xs:string? , $pattern as xs:string , $replacement as xs:string , $flags as xs:string ) as xs:string

The function returns the xs:string that is obtained by replacing each non-overlapping substring of $input that matches the given $pattern (as influenced by the value of $flags) with an occurrence of the $replacement string. The function behavioral details, regular expression pattern syntax, replacement string syntax and flags are defined by XPath 2.0. This function from XPath 2.0 is included in the XForms function library for authoring ease and for XPath 1.0 expression compatibility.

Examples:

xf:replace("abcd", "(ab)|(a)", "[1=$1][2=$2]")

returns [1=ab][2=]cd.

xf:replace('1234567890', '^\(?(\d{3})\)? [-. ]?(\d{3}) [-. ]?(\d{4})$', '($1) $2-$3')

<model>
  <xf:instance xmlns="">
    <data>
      <phone></phone>
    </data>
  </xf:instance>
  <bind ref="phone" constraint="xf:matches(., '^\(?(\d{3})\)? [-. ]?(\d{3}) [-. ]?(\d{4})$')"/>
</model>
<input ref="phone">
   <label>Enter phone number:</label>
   <setvalue ev:event="xforms-value-changed" ref="."
             value="xf:replace(., '^\(?(\d{3})\)? [-. ]?(\d{3}) [-. ]?(\d{4})$', '($1) $2-$3')"/>
</input>

                                                        

4.3.6 The serialize() Function

xf:serialize ( $element as element()? ) as xs:string

xf:serialize ( $element as element()? , $format as xs:string ) as xs:string

The function returns a string containing the serialization of the XML tree rooted by the given $element. If $element is empty, then the empty string is returned. If no $format is specified, then the default is the xml serializer with no relevance pruning nor validation.

The $format is a space-separated list of QNames intended to allow namespace qualified custom extensions as well as NCName values that control various features of serialization such as whether relevance pruning is performed, whether an XML declaration is emitted, and various other options of serialization that are synonymous with XForms submission serialization and the XSLT output element.

Example:

 <model>
    <xf:instance xmlns="">
       <data>
          <node>abc</node>
          <text>&lt;node&gt;abc&lt;/node&gt;</text> 
       </data>
    </xf:instance>
    <bind ref="text" calculate="xf:serialize(../node)"/>
 </model>

                                                        

3.4.1 4.4.1 The local-date() Function

xf:local-date () as xs:date

This function returns a lexical xsd:date obtained as if by the following rules: the result of now() is converted to a local date based on the user agent time zone information. If no time zone information is available, then the date portion of the result of now() is returned.

Example:

xf:local-date()

xf:substring(local-date(), 1, 10)

xf:days-to-date(days-from-date(local-date()) + 31)

3.4.2 4.4.2 The local-dateTime() Function

xf:local-dateTime () as xs:dateTime

This function returns a lexical xsd:dateTime obtained as if by the following rules: the result of now() is converted to a local dateTime based on the user agent time zone information. If no time zone information is available, then the result of now() is returned.

Example:

xf:local-dateTime()

xf:adjust-dateTime-to-timezone(seconds-to-dateTime(seconds-from-dateTime(local-dateTime()) + 7200))

3.4.3 4.4.3 The now() Function

xf:now () as xs:string

The now function returns the current UTC date and time as a string value in the canonical XML Schema xsd:dateTime format. If time zone information is available, it is used to convert the date and time to UTC. If no time zone information is available, then the date and time are assumed to be in UTC.

Examples:

xf:now()

xf:seconds-to-dateTime(seconds-from-dateTime(now()) + 7200)

3.4.4 4.4.4 The days-from-date() Function

xf:days-from-date ( $arg as xs:string ) as xs:integer

This function returns a whole number of days, according to the following rules:

If the string parameter represents a legal lexical xsd:date or xsd:dateTime , the return value is equal to the number of days difference between the specified date or dateTime (normalized to UTC) and 1970-01-01 . Hour, minute, and second components are ignored after normalization. Any other input parameter causes a return value of NaN .

Examples:

xf:days-from-date("2002-01-01")

xf:days-from-date("2002-01-01-07:00")

xf:days-from-date("1969-12-31")

3.4.5 4.4.5 The days-to-date() Function

xf:days-to-date ( $arg as numeric ) as xs:date

This function returns an xsd:date that corresponds to the number of days passed as the parameter according to the following rules:

The number parameter is rounded to the nearest whole number, and the result is interpreted as the difference between the desired date and 1970-01-01 . An input parameter value of NaN results in output of the empty string.

Examples:

xf:days-to-date(11688)

xf:days-to-date(-1)

3.4.6 4.4.6 The seconds-from-dateTime() Function

xf:seconds-from-dateTime ( $arg as xs:string ) as xs:decimal

This function returns a possibly fractional number of seconds, according to the following rules:

If the string parameter represents a legal lexical xsd:dateTime , the return value is equal to the number of seconds difference between the specified dateTime (normalized to UTC) and 1970-01-01T00:00:00Z . If no time zone is specified, UTC is used. Any other input string parameter causes a return value of NaN . This function does not support leap seconds.

Example:

xf:seconds-from-dateTime('1970-01-01T00:00:00Z')

xf:seconds-from-dateTime('1970-01-01T00:00:00-08:00')

3.4.7 4.4.7 The seconds-to-dateTime() Function

xf:seconds-to-dateTime ( $arg as numeric ) as xs:xsd:dateTime

This function returns an xsd:dateTime that corresponds to the number of seconds passed as the parameter according to the following rules:

The number parameter is rounded to the nearest whole number, and the result is interpreted as the difference between the desired UTC dateTime and 1970-01-01T00:00:00Z . An input parameter value of NaN results in output of the empty string. This function does not support leap seconds.

Examples:

xf:seconds-to-dateTime(0)

xf:seconds-from-dateTime(28800)

xf:seconds-to-dateTime(seconds-from-dateTime(now()) + 7200)

xf:adjust-dateTime-to-timezone(seconds-to-dateTime(seconds-from-dateTime(now()) + 7200))

3.4.8 4.4.8 The adjust-dateTime-to-timezone() Function

xf:adjust-dateTime-to-timezone ( $arg as xs:string ) as xs:dateTime

This function adjusts a legal lexical xsd:dateTime received as the parameter to the local time zone for the user of the implementation, and returns the result. The application of daylight savings time is dependent on whether daylight savings time is in effect for the local time zone at the given date and time. "Local" or untimezoned times are presumed to be the time in the local time zone. If the implementation does not have access to time zone information, UTC is used. The result is empty string if the string argument is the empty sequence or not a legal lexical xsd:dateTime .

Examples:

xf:adjust-dateTime-to-timezone('2007-10-07T02:22:00')

xf:adjust-dateTime-to-timezone('2007-10-02T21:26:43Z')

xf:adjust-dateTime-to-timezone(seconds-to-dateTime(seconds-from-dateTime(now()) + 7200))

xf:adjust-dateTime-to-timezone(seconds-to-dateTime(seconds-from-dateTime('2007-10-02T14:26:43-07:00') + 61*86400))

3.4.9 4.4.9 The seconds() Function

xf:seconds ( $arg as xs:string ) as xs:decimal

This function returns a possibly fractional number of seconds, according to the following rules:

If the string parameter represents a legal lexical xsd:duration , the return value is equal to the number specified in the seconds component plus 60 * the number specified in the minutes component, plus 60 * 60 * the number specified in the hours component, plus 60 * 60 * 24 * the number specified in the days component. The sign of the result will match the sign of the duration. Year and month components, if present, are ignored. Any other input parameter causes a return value of NaN .

Examples:

xf:seconds("P3DT10H30M1.5S")

xf:seconds("P1Y2M")

xf:seconds("3")

3.4.10 4.4.10 The months() Function

xf:months ( $arg as xs:string ) as xs:integer

This function returns a whole number of months, according to the following rules:

If the string parameter represents a legal lexical xsd:duration , the return value is equal to the number specified in the months component plus 12 * the number specified in the years component. The sign of the result will match the sign of the duration. Day, hour, minute, and second components, if present, are ignored. Any other input parameter causes a return value of NaN .

Examples:

xf:months("P1Y2M")

xf:months("-P19M")

3.5.1 4.5.1 The instance() Function

xf:instance ( $id as xs:string? ) as element()?

An XForms Model can contain more than one instance. This function allows access to instance data, within the same XForms Model, but outside the instance data containing the context node.

If the argument is omitted or is equal to the empty string, then the root element node (also called the document element node) is returned for the default instance of the current model. The current model, is the model that contains the node of the nearest inscope evaluation context that is a node (starting from the evaluation context of the the node containing the XPath expression that invokes this function).

Otherwise, the argument is converted to a string as if by a call to the string function. This string is treated as an IDREF, which is matched against instance elements in the containing document. If a match is located, and the matching instance data is associated with the same XForms Model as the current model, this function returns the root element node (also called the document element node) of the referenced instance data. In all other cases, an empty sequence is returned.

Example:

For instance data corresponding to this XML:

<xforms:instance xmlns="" id="orderform">
  <orderForm>
    <shipTo>
      <firstName>John</firstName>
    </shipTo>
  </orderForm>
</xforms:instance>

The following expression selects the firstName node. Note that the instance function returns an element node, effectively replacing the leftmost location step from the path:

ref="xf:instance('orderform')/shipTo/firstName"

3.5.2 4.5.2 The current() Function

xf:current () as item()

Returns the context item ^XP used to initialize the evaluation of the containing XPath expression.

Examples:

<xforms:instance xmlns="">
   <converter>
      <amount>100</amount>
      <currency>jpy</currency>
      <convertedAmount></convertedAmount>
   </converter>
</xforms:instance>
<xforms:instance xmlns="" id="convTable">
   <convTable date="20040212" currency="cdn">
      <rate currency="eur">0.59376</rate>
      <rate currency="mxn">8.37597</rate>
      <rate currency="jpy">80.23451</rate>
      <rate currency="usd">0.76138</rate>
   </convTable>
</xforms:instance>

<bind nodeset="convertedAmount"
      calculate="../amount *
                 xf:instance('convTable')/rate[@currency=xf:current()/../currency]"/>

<xforms:instance xmlns="" id="i1">
   <months>
      <mon>01</mon>
      <mon>02</mon>
      <mon>03</mon>
   </months>
</xforms:instance>
<xforms:instance xmlns="" id="i2">
   <months>
      <month code="01">Jan</month>
      <month code="02">Feb</month>
      <month code="03">Mar</month>
   </months>
</xforms:instance>

<repeat nodeset="mon">
   <output value="xf:instance('i2')/month[@code = xf:current()]/>
</repeat>

3.5.3 4.5.3 The id() Function

xf:id ( $arg as xs:string* , $node as node()*? ) as element()*

xf:id ( $arg as node()* , $node as node()*? ) as element()*

The first parameter provides one or more IDREFs. This may be in the form of a string containing a space-separated list of IDREFs or a sequence of nodes, each node of which contains an IDREF. The second parameter provides nodes in one or more instance data documents to be searched. If the second parameter is not given or is empty, then the instance data document to be searched is the one containing the context node of the function call (if the context item isn't a node and second parameter isn't provided or is the empty sequence an error is raised). For each node in the second parameter (or its default), the set of element nodes are collected with IDs that match the IDREFs from the first parameter. The result of this function is a sequence of elements, in document order with duplicates eliminated, containing the union of the collected element nodes from each string. An element node can be assigned an ID by means of an xml:id attribute or an attribute that is assigned the type ID by a DTD or xsd:ID or any type derived from xsd:ID by an XML schema, or the type model item property.

Example:

xf:id('X Y', instance('Z'))

3.5.4 4.5.4 The context() Function

xf:context () ($id as xs:string?) as item()

This function returns the in-scope evaluation context item of the nearest an ancestor element of the node containing the XPath expression that invokes this function. The ancestor element is determined using the id parameter, taking into account Resolving ID References in XForms ^XF . When the id parameter is omitted, the nearest ancestor element is used for determining the in-scopre evaluation context item to return. The ancestor element may have been created dynamically as part of the run-time expansion of repeated content as described in Section 4.7 Resolving ID References in XForms ^XF .

It is an error to specify a non existing id or an id of an element that isn't an ancestor.

Example:

<setvalue ref="x" value="xf:context()/y"/>

4.6.1 The element() Function

xf:element ( $qname as xs:anyAtomicType , $content as item()* ) as element()

This function returns a new XML element with the qualified name provided. If the qualified name is not of type xs:QName the namespace of the element is resolved using the in-scope namespaces (the in-scope default namespace is used for qualified names that are unprefixed). The content argument is a sequence of items specifying attributes and content for the new element.

Examples:

xf:element('value')

xf:element('value', (xf:attribute('id', 'my-value'), 'John'))

xf:element('value', ('John', xf:attribute('id', 'my-value')))

4.6.2 The attribute() Function

xf:attribute ( $qname as xs:anyAtomicType , $value as xs:anyAtomicType? ) as attribute()

This function returns a new XML attribute with the qualified name provided as first argument. If the qualified name is not of type xs:QName the namespace of the element is resolved using the in-scope namespaces (the in-scope default namespace is used for qualified names that are unprefixed). The second argument is an optional value for the attribute with the empty string as default.

Example:

xf:attribute('id', 'first-name')

4.6.3 The parse() Function

xf:parse ( $arg as xs:string ) as element()?

xf:parse ( $arg as xs:string , $format as xs:string ) as element()?

This function takes as input a document represented as a string in $arg, and returns the XML document element node for the parsed document. The default if the $format is not specified, the XML 1.0 parsing is used. If $arg is the empty sequence or is not well-formed according to the $format parsing rules, the function returns the empty sequence.

The $format is a space-separated list of QNames intended to control various features of parsing, such as the grammar and grammatic variations, as well as allowing namespace qualified custom extensions.

Example:

 <insert context="container/node" nodeset="elem" at="last()" position="after"
         origin="xf:parse('&lt;elem&gt; &lt;a/&gt; &lt;b/&gt; &lt;/elem&gt;')"/>

                                                        

Note:

An important use case for this function is to convert unparsed data received by a form, such as from a submission, into parsed data.

3.6.1 4.7.1 The choose() Function

xf:choose ( $condition as xs:boolean , $choice-true as item()* , $choice-false as item()* ) as item()*

This function provides a conditional test that chooses an object to return based on the boolean parameter. If the boolean parameter is true, then the first object is returned, otherwise the second object is returned. Each of the object parameters can be of any XPath datatype as described in Section 3.1 Datatypes , and this function does no type conversion of the parameter it chooses to return.

Example:

xf:choose(count(x) > 0, x, y)

xf:choose(@x, @x, 0)

3.6.2 4.7.2 The event() Function

xf:event ( $property-name as xs:string ) as item()*

Function event returns context specific information determined by the string argument. The returned context information is an XPath object whose type and content depends upon the requested property. Each event describes what properties can be accessed by this function and the type and value that will be returned as the result.

The event context properties available on each event are:

The event-specific context properties for each event type are provided in the sections that describe the events.

This function is intended for use in the XPath expressions of XForms actions. If invoked for any other XPath expression, such as a binding expression or model item property expression, this function returns the empty string. If this function is invoked from an XPath expression for an XForms action, then event context information is used from the most recently dispatched event whose action handler contains the XForms action.

Some properties defined for an event may be unavailable if certain prerequisite conditions were not met prior to the event being dispatched. Implementations may also add custom properties. If the event context information does not contain the property indicated by the string argument, then an empty node-set is returned.

Examples:

xf:event('inserted-nodes')

4.7.3 The eval() Function

xf:eval ( $expression as xs:string ) as item()*

The function returns the result of evaluating the $expression in the context of the eval() function call. The expression containing the eval() function invocation references the XPath nodes referenced by the $expression, which introduces additional dependencies for the containing expression.

<model>
   <instance xmlns="">
      <data>
         <A>3</A>
         <B>4</B>
         <C value="power(../A * ../A + ../B * ../B, 0.5)">5</C>
      </data>
   </instance>
   <bind nodeset="descendant::*[@value]" calculate="xf:eval(@value)"/>
</model>
                                                        

<model>
   <instance xmlns="">
      <data>
         <A>3</A>
         <B>4</B>
         <C value="power(A * A + B * B, 0.5)">5</C>
      </data>
   </instance>
   <bind nodeset="descendant::*[@value]" calculate="../xf:eval(current()/@value)"/>
</model>
                                                        

4.7.4 The eval-in-context() Function

xf:eval-in-context($expression as xs:string, $context as node()*) as item()*

The function returns the result of evaluating the $expression in the $context. The expression containing the eval() function invocation references the XPath nodes referenced by the $expression, which introduces additional dependencies for the containing expression. In XPath 2.0, the eval() function can be invoked later in an expression, after setting the desired context, so this function is included for ease of authoring and XPath 1.0 expression compatibility.

<model>
   <instance xmlns="">
      <data>
         <A>3</A>
         <B>4</B>
         <C value="power(A * A + B * B, 0.5)">5</C>
      </data>
   </instance>
   <bind nodeset="descendant::*[@value]" calculate="xf:eval-in-context(@value, ..)"/>
</model>