| Class Summary | |
|---|---|
| Action | the parsed representation of a stylesheet component. |
| ActionDebugTarget | |
| ActionResultFragmentVariant | a result tree fragment to be stored in a variable? |
| AddExpr | a compiled XPath expression (component) that represents the addition of two sub-expressions |
| AddVariableSet | |
| AlphabetFormatTokenHandler | |
| AlphabetNumberFormat | |
| AlternativesPattern | represents an "OR" (union) of match patterns |
| AncestorAxisExpr | an XPath expression component representing an ancestor axis |
| AncestorOrSelfAxisExpr | An XPath expression component representing the ancestor-or-self axis |
| AncestorsOrSelfNodeIterator | an Iterator that walks toward thwe document root |
| AndExpr | |
| AnyElementOrAttributeTest | |
| AnyLevelNumberAction | |
| AnyLevelNumberActionDebug | |
| AnyLevelNumberAction.Cache | |
| AppendAction | |
| AppendActionDebug | |
| AppendExpr | Represents the concatenation of two String Expressions |
| ApplyImportsAction | |
| ApplyImportsActionDebug | |
| ArrayNodeIterator | |
| AttributeAction | |
| AttributeActionDebug | |
| AttributeAxisExpr | |
| AttributeNode | represents an XML Element's Attribute constructed around a W3C level 1 DOM Attribute |
| AttributeTest | A compiled XPath component that tests a node to see if it is an attribute with a (possibly?) |
| AxisExpr | |
| BilevelComparator | |
| BilevelComparatorTemplate | |
| BindLocalParamAction |
binds a local parameter to a name
|
| BindLocalParamActionDebug |
binds a local parameter to a name
|
| BindLocalVariableAction | binds a variable to a name |
| BindLocalVariableActionDebug | binds a variable to a name |
| BooleanExpr | |
| BooleanFunction |
a single argument XPath function which casts its
argument to a boolean
Function: boolean boolean(object)
The boolean function converts its argument to a boolean as follows:
|
| BooleanRelationalExpr | |
| BooleanVariant | a boolean which can provide its value as a String, Number or Object |
| BuiltinAction | |
| BuiltinActionDebug | |
| CeilingFunction | the XPath Function: number ceiling(number) The ceiling function returns the smallest (closest to negative infinity) number that is not less than the argument and that is an integer. |
| CharsAction | character data |
| CharsActionDebug | character data |
| ChildAxisExpr | |
| CloneableNodeIterator | |
| CloneableNodeIteratorImpl | |
| CloneableNodeIteratorImpl.NodeList | |
| CommentAction |
|
| CommentActionDebug |
|
| CommentHandler | receives comment events from a parse |
| CommentNode | Wraps a W3C DOM XML Comment Node as an om.Node |
| Comparator | |
| ComparatorTemplate | |
| ComposeEnumeration | |
| ComposeExpr | an expression which composes two sub-expressions (for each node in expr1, evaluate expr2) |
| ConcatFunction | represents the XPath Function: string concat(string, string, string*) has the method makeCallExpr which will construct a String expression representing the concat function |
| ContainerNode | presents a om.Node interface for a W3C DOM Node |
| ContainsFunction | Represents the XPath Function: boolean contains(string, string) The contains function returns true if the first argument string contains the second argument string, and otherwise returns false. |
| ContentHandlingResultWriter | Converts a SAX 2 event stream to calls on a Result -- which is useful for connecting to extension elements which generate SAX events |
| Converter | |
| ConvertibleBooleanExpr | An expression which is a boolean, but depending on its use, may be converted to a Number, String or Object |
| ConvertibleExpr | An XPath expression (component) which can be cast to any of several types as needed |
| ConvertibleNodeSetExpr | A compiled XPath pattern component which returns a Node set, but is convertible (castable) to a String expression, boolean expression or VariantExpression |
| ConvertibleNumberExpr | |
| ConvertibleStringExpr | |
| ConvertibleVariantExpr | |
| CopyAction |
|
| CopyActionDebug |
|
| CopyOfAction |
|
| CopyOfActionDebug |
|
| CountFunction | Represents the XPath Function: number count(node-set) The count function returns the number of nodes in the argument node-set. |
| CurrentFunction | Represents the XSLT Function: node-set current() The current function returns a node-set that has the current node as its only member. |
| DecimalNumberFormat | |
| DecodeURIFunction | Represents the EXSL str:encode-uri function For more information consult exsl specification at: Specification. |
| DefaultErrorListener | A default implementation of the ErrorListener interface. |
| DelegateExprContext | a base class for ExprContext classes that override some methods of an existing ExprContext, and delegate the rest of 'em to that existing ExprContest |
| DescendantAxisExpr | XPath expression (component) representing descendant axis |
| DescendantOrSelfAxisExpr | an XPath expression "//" |
| DescendantsOrSelfNodeIterator | walks an entire (sub)-tree, excluding attributes |
| Destination | represents the output destination for an XML document |
| DifferenceFunction | James Clark's extension function: node-set xt:difference(node-set, node-set) |
| DifferenceNodeIterator | |
| DivideExpr | |
| DocumentAction |
|
| DocumentActionDebug |
|
| DocumentFunction | represents the XSLT Function: node-set document(object, node-set?) |
| DocumentOrderComparator | |
| DOMBuilder | provides callback methods for xslt engine and constructs W3C DOM Nodes therefrom |
| DOMExtensions | |
| Driver | A Command line driver program for XSLProcessor |
| Driver.ErrorHandlerImpl | |
| ElementAction | |
| ElementActionDebug | |
| ElementAvailableFunction | the XSLT function 'element-available("qname")' |
| ElementNode | |
| ElementNode.AttributesIterator | |
| ElementOrAttributeTest | |
| ElementTest | A compiled XPath expression (component) tests a node for being an ELEMENT with a given Name |
| EmptyAction | a no-op |
| EmptyActionDebug | a no-op |
| EmptyVariableSet | |
| EncodeURIFunction | Represents the EXSL str:encode-uri function For more information consult exsl specification at: Specification. |
| EncodingName | maps between Java and IANA character encoding names |
| Engine | An engine, compiles a stylesheet |
| EngineImpl | compiles a stylesheet from a (XSLT D)OM |
| EqualsRelation | |
| ExprContext | packages up the context available to the XSLT engine when evaluating XPath expressions |
| ExprNumberAction | |
| ExprNumberActionDebug | |
| ExprParser | XPAth expression parser / compiler extends the lexer ExprTokenizer |
| ExprTokenizer | lexical analyser for XPath 1.0 |
| ExtensionContext | |
| ExtensionFunctionCallExpr | |
| ExtensionHandler | for extension functions -- i think |
| ExtensionHandlerImpl | for invoking XSLT extension functions (? |
| FalseExpr | |
| FalseFunction | a function of 0 arguments that returns false |
| FileDescriptorDestination | e.g stdout |
| FileDestination | Represents a file to which we can write the results of a transformation |
| FilterExpr | |
| FilterNodeIterator | |
| FilterPattern | a pattern that has a predicate to eliminate some nodes |
| FilterPattern.Context | |
| FloorFunction | |
| FollowingAxisExpr | |
| FollowingNodeIterator | |
| FollowingSiblingAxisExpr | |
| ForEachAction |
|
| ForEachActionDebug |
|
| FormatNumberFunction | |
| FormatTokenHandler | |
| Function | all functions have the method: "makeCallExpr( ... |
| Function0 | base class for all functions taking no arguments |
| Function1 | base class for all functions taking one arguments |
| Function2 | |
| Function3 | abstract base class for XPath functions which take 3 arguments |
| FunctionAvailableFunction | implements XSLT function-available("qname") function XSLT sections 14.2 and 15 |
| FunctionOpt1 | |
| GenerateIdFunction | |
| GenericDestination | A base class for output Destinations, providing some common default behaviors |
| GlobalVariableRefExpr | |
| GreaterThanEqualsRelation | |
| GreaterThanRelation | |
| HTMLOutputHandler | A OutputDocumentHandler that writes an HTML representation. |
| HTMLOutputHandler | A OutputContentHandler that writes an HTML representation to a Destination |
| IdFunction | the XPath function id(x) |
| IdPattern | represents an XSLT/XPath pattern of the form id('foo') |
| IfAction |
|
| IfActionDebug |
|
| Importance | |
| ImportantBoolean | |
| Indenter | performs "pretty-printing" by wrapping another OutputDocumentHandler, intercepting SAX events, and inserting whitespace events as appropriate. |
| Indenter | performs "pretty-printing" by wrapping another ContentHandler, intercepting SAX events, and inserting whitespace events as appropriate. |
| InheritPattern | |
| IntersectionFunction | |
| IntersectionNodeIterator | |
| InvokeAction | call template |
| InvokeActionDebug | call template |
| KeyDefinition | represents the top-level element xsl:key which defines a named lookup table for nodes XSLT 1.0 section 12.2 |
| KeyFunction | the XPath function key("name", "value") |
| KeyPattern | represents an XSLT/XPath pattern of the form key('foo', 'bar') |
| KeyValuesTable | all the nodes which have been indexed for a given document in a given named key ... part of the implementation of xsl:key |
| Lang | Convert the value of an xml:lang attribute to a Locale. |
| LangFunction | |
| LastFunction | |
| LiteralAttributeAction | |
| LiteralAttributeActionDebug | |
| LiteralElementAction | |
| LiteralElementActionDebug | |
| LiteralExpr | |
| LoadContext | maintains a list of a few options for how a XMLProcessor constructs an object model |
| LocalNameFunction | |
| LocalPartFunction | |
| LocalVariableRefExpr | |
| MergeNodeIterator | does some sort of sort/merge on NodeIterators, I think |
| MergeSort | |
| MessageAction |
|
| MessageActionDebug |
|
| ModuloExpr | |
| MultiLevelNumberAction | |
| MultiLevelNumberActionDebug | |
| MultiLevelNumberAction.Cache | |
| MultiLevelNumberAction.CacheEntry | |
| MultiNamespaceResult | |
| MultiNamespaceResult | |
| MultiplyExpr | |
| Name |
A Name is a two part object, consisting of a namespace (String)
and a local part (String with no colon)
Names are the same if they have the same namespace, local part and
creator.
|
| NameExpr | |
| NameFunction | |
| NamespaceAttributeTest | |
| NamespaceAxisExpr | |
| NamespaceConstants | |
| NamespaceElementTest | |
| NamespaceFunction | |
| NamespacePrefixMap | Associates namespaces with prefixes. |
| NamespaceTest | |
| NamespaceUriFunction | |
| NameTable | constructs (or obtains) Names for qName/namespace pairs |
| NameTableImpl | manages collections of Names and NamespacePrefixMaps |
| NegateExpr | |
| Node | represents a Node in an XML document |
| NodeBase | Base class wrapper which presents our xt om Node interface around a W3C Level 1 DOM node |
| NodeComparatorTemplate | |
| NodeConstantExpr | |
| NodeIterator | represents a list of Nodes |
| NodeListSorter |
Like the name suggests, provides a mechanism to sort
the nodes in a NodeIterator based upon the test of
Comparator |
| NodeSetExpr | A NodeSetExpr (compiled XPath), when evaluated with a contextNode and an ExpressionContext, yields a NodeIterator |
| NodeSetFunction | |
| NodeSetVariant | |
| NodeTestExpr | |
| NodeTypeTest | Simply tests if a node is of a given type e.g. |
| NormalizeFunction | |
| NormalizeSpaceFunction | |
| NotEqualsRelation | |
| NotFunction | |
| NullNodeIterator | provides a singleton Node iterator representing 0 Nodes |
| NullNodeIterator | |
| NumberComparator | |
| NumberConstantExpr | |
| NumberExpr | |
| NumberFormat | formats an integer into a String |
| NumberFunction | |
| NumberListFormat | |
| NumberListFormatTemplate | |
| NumberRelationalExpr | |
| NumberVariant | |
| NumericRelation | |
| NXMLOutputHandler | an output handler that handles our special technique for non XML characters |
| NXMLOutputHandler | an output handler that recognizes our special technique for signalling non XML characters |
| NXMLOutputHandler.CharacterHandler | |
| NXMLOutputHandler.CharacterHandler | |
| NXMLOutputHandler.ControlCharacterHandler | |
| NXMLOutputHandler.ControlCharacterHandler | |
| NXMLOutputHandler.DataCharacterHandler | |
| NXMLOutputHandler.DataCharacterHandler | |
| NXMLOutputHandler.EscapeCharacterHandler | |
| NXMLOutputHandler.EscapeCharacterHandler | |
| NXMLOutputHandler.LineControlCharacterHandler | |
| NXMLOutputHandler.LineControlCharacterHandler | |
| ObjectTypeFunction | Represents the EXSL exsl:object-type function For more information consult exsl specification at: Specification. |
| ObjectVariant | |
| OrExpr | |
| OutputContentHandler | a SAX2 ContentHandler that serializes to a Destination and requires some initialization |
| OutputDocumentHandler | A SAX 1 DocumentHandler that serializes the results of a transform to a Destination, in a manner influenced by the "xsl:output" element |
| OutputMethod | collects the attributes from the xsl:output element which determine the type of output we are to produce |
| OutputMethodAttributeList | represents the set of attributes that modify how output is serialized |
| OutputMethodDefaulter | able to automagically decide to use the html output method if the first start element name is "html" in no namespace |
| OutputMethodDefaulter |
automagically decides to use the html output method
if the first start element name is "html" in no namespace
Recieves SAX parse events from a ResultBase, till it gets a look at the root element's name. Tells the ResultBase that had been sending it SAX parse events what this has learned. |
| OutputMethodDefaulter.CharactersEvent | |
| OutputMethodDefaulter.CharactersEvent | |
| OutputMethodDefaulter.CommentEvent | |
| OutputMethodDefaulter.CommentEvent | |
| OutputMethodDefaulter.Event | |
| OutputMethodDefaulter.Event | |
| OutputMethodDefaulter.IgnorableWhitespaceEvent | |
| OutputMethodDefaulter.IgnorableWhitespaceEvent | |
| OutputMethodDefaulter.ProcessingInstructionEvent | |
| OutputMethodDefaulter.ProcessingInstructionEvent | |
| OutputMethodDefaulter.RawCharactersEvent | |
| OutputMethodDefaulter.RawCharactersEvent | |
| OutputMethodHandler | constructs a DocumentHandler appropriate for a given output method (which typically is determined by the stylesheet) and destination (which is determined externally) |
| OutputMethodHandler | constructs a ContentHandler appropriate for a given output method (which typically is determined by the stylesheet) and destination (which is determined externally) |
| OutputMethodHandlerImpl | produces a DocumentHandler suitable for a given output method i.e text, XML, etc and destination |
| OutputMethodHandlerImpl | produces a ContentHandler suitable for a given output method i.e text, XML, etc and destination |
| OutputMethodProperties |
Presents a java.util.Properties representation
the information, declared in the
xsl:output element, that modify how
transformation output is serialized |
| OutputStreamDestination | A Destination on an already opened OutputStream |
| ParamAction | binds a parameter to it's value |
| ParameterSet | a place to obtain run-time parameters from the execution environment |
| ParentAxisExpr | |
| ParentPattern | represents the concatenation of step patterns, right to left in a LocationPathPattern |
| ParseException | |
| ParserTest | |
| PathPattern | a compiled XPath expression which has an XSLT match priority |
| PathPatternBase | a (component of) a compiled XPath pattern expression |
| Pattern | an XPATH (XSLT) match pattern |
| PatternList | This is where we come to find which template match pattern applies to any given node when we do an apply-templates. maintains lists of match patterns (PathPatterns?) |
| PermanentNodeSetVariant | |
| PositionFunction | implements the XPath position() function, which evaluates to the current node's position in the current node set |
| PrecedingAxisExpr | The algorithm is:
(define (preceding x)
(define (reverse-subtree x)
(append (map reverse-subtree (reverse (children x)))
(list x)))
(map (lambda (y)
(map reverse-subtree (preceding-sibling y)))
(ancestor-or-self x)))
|
| PrecedingAxisExpr.AppendNodeIterator | |
| PrecedingAxisExpr.LeftExpr | |
| PrecedingAxisExpr.ReverseSubtreeExpr | |
| PrecedingSiblingAxisExpr | |
| Priority | |
| ProcessAction | apply-templates! |
| ProcessActionDebug | apply-templates! |
| ProcessContext | Processing context for a Stylesheet (Sheet) maintains state for a transformation, and actually does the dispatching of the transformation work by calling invoke() on Actions |
| ProcessContextImpl | manages the state of a transformation (and performs the transformation of a source document against an XSLT stylesheet) |
| ProcessContextImpl.VariableBindings | variable name/value bindings are maintained internally as a linked list |
| ProcessContext.Memento | |
| ProcessingInstructionAction |
|
| ProcessingInstructionActionDebug |
|
| ProcessingInstructionNode | |
| ProcessingInstructionTest | |
| RawCharactersHandler | |
| RawCharactersHandler | a SAX style event handler that receives raw characters events for writing e.g. non XML output |
| RawCharsAction | |
| RawCharsActionDebug | |
| RawValueOfAction | represents an "xsl:value-of" with disable-output-escaping='yes' |
| RawValueOfActionDebug | represents an "xsl:value-of" with disable-output-escaping='yes' |
| RegexpMatchFunction | Represents the EXSL regexp:match function For more information consult exsl specification at: Specification. |
| RegexpReplaceFunction | Represents the EXSL regexp:replace function For more information consult exsl specification at: Specification. |
| RegexpTestFunction | Represents the EXSL regesp:test function For more information consult exsl specification at: Specification. |
| Relation | |
| Result |
As transformation proceeds, "Actions" are performed, and an output tree is constructed. |
| ResultBase | abstract base class represents the results of executing a stylesheet Action -- constructs result components. events are fired to the Result, which in turn fires events to a SAX (1) DocumentHandler |
| ResultBase | abstract base class represents the results of executing a stylesheet Action -- constructs result components. events are fired to the Result, which may, in turn, fire events to a SAX ContHandler |
| ResultFragmentExpr | |
| ResultFragmentVariant | |
| ResultFragmentVariantBase | a result tree fragment, I guess used as a variable or param? |
| ResultTreeFragment | |
| ResultTreeFragment | A Result Tree Fragment can write out a representation of itself as a sequence of SAX events |
| ReverseAxisExpr | A reverse axis (XPath) expression represents a Node set which may need to be seen in document order (thus reversed) |
| ReverseComparator | |
| RomanNumberFormat | |
| RootExpr | an XPath expression (component) that evaluates a sub-expression with a document root Node as the contextNode |
| RootNode | |
| RoundFunction | |
| SAXTwoOMBuilder | constructs an (XT) object model from SAX2 events |
| SAXTwoOMBuilderImpl | constructs an (xslt) XML object model from SAX2 events N.B. |
| SafeNodeIterator | represents a list of Nodes -- the next() function promises to not throw an exception |
| SaxFilterMaker | an object which is able to provide a SAX2 XMLFilter We use these for some experimental XSLT extension elements |
| SelfAxisExpr | |
| SequenceComposeExpr | Composition when expr1 is SINGLE_LEVEL and expr2 is STAYS_IN_SUBTREE. |
| SequenceComposeNodeIterator | |
| ServletDestination | provides and initializes an output stream to (through) a ServletResponse |
| Sheet | Represents a (compiled) XSLT stylesheet. |
| SheetDetails | provides access to the additional information in the compiled stylesheet that the implementation of the ProcessContext needs to get at, but we don't need to share with other packages |
| SheetImpl | Actually does the work of compiling the stylesheet's object model into the template rules, actions, variable definitions, etc. |
| SiblingNodeIterator | |
| SingleLevelNumberAction | |
| SingleLevelNumberActionDebug | |
| SingleNodeIterator | |
| SortNodeSetExpr | sorts a node list before returning them from a nested expression |
| SplitFunction | Represents the EXSL str:split function For more information consult exsl specification at: Specification. |
| StartsWithFunction | |
| StringExpr | an XPath expression which evaluates to a String |
| StringFunction | |
| StringLengthFunction | |
| StringRelationalExpr | |
| StringResult | |
| StringVariant | |
| SubstringAfterFunction | |
| SubstringBeforeFunction | |
| SubstringFunction | |
| SubtractExpr | |
| SubtreeExpr | descendants-or-self(node())/E when E has STAYS_IN_SUBTREE |
| SumFunction | |
| SwapCaseComparator | |
| SystemPropertyFunction | implements the system-property() function, XSLT 1.0, section 12.4 |
| TemplateAttributeAction | |
| TemplateAttributeActionDebug | |
| TemplateRuleSet | holds a collection of Templates (Actions) for a mode .. their match patterns ranked by priority and importance |
| TemplatesHandlerImpl |
An implementation of javax.xml.transform.sax.TemplatesHandler.
|
| TemplatesImpl | An implementation of the TrAX Templates interface. |
| TerminateMessageAction | |
| TerminateMessageActionDebug | |
| TerminateXSLException | |
| TextComparator | |
| TextNode | |
| TextOutputHandler | An object which serailizes SAX 1 events to raw text |
| TextOutputHandler | An object which serailizes SAX 2 events to raw text |
| TokenizerTest | |
| TopLevelPattern | an XPath top level match pattern? |
| Transform | An object which transforms a source DOM into a result DOM |
| TransformerFactoryImpl | An implementation of the TrAX TransformerFactory class and SAXTransformerFactory classes. |
| TransformerFilterImpl | |
| TransformerHandlerImpl | An implementation of javax.xml.transform.sax.TransformerHandler A TransformerHandler listens for SAX ContentHandler parse events and transforms them to a Result. |
| TransformerImpl | An implementation of the TrAX Transformer class. |
| TransformEngine | |
| TransformException | |
| TranslateFunction | |
| TrueExpr | |
| TrueFunction | |
| TurkishSwapCaseComparator | |
| UnambiguousFormatTokenHandler | |
| UnbindLocalVariablesAction | |
| UnbindLocalVariablesActionDebug | |
| UncheckedXSLException | |
| UnionExpr | |
| UnionNodeIterator | |
| UniqueNodeIterator | |
| UnparsedEntityURIFunction | |
| UseAttributeSetAction | |
| UseAttributeSetActionDebug | |
| ValueIdIterator | |
| ValueIdIterator.Iterator | |
| ValueOfAction | xsl:value-of |
| ValueOfActionDebug | xsl:value-of |
| VariableInfo | the expression to evaluate for obraining a Variable's result, and the fact of whether it is a parameter |
| VariableSet | |
| Variant | |
| VariantBase | |
| VariantExpr | |
| VariantRelationalExpr | |
| WithCurrentExpr | |
| WithCurrentExpr.Context | |
| XMLOutputHandler | A DocumentHandler that writes an XML representation to an OutputStream. |
| XMLOutputHandler | A ContentHandler that writes an XML representation to an OutputStream. |
| XMLProcessor | Constructs an object model from an XML document |
| XMLProcessorEx | extended public interface for an XMLProcessor, which loads an XML source into our own DOM-like structure |
| XMLProcessorEx | extended public interface for an XMLProcessor, which loads an XML source into our own DOM-like structure |
| XMLProcessorImpl | builds a om.Node from a DOM implementation |
| XMLProcessorImpl | parses a source doc or stylesheet into our own DOM like structure |
| XMLProcessorImpl | Builds an object model from a SAX event stream |
| XMLProcessorImpl.Builder | |
| XRAPAction | Invokes an XRAP processor |
| XRAPActionDebug | Invokes an XRAP processor |
| XSLException | |
| XSLProcessor |
typical usage:
// find an implementation, and construct it
XSLProcessor xsl = new XSLProcessorImpl();
xsl.setParser(sourceParser, styleParser);
xsl.loadStylesheet(someInputSource);
// maybe clone for re-use ...
|
| XSLProcessor |
typical usage:
// find an implementation, and construct it
XSLProcessor xsl = new XSLProcessorImpl();
xsl.setReaders(sourceXMLReader, styleXMLReader);
xsl.loadStylesheet(someInputSource);
// maybe clone for re-use ...
|
| XSLProcessorImpl | An XSLT Processor |
| XSLProcessorImpl | An XSLT Processor |
| XSLServlet | an example servlet which compiles and caches a stylesheet, then with each "GET" transforms the requested file |
| XSLTransformEngine | |
| XTwice | A Command line driver program for XT's TrAX API |
| XTwice.ErrorHandlerImpl | |