All Classes

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).

Wraps a DOM attribute list in a SAX Attributes.

Class to hold an Attribute Value Template.

Simple string part of a complex AVT.

Serves as common interface for axes Walkers, and stores common state variables.

Base for iterators that handle predicates.

Simple stack for boolean values.

The methods in this class are convenience methods into the low-level XPath API.

This class implements an optimized iterator for "node()" patterns, that is, any children of the context node.

The class that implements any class that inherits from AbstractTranslet, i.e. any translet.

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.

Special context node pattern matcher.

Support the coroutine design pattern.

A class that does incremental counting for support of xsl:number.

CustomStringPool is an example of appliction provided data structure for a DTM implementation to hold symbol references, e.g. elelment names.

Structure to help in converting integers to roman numerals

Implement SAX error handler for default reporting.

The 'div' operation expression executer.

This class provides a DOM level 2 "helper", which provides services currently not provided be the DOM standard.

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 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.

Interface for a DOM serializer implementation.

DTM is an XML document model expressed as a table rather than an object tree.

This class serves as a default base for implementations of mutable DTMAxisIterators.

A class that implements traverses DTMAxisTraverser interface can traverse a set of nodes, usually as defined by an XPath axis.

Indicates a serious configuration error.

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.

This class specifies an exceptional condition that occured in the DTM module.

DTMIterators are used to step through a (possibly filtered) set of nodes.

The default implementation for the DTMManager.

Simple implementation of DOMException.

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.

DTMStringPool is an "interning" mechanism for strings.

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-templates.

Implement xsl:attribute-set.

Implement xsl:choose.

Implement xsl:copy.

This class has a series of flags (bit values) that describe an HTML element

Simple empty elem to push on the stack when nothing else got pushed, so that pop() works correctly.

Implement func:function.

Implement the declaration of an extension element

Implement xsl:fallback.

Implement xsl:if.

Implement xsl:message.

Implement xsl:otherwise.

Implement xsl:processing-instruction.

Implement xsl:template.

Implement xsl:template.

Implement an unknown element

Implement xsl:value-of.

Implement xsl:with-param.

DTM Empty Axis Iterator.

Holds information about a given encoding, which is the Java name for the encoding, the equivalent ISO name.

Event triggered by completion of a xsl:for-each selection or a xsl:apply-templates selection.

The '=' operation expression executer.

This is a default implementation of a table that manages mappings from expanded names to expandedNameIDs.

An object that implements this interface can supply information about the current XPath expression context.

Classes that implement this interface own an expression, which can be rewritten.

The base class for some EXSLT extension classes.

This class contains EXSLT dates and times extension functions.

This class contains EXSLT math extension functions.

This class contains EXSLT strings extension functions.

This interface has extensions to the standard SAX LexicalHandler interface.

The class ExtendedType represents an extended type object used by ExpandedNameTable.

Abstract base class for handling an extension namespace for XPath.

Class handling an extension namespace for XPath.

Represents an extension namespace for XPath that handles java classes.

A sample implementation of NamespaceContext, with support for EXSLT extension functions and Java extension functions.

During styleseet composition, an ExtensionNamespaceSupport object is created for each extension namespace the stylesheet uses.

Interface that XPath objects can call to obtain access to an ExtensionsTable.

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.

This class implements auxliary classes needed to compile filters (predicates).

Class to let us know when it's time to do a search from the parent because of indexing.

Execute the Ceiling() function.

Execute the Contains() function.

Execute the current() function.

Execute the Doc() function.

An object of this class represents an extension call expression.

Execute the False() function.

Execute the FormatNumber() function.

Execute the Id() function.

Execute the Lang() function.

Execute the LocalPart() function.

Execute the normalize-space() function.

Execute the Number() function.

Execute the Qname() function.

Execute the StartsWith() function.

Execute the StringLength() function.

Execute the SubstringAfter() function.

Execute the Sum() function.

This is a superclass of all XPath functions.

Base class for functions that accept three arguments.

Base class for functions that accept an undetermined number of multiple arguments.

Match pattern step that contains a function.

Execute the Translate() function.

GetOpt is a Java equivalent to the C getopt() library function discussed in man page getopt(3C).

The '>' operation expression executer.

The main hash-table implementation

IncrementalSAXSource_Filter implements IncrementalSAXSource, using a standard SAX2 event source as its input and parcelling out those events gradually in reponse to deliverMoreNodes() requests.

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.

Implement a stack of simple integers.

A very simple table that stores a list of int.

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.

A Connection Pool that wraps a JDBC datasource to provide connections.

Stores mappings of key values or IDs to DTM nodes.

This class manages the key tables.

Table of element keys, keyed by document node.

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

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 '<=' operation expression executer.

This is a special kind of iterator that takes a source iterator and a node N.

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.

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.

The '*' operation expression executer.

MultiValuedNodeHeapIterator takes a set of multi-valued heap nodes and produces a merged NodeSet in document order with duplicates removed.

This class is used for named templates.

Object to hold an xsl:namespace element.

Namespace support for XML document handlers.

The unary '-' operation expression executer.

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.

NodeLocator maintains information on an XML source node.

The NodeSet class can act as either a NodeVector, NodeList, or NodeIterator.

Base class for sort records containing application specific sort keys

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.

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.

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, that only go forward (i.e. it can not be used with ancestors, preceding, etc.)

The baseclass for a binary operation.

This class represents the data structure basics of the XPath object.

The 'or' operation expression executer.

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.

The '+' operation expression executer.

This class implements a generic PrefixResolver that can be used to perform prefix-to-namespace lookup for the XPath object.

The main() method handles the Xalan command-line interface.

This class processes parse events for an exslt func:result element.

This class processes parse events for an xsl:import element.

Processes an XSLT literal-result-element, or something that looks like one.

TransformerFactory for xsl:stylesheet or xsl:transform markup.

Process xsl:text.

Admin class that assigns a version number to the XSLTC software.

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.

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.

SAX2DTM2 is an optimized version of SAX2DTM which is used in non-incremental situation.

SAXImpl is the core model for SAX input source.

Event triggered by selection of a node in the style stree.

The standard SAX implementation of LocatorImpl is not serializable, limiting its utility as "a persistent snapshot of a locator".

This class acts as a base class for the XML "serializers" and the stream serializers.

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.

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.

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.

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 class bottlenecks all management of source trees.

The SQL Document is the main controlling class the executesa SQL Query

Class to guard against recursion getting too deep.

This class represents a single pattern match step.

The 'string()' operation expression executer.

This class pools string buffers, since they are reused so often.

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.

Represents a stylesheet element.

Represents a stylesheet that has methods that resolve includes and imports.

Search for the xml-stylesheet processing instructions in an XML document.

A very simple table that stores a list of byte.

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.

This class is used to resolve relative URIs and SystemID strings into absolute URIs.

Encapsulates a template list, and helps locate individual templates.

A utility class that wraps the ThreadController, which is used by IncrementalSAXSource for the incremental building of DTM.

This class is used to provide a base behavior to be inherited by other To...SAXHandler serializers.

This class wraps another SerializationHandler.

This class converts SAX or SAX-like calls to a serialized xml document.

Extends TraceListener but adds a SelectEnd event.

Extends TraceListenerEx2 but adds extensions trace events.

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.

Implementation of a JAXP1.1 TransformerFactory for Translets.

Implementation of a JAXP1.1 TransformerHandler

This class implements the Transformer interface, and is the core representation of the transformation execution.

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.

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.

To be subclassed by classes that wish to fake being nodes.

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 represents a union pattern, which can have multiple individual StepPattern patterns.

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.

The variable reference expression executer.

Defines a class to keep track of a stack for template arguments and variables.

Administrative class to keep track of the version number of the Xalan release.

Location path iterator that uses Walkers.

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.

Certain functions may throw this error if they are paired with the incorrect parser.

Before the serializer merge, the TransformState interface was implemented by ResultTreeHandler.

This class doesn't have any XPathContext, so override whatever to ensure it works OK.

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.

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.

Set up error messages.

Set up error messages.

Set up error messages.

Set up error messages.

Set up error messages.

Set up error messages.

Represents an xmlns declaration

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.

A concrete class that implements this interface creates XMLString objects.

Class XMLStringFactoryImpl creates XString versions of XMLStrings.

This class overrides the XNodeSet#object() method to provide the original Node object, NodeList object, or NodeIterator.

This class represents an XPath number, and is capable of converting the number to other types, such as a string.

The methods in this class are convenience methods into the low-level XPath API.

Class for XPath diagnostic functions.

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.

The XPathExpression interface encapsulates a (compiled) XPath expression.

The XPathFactory builds XPaths.

A sample implementation of XPathFunctionResolver, with support for EXSLT extension functions and Java extension functions.

A utility class for issuing XPath error messages.

Tokenizes and parses XPath expressions.

A new exception to add support for DOM Level 3 XPath API.

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.

This is an interface for error messages.

The German resource bundle.

The English resource bundle.

The French resource bundle.

The Armenian resource bundle.

The Japanese (Katakana) resource bundle.

The Japanese (Hiragana) resource bundle.

The Georgian resource bundle.

The Swedish resource bundle.

The Chinese(Taiwan) resource bundle.

This class makes an select statement act like an result tree fragment.

Provides transformer context to be passed to an extension element.

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.

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.

This class defines the allowed structure for a stylesheet, and the mapping between Xalan classes and the markup elements in the stylesheet.

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 will wrap a FastStringBuffer and allow for

An instance of this class holds unto a variable until it is executed.