All Classes and Interfaces
Class
Description
Absolute iterators ignore the node that is passed to setStartNode().
This class runs over a path expression that is assumed to be absolute, and
checks for variables and the like that may make it context dependent.
AdaptiveResultTreeImpl is a adaptive DOM model for result tree fragments (RTF).
The 'and' operation expression executer.
This class holds an instance of an argument on
the stack.
Wraps a DOM attribute list in a SAX Attributes.
Wraps a DOM attribute list in a SAX Attributes.
This class implements an optimized iterator for
attribute axes patterns.
This class extends org.xml.sax.helpers.AttributesImpl which implements org.
Class to hold an Attribute Value Template.
Class to hold a part, either a string or XPath,
of an Attribute Value Template.
Simple string part of a complex AVT.
Simple string part of a complex AVT.
Serves as common interface for axes Walkers, and stores common
state variables.
Specifies values related to XPath Axes.
Base for iterators that handle predicates.
Standard XSLT functions.
The 'boolean()' operation expression executer.
Simple stack for boolean values.
Simple stack for boolean values.
CachedNodeListIterator is used for select expressions in a
variable or parameter.
The methods in this class are convenience methods into the
low-level XPath API.
It is a mutable object to wrap the char[] used in
the contents of the XResourceBundle class
This class implements an optimized iterator for
"node()" patterns, that is, any children of the
context node.
This class implements an optimized iterator for
children patterns that have a node test, and possibly a predicate.
The class that implements any class that inherits from
AbstractTranslet, i.e. any translet.
A ClonedNodeListIterator is returned by the cloneIterator() method
of a CachedNodeListIterator.
Class used to clone a node, possibly including its children to
a result tree.
An instance of this class compiles an XPath string expression into
a Expression object.
An interface used to build wrapper classes around existing
Connection Pool libraries.
Primary constants used in the TransformerImpl classes.
This class defines constants used by both the compiler and the
runtime system.
Primary constants used by the XSLT Processor
Special context node pattern matcher.
Classes who implement this interface can be a
current node list,
also refered to here as a context node list .
Support the coroutine design pattern.
Deprecated.
Since the ability to start a parse via the
coroutine protocol was not being used and was complicating design.
A class that does incremental counting for support of xsl:number.
This is a table of counters, keyed by ElemNumber objects, each
of which has a list of Counter objects.
Iterators of this kind use a CurrentNodeListFilter to filter a subset of
nodes from a source iterator.
CustomStringPool is an example of appliction provided data structure
for a DTM implementation to hold symbol references, e.g. elelment names.
Implement xsl:decimal-format.
Structure to help in converting integers to roman numerals
For internal connectiones, i.e.
Implement SAX error handler for default reporting.
This class implements an optimized iterator for
descendant, descendant-or-self, or "//foo" patterns.
The 'div' operation expression executer.
The
DOM2DTM class serves up a DOM's contents via the
DTM API.This is a kluge to let us shove a declaration for xml: into the
DOM2DTM model.
This class provides a DOM level 2 "helper", which provides services currently
not provided be the DOM standard.
Deprecated.
Since the introduction of the DTM, this class will be removed.
This interface is not intended to be used
by an end user, but rather by an XML parser that is implementing the DOM
Level 3 Load and Save APIs.
This class implements the DOM3Serializer interface.
This class takes SAX events (in addition to some extra events
that SAX doesn't handle yet) and adds the result to a document
or document fragment.
Interface for SAXImpl which adds methods used at run-time, over and above
those provided by the XSLTC DOM interface.
Deprecated.
Since the introduction of the DTM, this class will be removed.
Deprecated.
Since the introduction of the DTM, this class will be removed.
Deprecated.
Use org.apache.xml.serializer.DOMSerializer
Interface for a DOM serializer implementation.
A wrapper class that adapts the
DTMWSFilter interface to the XSLTC
DOM StripFilter interface.DTM is an XML document model expressed as a table
rather than an object tree.This class iterates over a single XPath Axis, and returns node handles.
This class serves as a default base for implementations of mutable
DTMAxisIterators.
DTMAxisNodeList gives us an implementation of the DOM's
NodeList interface wrapped around a DTM Iterator.A class that implements traverses DTMAxisTraverser interface can traverse
a set of nodes, usually as defined by an XPath axis.
DTMNodeList gives us an implementation of the DOM's
NodeList interface wrapped around a DTM Iterator.Indicates a serious configuration error.
The
DTMDefaultBase class serves as a helper base for DTMs.This class implements the traversers for DTMDefaultBase.
This class implements the traversers for DTMDefaultBase.
The SQL Document is the main controlling class the executesa SQL Query
This is the implementation of the DTM document interface.
Simple implementation of DOMException.
This class specifies an exceptional condition that occured
in the DTM module.
Simple filter for doing node tests.
DTMIterators are used to step through a (possibly
filtered) set of nodes.A DTMManager instance can be used to create DTM and
DTMIterator objects, and manage the DTM objects in the system.
The default implementation for the DTMManager.
DTMNamedNodeMap is a quickie (as opposed to quick) implementation of the DOM's
NamedNodeMap interface, intended to support DTMProxy's getAttributes()
call.
Simple implementation of DOMException.
DTMNodeIterator gives us an implementation of the
DTMNodeIterator which returns DOM nodes.DTMNodeList gives us an implementation of the DOM's
NodeList interface wrapped around a DTM Iterator.DTMNodeList gives us an implementation of the DOM's
NodeList interface wrapped around a DTM Iterator.DTMNodeProxy presents a DOM Node API front-end to the DTM model.Like DTMStringPool, but threadsafe.
DTMStringPool is an "interning" mechanism for strings.
This class does a pre-order walk of the DTM tree, calling a ContentHandler
interface as it goes.
This interface is meant to be implemented by a client of the DTM, and allows
stripping of whitespace nodes.
Removes duplicates and sorts a source iterator.
Implement xsl:apply-imports.
Implement xsl:apply-templates.
Implement xsl:attribute.
Implement xsl:attribute-set.
Implement xsl:call-template.
Implement xsl:choose.
Implement xsl:comment.
Implement xsl:copy.
Implement xsl:copy-of.
This class has a series of flags (bit values) that describe an HTML element
Implement xsl:element
Simple empty elem to push on the stack when nothing
else got pushed, so that pop() works correctly.
Handles the EXSLT result element within an EXSLT function element.
Implement func:function.
Implement an extension element.
Implement the declaration of an extension element
Implement Script extension element
Implement xsl:fallback.
Implement xsl:for-each.
Implement xsl:if.
Implement a Literal Result Element.
Implement xsl:message.
Implement xsl:number.
Implement xsl:otherwise.
Implement xsl:param.
Implement xsl:processing-instruction.
Implement xsl:sort.
Implement xsl:template.
An instance of this class represents an element inside
an xsl:template class.
Implement xsl:template.
Implement a text literal.
Implement an unknown element
Implement xsl:use.
Implement xsl:value-of.
Implement xsl:variable.
Implement xsl:when.
Implement xsl:with-param.
DTM Empty Axis Iterator.
This class is an adapter class.
Holds information about a given encoding, which is the Java name for the
encoding, the equivalent ISO name.
Provides information about encodings.
Event triggered by completion of a xsl:for-each selection or a
xsl:apply-templates selection.
Utility class to report simple information about the environment.
The '=' operation expression executer.
This is a default implementation of a table that manages mappings from
expanded names to expandedNameIDs.
This abstract class serves as the base for all expression objects.
An object that implements this interface can supply
information about the current XPath expression context.
A class that implements this interface can construct expressions,
give information about child and parent expressions,
and give the originating source information.
Classes that implement this interface own an expression, which
can be rewritten.
When
StylesheetHandler creates
an XPath, the ExpressionVisitor
visits the XPath expression.The base class for some EXSLT extension classes.
This class contains EXSLT common extension functions.
This class contains EXSLT dates and times extension functions.
This class contains EXSLT dynamic extension functions.
This class contains EXSLT math extension functions.
This class contains EXSLT set extension functions.
This class contains EXSLT strings extension functions.
This interface describes extensions to the SAX ContentHandler interface.
This interface has extensions to the standard SAX LexicalHandler interface.
The class ExtendedType represents an extended type object used by
ExpandedNameTable.
An event representing an extension call.
Abstract base class for handling an extension namespace for XPath.
Execute EXSLT functions, determine the availability of EXSLT functions, and the
availability of an EXSLT result element.
Class handling an extension namespace for XPath.
Abstract base class handling the java language extensions for XPath.
Represents an extension namespace for XPath that handles java classes.
Represents an extension namespace for XPath that handles java packages
that may be fully or partially specified.
A sample implementation of NamespaceContext, with support for
EXSLT extension functions and Java extension functions.
Used during assembly of a stylesheet to collect the information for each
extension namespace that is required during the transformation process
to generate an
ExtensionHandler.During styleseet composition, an ExtensionNamespaceSupport object is created for each extension
namespace the stylesheet uses.
This class contains many of the Xalan-supplied extensions.
Interface that XPath objects can call to obtain access to an
ExtensionsTable.
Class holding a table registered extension namespace handlers
Bare-bones, unsafe, fast string buffer.
Extends a StepIterator by adding the ability to filter nodes.
Class to use for one-step iteration that doesn't have a predicate, and
doesn't need to set the context.
Walker for the OP_VARIABLE, or OP_EXTFUNCTION, or OP_FUNCTION, or OP_GROUP,
op codes.
This class implements auxliary classes needed to compile
filters (predicates).
Similar to a CurrentNodeListIterator except that the filter has a
simpler interface (only needs the node, no position, last, etc.)
Deprecated.
This class exists only for backwards compatibility with old
translets.
Class to let us know when it's time to do
a search from the parent because of indexing.
Execute the Boolean() function.
Execute the Ceiling() function.
Execute the Concat() function.
Execute the Contains() function.
Execute the Count() function.
Execute the current() function.
Execute the proprietary document-location() function, which returns
a node set of documents.
Execute the Doc() function.
Execute the ExtElementAvailable() function.
An object of this class represents an extension call expression.
Execute the ExtFunctionAvailable() function.
Execute the False() function.
Execute the Floor() function.
Execute the FormatNumber() function.
Execute the GenerateId() function.
Execute the Id() function.
Execute the Key() function.
Execute the Lang() function.
Execute the Last() function.
Execute the LocalPart() function.
Execute the Namespace() function.
Execute the normalize-space() function.
Execute the Not() function.
Execute the Number() function.
Execute the Position() function.
Execute the Qname() function.
Execute the round() function.
Execute the StartsWith() function.
Execute the String() function.
Execute the StringLength() function.
Execute the Substring() function.
Execute the SubstringAfter() function.
Execute the SubstringBefore() function.
Execute the Sum() function.
Execute the SystemProperty() function.
This is a superclass of all XPath functions.
Base class for functions that accept two arguments.
Base class for functions that accept three arguments.
Base class for functions that accept one argument that can be defaulted if
not specified.
Base class for functions that accept an undetermined number of multiple
arguments.
Base class for functions that accept one argument.
Match pattern step that contains a function.
The function table for XPath.
Execute the Translate() function.
Execute the True() function.
Event generated by the XSL processor after it generates a new node in the result tree.
GetOpt is a Java equivalent to the C getopt() library function
discussed in man page getopt(3C).
The '>' operation expression executer.
The '>=' operation expression executer.
The main hash-table implementation
Simple static utility to convert Hashtable to a Node.
IncrementalSAXSource is an API that delivers a small number of
SAX events each time a request is made from a "controller"
coroutine.
IncrementalSAXSource_Filter implements IncrementalSAXSource, using a
standard SAX2 event source as its input and parcelling out those
events gradually in reponse to deliverMoreNodes() requests.
IncrementalSAXSource_Xerces takes advantage of the fact that Xerces1
incremental mode is already a coroutine of sorts, and just wraps our
IncrementalSAXSource API around it.
It is a mutable object to wrap the int[] used in
the contents of the XResourceBundle class
Marks a class of errors in which XSLTC has reached some incorrect internal
state from which it cannot recover.
Class to express failed assertions and similar for the xsltc runtime.
Implement a stack of simple integers.
A very simple table that stores a list of int.
Pool of object of a given type to pick from to help memory usage
Utility class to redirect input to JavaCup program.
This class implements a Default PrefixResolver which
can be used to perform prefix-to-namespace lookup
for the XPath object.
Overrides
VariableStack and delegates the call to
XPathVariableResolver.A Connection Pool that wraps a JDBC datasource to provide connections.
Holds the attribute declarations for the xsl:keys element.
Stores mappings of key values or IDs to DTM nodes.
This class implements an optimized iterator for
"key()" patterns, matching each node to the
match attribute in one or more xsl:key declarations.
This class manages the key tables.
This class filters nodes from a key iterator, according to
whether or not the use value matches the ref value.
Table of element keys, keyed by document node.
Table of strings to operation code lookups.
Sample implementation of similar SAX ErrorHandler and JAXP ErrorListener.
This class extends NodeSetDTM, which implements NodeIterator,
and fetches nodes one at a time in document order based on a XPath
invalid input: '<'a href="http://www.w3.org/TR/xpath#NT-LocationPath>LocationPath.
It is a mutable object to wrap the long[] used in
the contents of the XResourceBundle class
Implemenatation of DOM Level 3 org.w3c.ls.LSSerializer and
org.w3c.dom.ls.DOMConfiguration.
The 'invalid input: '<'' operation expression executer.
The 'invalid input: '<'=' operation expression executer.
This is a special kind of iterator that takes a source iterator and a
node N.
This class treats a
LocationPath as a
filtered iteration over the tree, evaluating each node in a super axis
traversal against the LocationPath interpreted as a match pattern.
A utility class for issuing error messages.
This class defines the constants which are the names of the four default
output methods.
Utility class to help resolve method overloading with Xalan XSLT
argument types.
The binary '-' operation expression executer.
The 'mod' operation expression executer.
This class is not a public API,
It is used internally by serializer and is public,
in the Java sense, only because its use crosses
package boundaries.
This class will manage error messages, warning messages, and other types of
message events.
The '*' operation expression executer.
MultiValuedNodeHeapIterator takes a set of multi-valued
heap nodes and produces a merged NodeSet in document order with duplicates
removed.Mutable version of AttributesImpl.
This class is used for named templates.
A representation of a namespace.
Object to hold an xsl:namespace element.
This class keeps track of the currently defined namespaces.
Namespace support for XML document handlers.
Encapsulate Namespace tracking logic for use by SAX drivers.
The unary '-' operation expression executer.
This class is used as "wrapper" for dom nodes.
The tree walker will test for this interface, and call
setOriginatingNode before calling the SAX event.
This class implements auxiliary classes needed to compile
patterns in xsl:number.
NodeInfo defines a set of XSLT extension functions to be
used from stylesheets.NodeLocator maintains information on an XML source
node.This class is the dynamic wrapper for a Xalan DTMIterator instance, and
provides random access capabilities.
The NodeSet class can act as either a NodeVector,
NodeList, or NodeIterator.
The NodeSetDTM class can act as either a NodeVector,
NodeList, or NodeIterator.
This class can sort vectors of DOM nodes according to a select pattern.
Base class for sort records containing application specific sort keys
Generator for subclasses of NodeSortRecordFactory.
This is the basic node test class for both match patterns and location path
steps.
This interface should be implemented by Nodes and/or iterators,
when they need to know what the node test is before they do
getNextChild, etc.
A very simple table that stores a list of Nodes.
The '!
This class holds information about the namespace info
of a node.
The 'number()' operation expression executer.
Provide a simple Array storage mechinsim where native Arrays will be use as
the basic storage mechinism but the Arrays will be stored as blocks.
Pool of object of a given type to pick from to help memory usage
Implement a stack of simple integers.
A very simple table that stores a list of objects.
This class implements a general iterator for
those LocationSteps with only one step, and perhaps a predicate.
This class implements a general iterator for
those LocationSteps with only one step, and perhaps a predicate,
that only go forward (i.e. it can not be used with ancestors,
preceding, etc.)
Operations codes for XPath.
The baseclass for a binary operation.
This class represents the data structure basics of the XPath
object.
Like IntVector, but used only for the OpMap array.
The 'or' operation expression executer.
This class provides information from xsl:output elements.
This class is a factory to generate a set of default properties
of key/value pairs that are used to create a serializer through the
factory
SerilizerFactory.This class contains some static methods that act as helpers when parsing a
Java Property object.
Classes who implement this information provide information needed for
static analysis of a path component.
PipeDocument is a Xalan extension element to set stylesheet params and pipes an XML
document through a series of 1 or more stylesheets.
The '+' operation expression executer.
The class that implements this interface can resolve prefixes to
namespaces.
This class implements a generic PrefixResolver that
can be used to perform prefix-to-namespace lookup
for the XPath object.
Implementation of the TraceListener interface that
prints each event to standard out as it occurs.
The main() method handles the Xalan command-line interface.
This class processes character events for a XSLT template element.
This class processes parse events for an exslt func:result element.
This class processes parse events for an exslt func:function element.
This class processes parse events for an xsl:import element.
TransformerFactory class for xsl:include markup.
Processes an XSLT literal-result-element, or something that looks
like one.
This class processes the xsl:stylesheet element.
TransformerFactory for xsl:stylesheet or xsl:transform markup.
This class processes parse events for an XSLT template element.
Process xsl:text.
This class processes an unknown template element.
Admin class that assigns a version number to the XSLTC software.
This is used to represent names of nodes that may not be named, like a
comment node.
Class to represent a qualified name: "The name of an internal XSLT object,
specifically a named template (see [7 Named Templates]), a mode (see [6.7 Modes]),
an attribute set (see [8.1.4 Named Attribute Sets]), a key (see [14.2 Keys]),
a locale (see [14.3 Number Formatting]), a variable or a parameter (see
[12 Variables and Parameters]) is specified as a QName.
This class acts as a base for ResultTreeHandler, and keeps
queud stack events.
Deprecated.
An interface that a Serializer/ContentHandler/ContentHandler must
implement in order for disable-output-escaping to work.
Implements three extension elements to allow an XSLT transformation to
redirect its output to multiple output files.
This class eleminates redundent XPaths from a given subtree,
and also collects all absolute paths within the subtree.
A representation of a result namespace.
Walker for a reverse axes.
This class is used for result trees implemented as methods.
This class implements a DTM that tends to be optimized more for speed than
for compactness, that is constructed via SAX2 ContentHandler events.
SAX2DTM2 is an optimized version of SAX2DTM which is used in non-incremental situation.
This is a subclass of SAX2DTM which has been modified to meet the needs of
Result Tree Frameworks (RTFs).
SAXImpl is the core model for SAX input source.
Class SAXSourceLocator extends org.xml.sax.helpers.LocatorImpl
for the purpose of implementing the SourceLocator interface,
and thus can be both a SourceLocator and a SAX Locator.
Event triggered by selection of a node in the style stree.
This class implements an optimized iterator for
"." patterns, that is, the self axes without any predicates.
The standard SAX implementation of LocatorImpl is not serializable,
limiting its utility as "a persistent snapshot of a locator".
This interface is the one that a serializer implements.
Deprecated.
Use org.apache.xml.serializer.Serializer
The Serializer interface is implemented by a serializer to enable users to:
get and set streams or writers
configure the serializer with key/value properties
get an org.xml.sax.ContentHandler or a DOMSerializer to provide input to
This class acts as a base class for the XML "serializers"
and the stream serializers.
Deprecated.
The new class to use is
org.apache.xml.serializer.SerializerFactory
This class is a public API, it is a factory for creating serializers.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
Default implementation.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
An instance of this class is a ListResourceBundle that
has the required getContents() method that returns
an array of message-key/message associations.
This is a helper class that decides if Xalan needs to switch
serializers, based on the first output element.
This interface defines a set of integer constants that identify trace event
types.
Class that contains only static methods that are used to "serialize",
these methods are used by Xalan and are not in org.apache.xml.serializer
because they have dependancies on the packages org.apache.xpath or org.
This class represents a light-weight DOM model for simple result tree fragment(RTF).
Implementation of a transformer factory that uses an XSLTC
transformer factory for the creation of Templates objects
and uses the Xalan processor transformer factory for the
creation of Transformer objects.
This object represents a Source Tree, and any associated
information.
This class bottlenecks all management of source trees.
The SQL Document is the main controlling class the executesa SQL Query
The SQL Document is the main controlling class the executesa SQL Query
Class to guard against recursion getting too deep.
A step iterator is used to evaluate expressions like "BOOK/TITLE".
This class represents a single pattern match step.
This is a special exception that is used to stop parsing when
search for an element.
The 'string()' operation expression executer.
It is a mutable object to wrap the String[] used in
the contents of the XResourceBundle class
This class pools string buffers, since they are reused so often.
International friendly string comparison with case-order
A very simple lookup table that stores a list of strings, the even
number strings being keys, and the odd number strings being values.
A very simple lookup table that stores a list of strings, the even
number strings being keys, and the odd number strings being values.
A very simple lookup table that stores a list of strings, the even
number strings being keys, and the odd number strings being values.
A very simple table that stores a list of StringToStringTables, optimized
for small lists.
A very simple table that stores a list of strings, optimized
for small lists.
Represents a stylesheet element.
Represents a stylesheet that has methods that resolve includes and
imports.
Initializes and processes a stylesheet via SAX events.
Search for the xml-stylesheet processing instructions in an XML document.
This class represents the root object of the stylesheet tree.
A very simple table that stores a list of byte.
A very simple table that stores a list of int.
A class that implements this interface is a sub context node list, meaning it
is a node list for a location path step for a predicate.
CUP generated class containing symbol constants.
This class is used to resolve relative URIs and SystemID
strings into absolute URIs.
This class is used to resolve relative URIs and SystemID
strings into absolute URIs.
Encapsulates a template list, and helps locate individual templates.
Implementation of a JAXP1.1 TemplatesHandler
A utility class that wraps the ThreadController, which is used
by IncrementalSAXSource for the incremental building of DTM.
Thread controller utility class for incremental SAX source.
Deprecated.
As of Xalan 2.7.1, replaced by the use of
ToXMLSAXHandler.This serializer takes a series of SAX or
SAX-like events and writes its output
to the given stream.
This class is used to provide a base behavior to be inherited
by other To...SAXHandler serializers.
This abstract class is a base class for other stream
serializers (xml, html, text ...) that write output to a stream.
Deprecated.
As of Xalan 2.7.1, replaced by the use of
ToXMLSAXHandler.This class is not a public API.
This class wraps another SerializationHandler.
This class receives notification of SAX-like events, and with gathered
information over these calls it will invoke the equivalent SAX methods
on a handler, the ultimate xsl:output method is known to be "xml".
This class converts SAX or SAX-like calls to a
serialized xml document.
Interface the XSL processor calls when it matches a source node, selects a set of source nodes,
or generates a result node.
Extends TraceListener but adds a SelectEnd event.
Extends TraceListenerEx but adds a EndTrace event.
Extends TraceListenerEx2 but adds extensions trace events.
This class manages trace listeners, and acts as an
interface for the tracing functionality in Xalan.
Parent class of events generated for tracing the
progress of the XSL processor.
A content handler can get a reference
to a TransformState by implementing
the TransformerClient interface.
The TransformerFactoryImpl, which implements the TRaX TransformerFactory
interface, processes XSLT stylesheets into a Templates object
(a StylesheetRoot).
Implementation of a JAXP1.1 TransformerFactory for Translets.
A TransformerHandler
listens for SAX ContentHandler parse events and transforms
them to a Result.
Implementation of a JAXP1.1 TransformerHandler
This class implements an identity transformer for
SAXTransformerFactory.newTransformerHandler()
and TransformerFactory.newTransformer().This class implements the
Transformer interface, and is the core
representation of the transformation execution.Deprecated.
It doesn't look like this code, which is for tooling, has
functioned propery for a while, so it doesn't look like it is being used.
This interface is meant to be used by a consumer of
SAX2 events produced by Xalan, and enables the consumer
to get information about the state of the transform.
This interface is meant to be used by a base interface to
TransformState, but which as only the setters which have non Xalan
specific types in their signature, so that there are no dependancies
of the serializer on Xalan.
skeleton extension of XMLFilterImpl for now.
This class does a pre-order walk of the DOM tree, calling a ContentHandler
interface as it goes.
This class does a pre-order walk of the DOM tree, calling a ContentHandler
interface as it goes.
Handle a walk of a tree, but screen out attributes for
the result tree.
The unary operation base class.
To be subclassed by classes that wish to fake being nodes.
This class defines a simplified type of union iterator that only
tests along the child axes.
UnionIterator takes a set of NodeIterators and produces
a merged NodeSet in document order with duplicates removed
The individual iterators are supposed to generate nodes
in document order
This class extends NodeSetDTM, which implements DTMIterator,
and fetches nodes one at a time in document order based on a XPath
UnionExpr.
This class represents a union pattern, which can have multiple individual
StepPattern patterns.
A class to represent a Uniform Resource Identifier (URI).
MalformedURIExceptions are thrown in the process of building a URI
or setting fields on a URI when an operation would result in an
invalid URI specification.
This class contains utilities used by the serializer.
The variable reference expression executer.
This is a "smart" variable reference that is used in situations where
an absolute path is optimized into a variable reference, but may
be used in some situations where the document context may have changed.
Defines a class to keep track of a stack for
template arguments and variables.
This class visits variable refs in an XPath and collects their QNames.
Administrative class to keep track of the version number of
the Xalan release.
Administrative class to keep track of the version number of
the Serializer release.
This class is both a factory for XPath location path expressions,
which are built from the opcode map output, and an analysis engine
for the location path expressions in order to provide optimization hints.
Location path iterator that uses Walkers.
This class iterates over set of nodes that needs to be sorted.
This is used as a special "fake" template that can be
handled by the TemplateList to do pattern matching
on nodes.
A class that implements this interface can tell if a given element should
strip whitespace nodes from it's children.
This class is for throwing important checked exceptions
over non-checked methods.
This class is for throwing important checked exceptions
over non-checked methods.
An exception that is thrown if the wrong number of arguments to an exception
are specified by the stylesheet.
Certain functions may throw this error if they are paired with
the incorrect parser.
XalanProperties defines the features understood by
Xalan.Before the serializer merge, the TransformState interface was
implemented by ResultTreeHandler.
This class represents an XPath boolean object, and is capable of
converting the boolean to other types, such as a string.
This class doesn't have any XPathContext, so override
whatever to ensure it works OK.
An XSLT extension that allows a stylesheet to
access JDBC data.
THIS IS A COPY OF THE XERCES-2J CLASS org.apache.xerces.utls.XMLChar
This class defines the basic properties of characters in XML 1.1.
THIS IS A COPY OF THE XERCES-2J CLASS org.apache.xerces.utls.XMLChar
This class defines the basic properties of characters in XML 1.1.
THIS IS A COPY OF THE XERCES-2J CLASS org.apache.xerces.utls.XMLChar
This class defines the basic XML character properties.
This class defines the basic XML character properties.
Class used to verify whether the specified ch
conforms to the XML 1.0 definition of whitespace.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Default implementation of XPATHErrorResources.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
A utility class for issuing XML error messages.
Represents an xmlns declaration
Creates XMLReader objects and caches them for re-use.
This class is meant to be an interface to character strings, whether they
be java Strings or
org.apache.xml.utils.FastStringBuffers, or
other character data.The default implementation of the XMLString interface,
which is just a simple wrapper of a String object.
A concrete class that implements this interface creates XMLString objects.
The default implementation of XMLStringFactory.
Class XMLStringFactoryImpl creates XString versions of XMLStrings.
This class represents an XPath nodeset object, and is capable of
converting the nodeset to other types, such as a string.
This class overrides the XNodeSet#object() method to provide the original
Node object, NodeList object, or NodeIterator.
This class represents an XPath null object, and is capable of
converting the null to other types, such as a string.
This class represents an XPath number, and is capable of
converting the number to other types, such as a string.
This class represents an XPath object, and is capable of
converting the object to various types, such as a string.
The XPath class wraps an expression object and provides general services
for execution of that expression.
The methods in this class are convenience methods into the
low-level XPath API.
Default class for the runtime execution context for XPath.
Class for XPath diagnostic functions.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Default implementation of XPATHErrorResources.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
The class provides an implementation of XPathEvaluator according
to the DOM L3 XPath Specification, Working Group Note 26 February 2004.
This class implements an exception object that all
XPath classes will throw in case of an error.
The XPathExpression interface encapsulates a (compiled) XPath expression.
Factory class for creating an XPath.
The XPathFactory builds XPaths.
A sample implementation of XPathFunction, with support for
EXSLT extension functions and Java extension functions.
A sample implementation of XPathFunctionResolver, with support for
EXSLT extension functions and Java extension functions.
The XPathImpl class provides implementation for the methods defined in
javax.xml.xpath.XPath interface.
A utility class for issuing XPath error messages.
CUP v0.11b 20160615 generated parser.
Tokenizes and parses XPath expressions.
Derived from XPathException in order that XPath processor
exceptions may be specifically caught.
A new exception to add support for DOM Level 3 XPath API.
A class that implements this interface will call a XPathVisitor
for itself and members within it's heararchy.
A derivation from this class can be passed to a class that implements
the XPathVisitable interface, to have the appropriate method called
for each component of the XPath.
The default (english) resource bundle.
This is an interface for error messages.
The Cyrillic resource bundle.
The German resource bundle.
The Greek resource bundle.
The English resource bundle.
The Spanish resource bundle.
The French resource bundle.
The Hebrew resource bundle.
The Armenian resource bundle.
The Italian resource bundle.
The Japanese (Katakana) resource bundle.
The Japanese (Hiragana) resource bundle.
The Japanese (Hiragana) resource bundle.
The Japanese (Katakana) resource bundle.
The Georgian resource bundle.
The Korean resource bundle.
The Swedish resource bundle.
The Chinese resource bundle.
The Chinese(Taiwan) resource bundle.
This class represents an XPath result tree fragment object, and is capable of
converting the RTF to other types, such as a string.
This class makes an select statement act like an result tree fragment.
Sets things up for issuing error messages.
Provides transformer context to be passed to an extension element.
Deprecated.
To be replaced by org.apache.xalan.Version.getVersion()
This class defines an attribute for an element in a XSLT stylesheet,
is meant to reflect the structure defined in http://www.w3.org/TR/xslt#dtd, and the
mapping between Xalan classes and the markup attributes in the element.
The default implementation for the DTMManager.
This class defines the allowed structure for an element in a XSLT stylesheet,
is meant to reflect the structure defined in http://www.w3.org/TR/xslt#dtd, and the
mapping between Xalan classes and the markup elements in the XSLT instance.
This class acts as the superclass for all stylesheet element
processors, and deals with things that are common to all elements.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Default implementation of XSLTErrorResources.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Set up error messages.
Provides applet host for the XSLT processor.
This class defines the allowed structure for a stylesheet, and the
mapping between Xalan classes and the markup elements in the stylesheet.
A class that implements this interface will call a XSLTVisitor
for itself and members within it's heararchy.
A derivation from this class can be passed to a class that implements
the XSLTVisitable interface, to have the appropriate method called
for each component of an XSLT stylesheet.
This class represents an XPath string object, and is capable of
converting the string to other types, such as a number.
This class will wrap a FastStringBuffer and allow for
This class will wrap a FastStringBuffer and allow for
An instance of this class holds unto a variable until
it is executed.
This is the same as XUnresolvedVariable, but it assumes that the
context is already set up.