sigel.xslt.elements — me.flowthing/sigel 1.0.1

Functions for creating XSLT elements.

This namespace declares so many vars that conflict with vars in the Clojure core that you probably want to alias the vars in this namespace.

The docstrings in this file are copied directly from the Saxon documentation.

accept clj

(accept a)

Allows a package to restrict the visibility of components exposed by a package that it uses.

accumulator clj

(accumulator & [a & xs])

An accumulator defines some processing that is to take place while a document is being sequentially processed: for example, a total that is to be accumulated.

accumulator-rule clj

(accumulator-rule & [a & xs])

Defines a rule for an accumulator.

analyze-string clj

(analyze-string & [a & xs])

Applies a regular expression to a supplied string value.

apply-imports clj

(apply-imports & [a & xs])

Searches for a template that matches the current node and that is defined in a stylesheet that was imported (directly or indirectly) from the stylesheet containing the current template, and whose mode matches the current mode. If there is such a template, it is activated using the current node. If not, the built-in template for the kind of node is activated.

apply-templates clj

(apply-templates & [a & xs])

Causes navigation from the current element, usually but not necessarily to process its children. Each selected node is processed using the best-match xsl:template defined for that node.

assert clj

(assert & [a & xs])

Used to make assertions in the form of XPath expressions, causing a dynamic error if the assertion turns out to be false.

attribute clj

(attribute & [a & xs])

The xsl:attribute element is used to add an attribute value to an element element or literal result element, or to an element created using copy. The attribute must be output immediately after the element, with no intervening character data.

attribute-set clj

(attribute-set & [a & xs])

Used to declare a named collection of attributes, which will often be used together to define an output style. It is declared at the top level (subordinate to stylesheet).

break clj

(break & [a & xs])

The xsl:break instruction is used within iterate, and causes premature completion before the entire input sequence has been processed.

call-template clj

(call-template & [a & xs])

Invokes a named template.

catch clj

(catch & [a & xs])

In conjunction with try, the xsl:catch instruction allows recovery from dynamic errors.

character-map clj

(character-map & [a & xs])

Defines a named character map for use during serialization.

choose clj

(choose & [a & xs])

Used to choose one of a number of alternative outputs.

comment clj

(comment & [a & xs])

Indicates text that is to be output to the current output stream in the form of an XML or HTML comment.

context-item clj

(context-item & [a & xs])

Used to declare the initial context item for a template: whether the template requires a context item, and if so, what its expected type is.

copy clj

(copy & [a & xs])

Causes the current XML node in the source document to be copied to the output. The actual effect depends on whether the node is an element, an attribute, or a text node.

copy-of clj

(copy-of a)

Copies the value obtained by evaluating the mandatory select attribute. It makes an exact copy.

decimal-format clj

(decimal-format a)

Indicates a set of localisation parameters. If the xsl:decimal-format element has a name attribute, it identifies a named format; if not, it identifies the default format.

document clj

(document & [a & xs])

Creates a new document node.

element clj

(element & [a & xs])

Used to create an output element whose name might be calculated at run-time.

evaluate clj

(evaluate & [a & xs])

Allows dynamic evaluation of XPath expressions constructed as a string.

expose clj

(expose & [a & xs])

Used to modify the visibility of selected components within a package.

fallback clj

(fallback & xs)

Used to define recovery action to be taken when an instruction element is used in the stylesheet and no implementation of that element is available.

for-each clj

(for-each & [a & xs])

Causes iteration over the nodes selected by a node-set expression.

for-each-group clj

(for-each-group & [a & xs])

Selects a sequence of nodes and/or atomic values and organizes them into subsets called groups.

fork clj

(fork & xs)

The result of the xsl:fork instruction is the sequence formed by concatenating the results of evaluating each of its contained instructions, in order.

function clj

(function & [a & xs])

Defines a function within a stylesheet. The function is written in XSLT but it may be called from any XPath expression in the stylesheet. It must have a non-default namespace prefix.

global-context-item clj

(global-context-item a)

Used to declare whether a global context item is required, and if so, to declare its required type.

if clj

(if & [a & xs])

Used for conditional processing. It takes a mandatory test attribute, whose value is a boolean expression. The contents of the xsl:if element are expanded only of the expression is true.

import clj

(import a)

Used to import the contents of one stylesheet module into another.

import-schema clj

(import-schema & [a & xs])

Used to identify a schema containing definitions of types that are referred to in the stylesheet

include clj

(include a)

Used to include the contents of one stylesheet within another.

iterate clj

(iterate & [a & xs])

Used to iterate over a sequence, with the option to set parameters for use in the next iteration.

key clj

(key & [a & xs])

Used at the top level of the stylesheet to declare an attribute, or other value, that may be used as a key to identify nodes using the key() function within an expression. Each xsl:key definition declares a named key, which must match the name of the key used in the key() function.

map clj

(map & xs)

Used to construct a new map.

map-entry clj

(map-entry & [a & xs])

Used to construct a singleton map (one key and one value).

matching-substring clj

(matching-substring & xs)

Used within an analyze-string element to indicate the default action to be taken with substrings that match a regular expression.

merge clj

(merge & xs)

The purpose of the instruction is to allow streamed merging of two or more pre-sorted input files.

merge-action clj

(merge-action & xs)

The purpose of the instruction is to allow streamed merging of two or more pre-sorted input files.

merge-key clj

(merge-key & [a & xs])

Used to define the merge keys on which the input sequences of a merging operation are sorted.

merge-source clj

(merge-source & [a & xs])

Describes the input source for an merge instruction.

message clj

(message & [a & xs])

Causes a message to be displayed.

mode clj

(mode a)

Allows properties of a mode to be defined.

namespace clj

(namespace & [a & xs])

Creates a namespace node.

namespace-alias clj

(namespace-alias a)

A top-level element used to control the mapping between a namespace URI used in the stylesheet and the corresponding namespace URI used in the result document.

namespace-uri clj

next-iteration clj

(next-iteration & xs)

The xsl:next-iteration instruction occurs within iterate. The contents are a set of with-param elements defining the values of the iteration parameters to be used on the next iteration.

next-match clj

(next-match & [a & xs])

Chooses the next template to execute.

non-matching-substring clj

(non-matching-substring & xs)

Used within an xsl:analyze-string element to indicate the default action to be taken with substrings that do not match a regular expression.

number clj

(number a)

Outputs the sequential number of a node in the source document.

on-completion clj

(on-completion & [a & xs])

Occurs within xsl:iterate to define processing to be carried out when the input sequence is exhausted.

on-empty clj

(on-empty & [a & xs])

Used to allow conditional content construction to be made streamable. Outputs the enclosed content only if the containing sequence also generates "ordinary" content.

on-non-empty clj

(on-non-empty & [a & xs])

Used to allow conditional content construction to be made streamable. Outputs the enclosed content only if the containing sequence generates no "ordinary" content.

otherwise clj

(otherwise & xs)

Used within choose to indicate the default action to be taken if none of the other choices matches.

output clj

(output a)

Used to control the format of serial output files resulting from the transformation.

output-character clj

(output-character a)

Used to define the output representation of a given Unicode character, in a character-map.

override clj

(override & xs)

Allows a using package to override a component from a used package.

package clj

(package & [a & xs])

Defines a set of stylesheet modules that can be separately compiled.

param clj

(param & [a & xs])

Used to define a formal parameter to a template, the stylesheet, a function, or an iteration.

perform-sort clj

(perform-sort & [a & xs])

Takes a sequence as its input and produces a sorted sequence as its output.

preserve-space clj

(preserve-space a)

Used at the top level of the stylesheet to define elements in the source document for which whitespace nodes are significant and should be retained.

processing-instruction clj

(processing-instruction & [a & xs])

Causes an XML processing instruction to be output.

result-document clj

(result-document & [a & xs])

Used to direct output to a secondary output destination.

sequence clj

(sequence & [a & xs])

Used to construct arbitrary sequences. It may select any sequence of nodes and/or atomic values, and essentially adds these to the result sequence.

sort clj

(sort & [a & xs])

Used within for-each, apply-templates, for-each-group, or perform-sort to indicate the order in which the selected elements are processed.

source-document clj

(source-document & [a & xs])

Used to initiate streamed processing of a source document.

strip-space clj

(strip-space a)

Used at the top level of the stylesheet to define elements in the source document for which whitespace nodes are insignificant and should be removed from the tree before processing.

stylesheet clj

(stylesheet & [a & xs])

The xsl:stylesheet element is always the top-level element of an XSLT stylesheet. The name xsl:transform may be used as a synonym.

template clj

(template & [a & xs])

Defines a processing rule for source elements or other nodes of a particular type.

text clj

(text & [a & xs])

Causes its content to be output. The main reason for enclosing text within an xsl:text element is to allow whitespace to be output. Whitespace nodes in the stylesheet are ignored unless they appear immediately within an xsl:text element.

try clj

(try & [a & xs])

In conjunction with catch, the xsl:try instruction allows recovery from dynamic errors occurring within the expression it wraps.

use-package clj

(use-package & [a & xs])

Used to allow components of one package to be referenced within another.

value-of clj

(value-of & [a & xs])

Evaluates an expression as a string, and outputs its value to the current result tree.

variable clj

(variable & [a & xs])

Evaluates an expression as a string, and outputs its value to the current result tree.

when clj

(when & [a & xs])

Used within choose to indicate one of a number of choices.

where-populated clj

(where-populated & [a & xs])

Used to allow conditional content construction to be made streamable. Used to avoid outputting an element if it would have no children.

with-param clj

(with-param & [a & xs])

Used to define an actual parameter to a template: within call-template, apply-templates, apply-imports, next-match. Also used to define parameters to an iteration (using next-iteration) or to a dynamic invocation of an XPath expression (using evaluate).