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
SAX characters event -- send the characters to our current handler
construct some characters in the result
construct some characters in the result
resets the output method properties to just those which
were set in the stylesheet
resets the output method to just those properties which were
set in the stylesheet and/or defaults
Clear all parameters set with setParameter.
clone after loadStylesheet()
enables us to re-use a transformer, without recompiling the stylesheet
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 SAX (version 2) API for XT
This package provides APIs for invoking XT with
SAX 2 XMLReaders providing input stylesheets and source
document
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.
recieve notification that a comment has been encountered
in the parse
recieve notification that a comment has been encountered
in the parse
recieve notification that a comment has been encountered
in the parse
recieve notification that a comment has been encountered
in the parse
construct a comment in our result
construct a comment in our result
recieve notification that a comment has been encountered
in the parse
receives comment events from a parse
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.
Converts a SAX 2 event stream to calls on a Result -- which
is useful for connecting to extension elements
which generate SAX events
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 ContHandler for the given outputMethodName
appropriate for the destination with which this object had been
constructed
obtain a ContentHandler appropriate for the named
output method and our destination
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)
construct one of these guys for a given output URI (destination)
Creates a new instance for writing to the given URI.
Create a Result that can write to the given uri.
Create a new Result object for serializing to
the destination uri.
Create a new Result object for serializing to
the destination uri.
complies the stylesheet from the parsed OM
complies the stylesheet from the parsed OM providing a debugger
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
emit a representation of this result tree fragment
as a sequence of SAX events to the given ContentHandler
maps between Java and IANA character encoding names
Finish constructing stuff.
flush any pending construction work, nothing else will be built
flush any pending construction work, nothing else will be built
Finish constructing stuff.
receive notice of doc's end
end of stylesheet SAX events, compile it
Finish constructing an Element
Finish constructing an Element
Finish constructing an Element
receive notice of an element's end ...
Notify the Element is ending
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
report an error to stderr
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 Attribute's qName
non-colonized names are returned as belonging to no namespace
returns the two-part Name for the given qName
non-colonized names are identified in the default namespace, if there
is one, else no namespace
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 (??)
A base class for output Destinations, providing some common
default behaviors
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
Get the stylesheet specification(s) associated
via the xml-stylesheet processing instruction (see
http://www.w3.org/TR/xml-stylesheet/) with the document
document specified in the source parameter, and that match
the given criteria.
does this only work on Elements?
does this only work on Elements?
default behavior -- return null.
Throws an IllegalArgumentException since attributes are not supported.
all the known output method attribute names, excluding
"method" and "cdata-section-elements"
does this only work on Elements?
does this only work on Elements?
does this only work on Elements?
top level attribute set definition
does this only work on Elements?
does this only work on Elements?
default behavior -- return null.
the "cdata-section-elements" attribute
In this implementation, its a NameTable
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;
are we instrumenting this transformer?
gets the xrap (extension) processor for use during processing
gets the xrap processor for use during processing
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
Returns the IANA name of the encoding actually used.
returns the IANA character encoding name
Get the error event handler for the TransformerFactory.
Get the error event handler in effect for the transformation.
Look up the value of a feature.
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?
Attributes implementation: get the index of the Attribute
with the given Name components, or null if
it does not exist
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
Attributes implementation: get the Attribute's local name
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
A NamespacePrefixMap is associated with a single NameTable
used for obtaining Names from namespace / localName pairs
returns the current values set either by client code,
the stylesheet, or defaulted for the output method properties
returns the current values set either by client code,
the stylesheet, or defaulted for the output method properties
returns the current values set either by client code,
the stylesheet, or defaulted for the output method properties
see java.xml.transform.Transform.getOutputMethodProperties()
returns the current values set either by client code,
the stylesheet, or defaulted for the output method properties
see java.xml.transform.Transform.getOutputMethodProperties()
returns the current value of the named property
returns the current value of the named property
Return a empty Properties object.
initialize with the given (Java) character encoding name,
ignore the mime contentType and return the OutputStream
for an OutputHandler to write to
gets an OutputStream for the named (Java style) character encoding
and mime content type.
Get a parameter that was explicitly set with setParameter
or setParameters.
recognizes names in the form "{namespace-part}local-part"
as used in TrAX
Properties implementation: get the value of the named property
gets the value specified in the stylesheet, if available,
else gets the defaulted value
gets the owning Document's root
gets the owning Document's root
returns an XRAP (Extension element) processor, packaged
as a SAX filter
gets the xrap (extension) processor for use during processing
gets the xrap processor for use during processing
The number of bound prefixes
get the parameters controlling how a source tree object model
is build
return the value for the named output method attribute,
only if that attribute was specified in the stylesheet
qets the base URI associated with the stylesheet
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
When a TemplatesHandler object is used as a ContentHandler for
the parsing of transformation instructions, it creates a Templates
object, which the caller can get once the SAX events have been
completed.
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
Attributes implementation: get the namespace for the
i'th Attribute's name
Return the URIResolver that was set with setURIResolver.
Get an object that will be used to resolve URIs used in
document(), etc.
Attributes implementation: get the value of the i'th Attribute
Attributes implementation: get the value of the named
Attribute
Attributes implementation: get the value of the Attribute
with the given name in the given namespace
the String value of the Attribute, or null
if
it does not exist
gets the value for a variable or parameter
get a Writer for an OutputHandler to write characters to
our default behavior is to construct a new Writer around
the OutputStream associated with this Destination.
A Name is a two part object, consisting of a namespace (String
)
and a local part (String
with no colon)
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
manages collections of Names and NamespacePrefixMaps
Empty constructor initializes prefix map
Process the Source into a Templates object, which is a
a compiled representation of the source.
Get a TemplatesHandler object that can process SAX ContentHandler events into a
Templates object.
Create a new transformation context for this Templates object.
Create a new Transformer object that performs a copy
of the source to the result.
Process the Source into a Transformer object.
Return null since XMLFilters are not yet supported.
Return null since XMLFilters are not yet supported.
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
an output handler that recognizes our special technique
for signalling 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
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 "xsl: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?)
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 the dispatching 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
SAX Processing Instruction event handler -- strips PI's from output
Construct a Processing Instruction
construct a processingInstruction in the result
construct a processingInstruction in the result
Construct a Processing Instruction
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
constructs an (XT) object model from SAX2 events
constructs an (xslt) XML object model from SAX2 events
N.B.
make sure you call init() if you construct with this method
Composition when expr1 is SINGLE_LEVEL and expr2 is STAYS_IN_SUBTREE.
provides and initializes an output stream to (through)
a ServletResponse
Throws an IllegalArgumentException since attributes are not supported.
set the output target for the transform.
we can have either an OutputMethodHandler,
a ContentHandler or DocumentHandler, not two or three
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 a special kind of extension element processor
N.B.
sets an extension element processor for XRAP
set the target of our output stream
we can have either an OutputMethodHandler,
or a DocumentHandler, not both
sets the IANA character encoding name from a Java character
encoding name.
Set the error event listener for the TransformerFactory, which
is used for the processing of transformation instructions,
Set the error event listener in effect for the transformation.
get the appropriate DocumentHandler from the
outputMethodHandler (we've already obtained for our destiantion)
for the named output method
get the appropriate ContentHandler from the
outputMethodHandler (we've already obtained for our destination)
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 output target for the transform.
we can have either an OutputMethodHandler,
or a DocumentHandler, not both
override the stylesheet's or default value for an
output method property
override the stylesheet's or default value for an
output method property
Set the output properties for the transformation.
Set an output property that will be in effect for the
transformation.
Add a parameter for the transformation.
set the run-time parameters for the stylesheet
set the run-time parameters for the stylesheet
recognizes names in the form "{namespace-part}local-part"
as used in TrAX
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
set one parser for the stylesheet, and another for the input
set two XMLReaders (may be the same XMLReader), #1 for
parsing the XML source to transform, #2 for parsing the stylesheeet.
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 a special kind of extension element processor
N.B.
sets an extension element processor for XRAP
sets an extension element processor for XRAP
prepare for parsing the input XML document
prepare for parsing the input XML document
sets the base URI we want to associate with the stylesheet
Set an object that will be used to resolve URIs used in
document().
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
Prepare to start constructing stuff.
initialize, (and possibly construct) the DocumentHandler
initialize, (and possibly construct) the ContentHandler
called by the transformation engine
Prepare to start constructing stuff.
SAX startDocument parse event
SAX startDocument parse event
receive notice of doc's start
SAX implementation: recieve notification of start of parse,
redirect all subsequent SAX events to our embedded object model
builder
Start constructing an Element
(NB) The nsMap must declare the prefix on elementType correctly.
start construction an Element
start construction an Element ...
Start constructing 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
captures "control", "data", "char" and "escape" character indicators
and interposes the appropriate character handler
the first start element, if it's "html" and in no namespace, then
we switch to an html contentHandler -- yucchh
we're finished with adding attributes?
notify that 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