xslt-fun.xtp

RESIN 3.2 最新源码

<xsl:attribute-set name='font'>
  <xsl:attribute name='font-size'>12pt</xsl:attribute>
  <xsl:attribute name='font-weight'>bold</xsl:attribute>
</xsl:attribute-set>

<xsl:template match='a'>
  <c xsl:use-attribute-sets='font'/>
</xsl:template>
</example>
<results>
&lt;c font-size='12pt' font-weight='bold'/&gt;
</results>

</s2>

<s2 name="pi" title="&lt;xsl:processing-instruction&gt;" type="defun">
<p>Creates a new processing instruction.</p>

<deftable>
<tr><th>Attribute</th><th>Meaning
</th></tr><tr><td>name</td><td>Processing instruction name.
</td></tr></deftable>

<example>
&lt;xsl:template match='a'&gt;
  &lt;xsl:processing-instruction name='foo'&gt;
  &lt;xsl:text&gt;Text for the PI&lt;/xsl:text&gt;
  &lt;/xsl:processing-instruction/&gt;
&lt;/xsl:template&gt;
</example>
<results>
&lt;?foo Text for the PI?&gt;
</results>
</s2>

<s2 name="comment" title="&lt;xsl:comment&gt;" type="defun">
<p>Creates a new comment.</p>  

<p>
The contents of the xsl:comment element
become the contents of the comment.
</p>

<example>
&lt;xsl:template match='a'&gt;
  &lt;xsl:comment&gt;
  &lt;xsl:text&gt;Text for the comment&lt;/xsl:text&gt;
  &lt;/xsl:processing-instruction/&gt;
&lt;/xsl:template&gt;
</example>
<results>
&lt;!--Text for the comment--&gt;
</results>
</s2>

<s2 name="copy" title="&lt;xsl:copy&gt;" type="defun">
<p>Copies the current node, but not children or attributes, to the
output.</p> 

<p>To copy an element, a stylesheet must copy the attributes as well.</p>

<p>The following example is the identity stylesheet. It copies input
to the output including the attributes.
</p>

<example>
&lt;xsl:template match='@*|node()'&gt;
  &lt;xsl:copy&gt;
    &lt;xsl:apply-templates select='@*|node()'/&gt;
  &lt;/xsl:copy&gt;
&lt;/xsl:template&gt;
</example>
</s2>

<s2 name="copy-of" title="&lt;xsl:copy-of .../&gt;" type="defun">
<p>Copies a sub-tree into the output.</p>  

<p>
<code>copy-of</code> resembles
<code>value-of</code>.  <code>value-of</code> always converts the value to a
string.  <code>copy-of</code> will copy subtrees. 
</p>

<deftable>
<tr><th>attribute</th><th>meaning
</th></tr><tr><td>select</td><td>An XPath expression to be copied.
</td></tr></deftable>
</s2>

<s2 name="variable" title="&lt;xsl:variable&gt;" type="defun">
<p>Assignes an XSL variable.</p>  

<p>
Variables can be retrieved using
the XPath variable syntax.
</p>

<deftable>
<tr><th>Attribute</th><th>Meaning
</th></tr><tr><td>name</td><td>variable name
</td></tr><tr><td>select</td><td>variable value
</td></tr></deftable>

<example>
&lt;xsl:variable name='foo' select='1+1'/&gt;

&lt;xsl:template match='a'&gt;
  &lt;xsl:value-of select='$foo'/&gt;
&lt;/xsl:template&gt;
</example>
<results>
2
</results>
</s2>

<s2 name="call-template" title="&lt;xsl:call-template&gt;" type="defun">
<p>Calls a named template with the current node.</p>
<p>
<code>xsl:call-template</code> lets stylesheets reuse common code, like
functions.  It works like <code>xsl:apply-templates select='.'</code>
except that it calls based on a template name.
</p>

<deftable>
<tr><th>Attribute</th><th>Meaning
</th></tr><tr><td>name</td><td>template name to call
</td></tr><tr><td>mode</td><td>template mode
</td></tr></deftable>
</s2>

<s2 name="param" title="&lt;xsl:param&gt;" type="defun">
<p>Declares an XSL parameter.</p>  

<p>
<code>xsl:param</code>'s
<code>select</code> parameter as a default.  If the variable has been
assigned, it uses the old value.
</p>

<deftable>
<tr><th>Attribute</th><th>Meaning
</th></tr><tr><td>name</td><td>variable name
</td></tr><tr><td>select</td><td>variable value
</td></tr></deftable>

<example>
&lt;xsl:template name='fun'&gt;
  &lt;xsl:param name='foo' select='15'/&gt;
  &lt;xsl:value-of select='$foo'/&gt;
&lt;/xsl:template&gt;

&lt;xsl:template match='a'&gt;
  &lt;xsl:call-template name='foo'&gt;
    &lt;xsl:with-param name='foo' select='1+2'/&gt;
  &lt;/xsl:call-template&gt;
&lt;/xsl:template&gt;
</example>
<results>
3
</results>
</s2>

<s2 name="apply-imports" title="&lt;xsl:apply-imports&gt;" type="defun">
<p>Like Java's <code>super</code>, calls the overridden template.</p>
</s2>

<s2 name="sort" title="&lt;xsl:sort&gt;" type="defun">
<p>Sorts nodes in xsl:apply-templates or
xsl:for-each.</p>

<deftable>
<tr><th>Attribute</th><th>Meaning
</th></tr><tr><td>select</td><td>value to sort on (default = '.')
</td></tr><tr><td>order</td><td>ascending or descending  (default = ascending)
</td></tr><tr><td>data-type</td><td>text or number (default = text)
</td></tr></deftable>

<note>case-order and lang attributes are not implemented</note>
</s2>

<s2 name="choose" title="&lt;xsl:choose ...&gt; ..." type="defun">
<p>Implements an if-elsif-else block.</p>  

<p>
The <code>xsl:when</code>
statements are tested in order.  The first matching one is executed.
If none match, the <code>xsl:otherwise</code> block is executed.
</p>

<deftable>
<tr><th>Attribute</th><th>Meaning
</th></tr><tr><td>test</td><td>XPath expression evaluating to a boolean.
</td></tr></deftable>

<example>
&lt;xsl:template match='a'&gt;
  &lt;xsl:choose&gt;
  &lt;xsl:when test='@color="red"'&gt;
    &lt;xsl:text&gt;stop&lt;/xsl:text&gt;
  &lt;/xsl:when&gt;
  &lt;xsl:when test='@color="green"'&gt;
    &lt;xsl:text&gt;go&lt;/xsl:text&gt;
  &lt;/xsl:when&gt;
  &lt;xsl:otherwise&gt;
    &lt;xsl:text&gt;yield&lt;/xsl:text&gt;
  &lt;/xsl:otherwise&gt;
  &lt;/xsl:choose&gt;
&lt;/xsl:template&gt;
</example>

</s2>
</s1>

<s1 name="xsl" title="Resin extensions">
<!--
<defun name=copy-element title='&lt;xtp:copy-element&gt;' version='resin1.0'>
<p>Copies the element to the output.</p>

<p><code/xtp:copy-element/> is extremely useful as a default rule.
With <code/xtp:copy-element/> as the default, the input gets copied to
the output.  Using the usual default, all tags get stripped.
</p>

<p>The standard default rule produces the following,</p>

<example>
&lt;a&gt;A text&lt;/a&gt;
&lt;b&gt;B text&lt;/b&gt;
</example>
<results>
A text
B text
</results>

<p>Using <code/xtp:copy-element/>, XSL stylesheets can copy elements
it doesn't understand.</p>

<example>
&lt;xsl:template match='*'&gt;
  &lt;xtp:copy-element&gt;
    &lt;xsl:apply-templates/&gt;
  &lt;/xtp:copy-element&gt;
&lt;/xsl:template&gt;
</example>

<example>
&lt;a&gt;A text&lt;/a&gt;
&lt;b&gt;B text&lt;/b&gt;
</example>
<results>
&lt;a&gt;A text&lt;/a&gt;
&lt;b&gt;B text&lt;/b&gt;
</results>


</defun>
-->
<s2 name="expression" title="&lt;xtp:expression&gt;expression ..." version="resin1.0" type="defun">
<p>Executes <var>expression</var> and prints it to the output.</p>
<p>
 Stylesheets can use any JavaScript expression.  The following
variables are pre-defined in stylesheets.
</p>

<deftable>
<tr><th>Variable</th><th>Meaning
</th></tr><tr><td>node</td><td>The current org.w3c.dom.Node.
</td></tr><tr><td>out</td><td>The com.caucho.xsl.XslWriter.
</td></tr></deftable>

<p>
In addition, the <var>out</var> variable gives access to the servlet
PageContext with the <var>page</var> property.
</p>

<example>
&lt;xsl:template match='welcome-user'&gt;
  &lt;xsl:text&gt;Welcome back, &lt;/xsl:text&gt;
  &lt;xtp:expression&gt;
    out.page.session.value.user
  &lt;xtp:expression&gt;
&lt;/xsl:template&gt;
</example>
</s2>
<s2 name="scriptlet" title="&lt;xtp:scriptlet&gt; statement_list" version="resin1.0" type="defun">
<p>Executes the <var>statement_list</var> scriptlet.</p>  

<p> The JavaScript code can be any statement list.  The same implicit
variables are allowed in scriptlets as in expressions.
</p>

<p>The following example creates a number of stars:</p>

<example>
&lt;@# page language='javascript' #&gt;
&lt;xsl:template match='ct:stars'&gt;
  &lt;xtp:scriptlet&gt;
    for (var i = 0; i &lt; node.attribute.count; i++)
      out.write('*');
  &lt;/xtp:scriptlet&gt;
&lt;/xsl:template&gt;
</example>

<example>
1 = &lt;ct:stars count='1'/&gt;
9 = &lt;ct:stars count='9'/&gt;
</example>
<results>
1 = *
9 = *********
</results>
</s2>

<s2 name="declaration" title="&lt;xtp:declaration&gt;" index="declaration" type="defun">
<p>Adds declaration code, i.e. code outside of any function.</p>

<example>
&lt;xtp:declaration&gt;
function dist(x1, y1, x2, y2)
{
  return Math.sqrt((x1 - x2) * (x1 - x2) +
                   (y1 - y2) * (y1 - y2));
}
&lt;/xtp:declaration&gt;

</example>

</s2>

<s2 name="page" title="&lt;xtp:directive.page attributes /&gt;" type="defun">
<p>Sets page directives</p>
<deftable>
<tr><th>name</th><th>meaning
</th></tr><tr><td>language</td><td>script language, default Java
</td></tr><tr><td>session</td><td>use sessions, default false
</td></tr><tr><td>errorPage</td><td>page to display for errors
</td></tr><tr><td>errorPage</td><td>page to display for errors
</td></tr><tr><td>import</td><td>imports Java packages 
</td></tr><tr><td>contentType</td><td>content-type of the generated page
</td></tr></deftable>

</s2>
<!--
<defun name=cache title='&lt;xtp:directive.cache attributes/>'>

<p>Caches the generated JSP file by default.</p>

<p>Caching for XSL is more complicated than for JSP because only some
templates may be used in a page.  Caching is based on the generated
page, not simply on the stylesheet.</p>

<p>A page that just uses static
templates is automatically cached.  Pages that use scripts just for
simple calculation can also be cached.  But pages that use scripts
based on the request cannot be cached.
</p>

<deftable>
<tr><th>name<th>meaning
<tr><td>file<td>the JSP file depends on <var/file/>.
<tr><td>no-cache<td>do not cache the generated JSP.
</deftable>

</defun>
-->

</s1>
  </body>
</document>