the XPath Function: number ceiling(number)
The ceiling function returns the smallest
(closest to negative infinity) number that is not less than the
argument and that is an integer.
SAX characters event -- send the characters to our current handler
construct some characters in the result
clone after loadStylesheet()
enables us to re-use a transformer, without recompiling the stylesheet
Number formatting utility classes
A simple DOM (level 1) API for XT
This simple API is based purely on the
DOM.
Expression parsing and evaluation
This package provides facilities for parsing and evaluating
XSLT expressions which include XPath expressions, template
match patterns and attribute templates.
The XML object model
This package provides the APIs of the XML object model
used internally by XT code.
The SAX (version 1) API for XT
This package provides APIs for invoking XT with
SAX 1 parsers providing input stylesheets and source
document
This version of XT continues the public interface of earlier
versions.
The transformation engine
This package provides facilities for parsing and "compiling"
XSLT stylesheets as well as executing the stylesheet with
a source document to effect a transformation.
Miscellaneous utilities for sorting, etc.
construct a comment in our result
receives comment events from a parser, a la SAX1.0
Wraps a W3C DOM XML Comment Node as an om.Node
also compares document order
also compares document order
After all the patterns and actions have been added,
this must be called to
organize them to facilitate quick finding of the
best template action when "apply-templates" is
performed on a Node
Return an expression for this/expr
an expression which composes two sub-expressions
(for each node in expr1, evaluate expr2)
construct with two sub-expressions
represents the XPath Function: string concat(string, string, string*)
has the method makeCallExpr which will construct a String expression
representing the concat function
presents a om.Node interface for a W3C DOM Node
Represents the XPath Function: boolean contains(string, string)
The contains function returns true if the first argument
string contains the second argument string, and
otherwise returns false.
Writes a SAX 2 event stream to a Result
An expression which is a boolean, but depending
on its use, may be converted to a Number, String or Object
An XPath expression (component) which can be cast to
any of several types as needed
A compiled XPath pattern component which returns a Node set, but is
convertible (castable) to a String expression, boolean expression
or VariantExpression
Represents the XPath
Function: number count(node-set)
The count function returns the number of nodes in
the argument node-set.
construct the DocumentHandler for the given outputMethodName
appropriate for the destination with which this object had been
constructed
obtain a DocumentHandler appropriate for the named
output method and our destination
obtain a Name with no namespace
create a name in the document's (null) namespace
for a non-qualified name
obtain a name in the given namespace
construct (or find) a Name for the given qName in the
given Namespace
construct one of these guys for a given output URI (destination)
complies the stylesheet from the parsed OM
Represents the XSLT Function: node-set current()
The current function returns a node-set that has the
current node as its only member.
the XSLT function 'element-available("qname")'
A compiled XPath expression (component)
tests a node for being an ELEMENT with a
given Name
construct with the Name to be tested
maps between Java and IANA character encoding names
flush any pending construction work, nothing else will be built
An engine, compiles a stylesheet
compiles a stylesheet from a (XSLT D)OM
we'll keep track of the loader/processor for sheet creation time
evaluate to result of a double
when evaluated, return a NodeIterator of parent and its
ancestors
When evaluated, returns a Node iterator for
the context node and its ancestors
evaluate each of the two sub-expressions with the given
context Node and given context, return the concatenation
of the results of each evaluation
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate with a context node and an expression context
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate with the given contextNode and context
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate the sub-expression with the context node's
root node
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
evaluate with the given contextNode and context
evaluate the expression with a contextNode
and ExprContext
evaluate the expression with a contextNode
and ExprContext
returns the two-part Name for the given qName
returns the two-part Name for the given qName
packages up the context available to the XSLT engine
when evaluating XPath expressions
XPAth expression parser / compiler
extends the lexer ExprTokenizer
lexical analyser for XPath 1.0
construct with the string to be tokenized
for extension functions -- i think
for invoking XSLT extension functions (??)
finds the first pattern in the list that matches the
given Node in the given ExprContext.
return a nodelist of the nodes with the "use" value
which matches the supplied argument
finds and returns the TemplateAction that is the best match
(or highest priority) for the given Node in the given context
get an enumeration of all Rules that might match
the given Node in the given ExprContext
by default, only return a list of length one (itself)
may represent an "or" grouping, so
we allow them to be broken
out and dealt with separately
does this only work on Elements?
does this only work on Elements?
default behavior -- return null.
does this only work on Elements?
does this only work on Elements?
does this only work on Elements?
top level attributes of the sheet e.g.
does this only work on Elements?
does this only work on Elements?
default behavior -- return null.
default behavior -- return null.
Returns text for TEXT node; value for attribute node;
content for comment node;
content after PI for PI node;
Returns text for TEXT node; value for attribute node;
content for comment node;
content after PI for PI node;
default behavior -- return null.
Returns text for TEXT node; value for attribute node;
content for comment node;
content after PI for PI node;
priority when used in XSLT template match pattern
priority when used in XSLT template match pattern
priority when used in XSLT template match pattern
priority when used in XSLT template match pattern
priority when used in XSLT template match pattern
priority when used in XSLT template match pattern
priority when used in XSLT template match pattern
loads the document at the given URI
returns a parsed representation of the document at the given
URL.
load an object model representation of the XML document at
a url constructed from the two arguments
finds an Element Node, in the this node's document,
with the given ID
finds an Element Node, in the this node's document,
with the given ID
finds an Element Node, in the this node's document,
with the given ID
obtain an empty NamespacePrefixMap
obtain an empty NamespacePrefixMap
Returns the IANA name of the encoding actually used.
return an object we can attach in a pipe
guaranteed to be unique (and repeatable)
guaranteed to be unique (and repeatable)
guaranteed to be unique (and repeatable)
access to the stylesheet's global variables
access to the stylesheet's global variables
include processing instructions?
obtain the definition of the named key
obtain the definition of the named key
if decorated with locator events, this returns the line number
in the XML source where this node was found
if decorated with locator events, this returns the line number
in the XML source where this node was found
get the part of the name that has no prefix
access to the stylesheet's in-scope local variables
access to the stylesheet's in-scope local variables
by default, returns null
Element, Attribute and PI nodetype tests will override this
gets the rightmost (final) step's matchNodeType
by default, returns null
Element, Attribute and PI nodetype tests will override this
by default, returns null
Element, Attribute and PI nodetype tests will override this
gets the rightmost (final) step's matchNodeType
obtain the collection of templates which may be
applied in a named Mode
obtain the collection of templates which may be
applied in a named Mode
default behavior -- return null.
Returns element type name for element; attribute name for an attribute;
target for a PI.
Returns element type name for element; attribute name for an attribute;
target for a PI.
default behavior -- return null.
get the URI reference that is the namespace
gets the owning Document's root
gets the owning Document's root
returns an XRAP processor, packaged as a SAX filter
gets the xrap (extension) processor for use during processing
gets the xrap processor for use during processing
provides access to the system properties for the
system-property() function in XSLT 1.0 section 12.4
provides access to the system properties for the
system-property() function in XSLT 1.0 section 12.4
return the value of the named system property
for converting to a NodeSet ??
returns one of: ELEMENT, TEXT, ATTRIBUTE,
ROOT, PROCESSING_INSTRUCTION or COMMENT
returns one of: ELEMENT, TEXT, ATTRIBUTE,
ROOT, PROCESSING_INSTRUCTION or COMMENT
returns one of: ELEMENT, TEXT, ATTRIBUTE,
ROOT, PROCESSING_INSTRUCTION or COMMENT
returns one of: ELEMENT, TEXT, ATTRIBUTE,
ROOT, PROCESSING_INSTRUCTION or COMMENT
returns one of: ELEMENT, TEXT, ATTRIBUTE,
ROOT, PROCESSING_INSTRUCTION or COMMENT
returns one of: ELEMENT, TEXT, ATTRIBUTE,
ROOT, PROCESSING_INSTRUCTION or COMMENT
gets the value for a variable or parameter
cast it as a boolean expression
cast it as a boolean expression
cast it as a boolean expression
cast it as a NodeSet expression (by default, don't)
cast it as a NodeSet expression (by default, don't)
cast it as a Number expression
cast it as a Number expression
cast it as a Number expression
cast it as a Predicate expression
cast it as a Predicate expression
cast it as a Predicate expression
A ConvertibleExpr allows for the casting of
one type to another for the purpose of making a comparison
cast it as a String expression
cast it as a String expression
cast it as a String expression
cast it as a String expression
cast it as a Variant (a variable or param you can
bind to a name) expression
cast it as a Variant (a variable or param you can
bind to a name) expression
cast it as a Variant (a variable or param you can
bind to a name) expression
return true if the given node matches this pattern
when evaluated in the given ExpressionContext
return true if the given node matches this pattern
when evaluated in the given ExpressionContext
return true if the given node matches this pattern
when evaluated in the given ExpressionContext
return true if this represents the "node()" test, else
return true if the node's type matches the test
if the rightmost step matches, and our parentPattern's matches() returns true for
this node's parent then we have a winner!
return true if the given node matches this pattern
when evaluated in the given ExpressionContext
does some sort of sort/merge on NodeIterators, I think
construct with an array of iterators
Names are the same if they have the same namespace, local part and
creator.
associates Namespaces with prefixes
constructs (or obtains) Names for qName/namespace pairs
contains a NamespacePrefixMap
return the next Node in the list
return the next Node in the list
return the next Node in the list
get the next Node in the list, and don't throw any Exception
lexes the next token, leaving the token type in
currentToken
, and the value (if applicable) in
tokenValue
return the next Node in the list
finds and returns the next node (in document(s) order?)
return the next Node in the list
return the next Node in the list
return the next Node in the list
get the next Node in the list, and don't throw any Exception
get the next Node in the list, and don't throw any Exception
represents a Node in an XML document
Base class wrapper which presents our xt om Node
interface around a W3C Level 1 DOM node
represents a list of Nodes
Like the name suggests, provides a mechanism to sort
the nodes in a NodeIterator based upon the test of
Comparator
A NodeSetExpr (compiled XPath), when evaluated with a contextNode
and an ExpressionContext, yields a NodeIterator
Simply tests if a node is of a given type e.g.
construct with one of the constants from om.Node
provides a singleton Node iterator representing 0 Nodes
formats an integer into a String
an output handler that handles our special technique
for non XML characters
binds a parameter to it's value
a place to obtain run-time parameters from the
execution environment
represents the concatenation of step patterns, right to left
in a LocationPathPattern
construct with a new stepPattern: childPattern and a previous parentPattern
load the input document into a (xslt) object model,
and run the transform
Parse the attributes on node as literal attributes and then
parse the actions.
parse an XPath expression which is to be
used in a context in which a Boolean is expected
parse an XPath expression which is to be
used in a context in which a NodeSet is expected
i.e.
parse an XPath expression which is to be
used in a context in which a Number is expected
parse an XPath match Pattern
parse an XPath match pattern (with some variables!?!?)
parse an XPath expression which is to be
used in a context in which a String is expected
come here if we have a "stylesheet" root element
expect XSLT elements permitted at the top level ...
parse an XSLT attribute value template (which may include
XPath expression(s) enclosed in curlybraces "{" "}")
parse an XPath expression which is to be
used in a context in which a Variant (xsl:variable, xsl:param)
is expected
a compiled XPath expression which has an
XSLT match priority
a (component of) a compiled XPath pattern expression
an XPATH (XSLT) match pattern
This is where we come to find which template match pattern
applies to any given node when we do an apply-templates.
pops a character handler off the stack, reverting to previous
(does this need to be public?)
implements the XPath position() function, which
evaluates to the current node's position in the current node set
The algorithm is:
(define (preceding x)
(define (reverse-subtree x)
(append (map reverse-subtree (reverse (children x)))
(list x)))
(map (lambda (y)
(map reverse-subtree (preceding-sibling y)))
(ancestor-or-self x)))
transform the document rooted at
node
against this stylesheet
process an XML input document against this stylesheet
perform the transformation
Processing context for a Stylesheet (Sheet)
maintains state for a transformation, and
actually does some of the transformation work
by calling invoke() on Actions
manages the state of a transformation
(and performs the transformation
of a source document against an XSLT stylesheet)
SAX Processing Instruction event handler -- strips PI's from output
construct a processingInstruction in the result
represents a list of Nodes -- the next() function promises to not throw an exception
an object which is able to provide a SAX2 XMLFilter
We use these for some experimental XSLT extension elements
Composition when expr1 is SINGLE_LEVEL and expr2 is STAYS_IN_SUBTREE.
we can have either an OutputMethodHandler,
or a DocumentHandler, not both
get the appropriate DocumentHandler from the
outputMethodHandler (we've already obtained for our destiantion)
for the named output method
set the output target for the transform
we can have either an OutputMethodHandler,
or a DocumentHandler, not both
set the run-time parameters for the stylesheet
setParser must be called before any other methods
use same parser for input and styleSheet
set one parser for the stylesheet, and another for the input
sets the experimental xrap processor for use during processing by
the ProcessContext
sets the xrap processor for use during processing
sets a special kind of extension element processor
N.B.
sets an extension element processor for XRAP
Represents a (compiled) XSLT stylesheet.
provides access to the additional information in the compiled
stylesheet that the implementation of the ProcessContext
needs to get at, but we don't need to share with other packages
Actually does the work of compiling the stylesheet's object model
into the template rules, actions, variable definitions, etc.
The constructor builds (compiles) a stylesheet
If this is set, then all nodes in the result of eval(x, c) are
guaranteed to be at the same level of the tree.
sorts a node list before returning them from
a nested expression
initialize, (and possibly construct) the DocumentHandler
SAX startDocument parse event
(NB) The nsMap must declare the prefix on elementType correctly.
start construction an Element
(NB) The nsMap must declare the prefix on elementType correctly.
captures "control", "data", "char" and "escape" character indicators
and interposes the appropriate character handler
we're finished with adding attributes?
If this is set, then all nodes in the result of eval(x, c)
are guaranteed to be in the subtree rooted at x.
an XPath expression which evaluates to a String
descendants-or-self(node())/E when E has STAYS_IN_SUBTREE
implements the system-property() function, XSLT 1.0, section 12.4