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.