| Home >> All >> org >> apache >> xalan >> [ xslt Javadoc ] |
• org.apache.xalan.xslt: Javadoc index of package org.apache.xalan.xslt.
Package Samples:
• org.apache.xalan.xslt.client: The main Xalan-Java package -- facilities for setting up and performing XSL transformations.
• org.apache.xalan.xslt.extensions
• org.apache.xalan.xslt.res
• org.apache.xalan.xslt.trace
• org.apache.xalan.xsltc.dom
• org.apache.xalan.xsltc.compiler.util
• org.apache.xalan.xsltc.compiler
• org.apache.xalan.xsltc.runtime.output
• org.apache.xalan.xsltc.runtime
• org.apache.xalan.xsltc.trax
• org.apache.xalan.xsltc.cmdline.getopt
• org.apache.xalan.xsltc.cmdline
• org.apache.xalan.xsltc.util
Classes:
• Redirect: Implements three extension elements to allow an XSLT transformation to redirect its output to multiple output files. You must declare the Xalan namespace (xmlns:lxslt="http://xml.apache.org/xslt"), a namespace for the extension prefix (such as xmlns:redirect="org.apache.xalan.xslt.extensions.Redirect"), and declare the extension namespace as an extension (extension-element-prefixes="redirect"). You can either just use redirect:write, in which case the file will be opened and immediately closed after the write, or you can bracket the write calls by redirect:open and redirect:close, in which case ...
• EnvironmentCheck: Utility class to report simple information about the environment. Simplistic reporting about certain classes found in your JVM may help answer some FAQs for simple problems. Usage-command line: java org.apache.xalan.xslt.EnvironmentCheck [-out outFile] Usage-from program: boolean environmentOK = (new EnvironmentCheck()).checkEnvironment(yourPrintWriter); Usage-from stylesheet: <?xml version="1.0"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:xalan="http://xml.apache.org/xalan" exclude-result-prefixes="xalan"> <xsl:output indent="yes"/> ...
• AdaptiveResultTreeImpl: AdaptiveResultTreeImpl is a adaptive DOM model for result tree fragments (RTF). It is used in the case where the RTF is likely to be pure text yet it can still be a DOM tree. It is designed for RTFs which have <xsl:call-template> or <xsl:apply-templates> in the contents. Example: <xsl:variable name = "x"> <xsl:call-template name = "test"> <xsl:with-param name="a" select="."/> </xsl:call-template> </xsl:variable> In this example the result produced by is likely to be a single Text node. But it can also be a DOM tree. This kind of RTF cannot be modelled by SimpleResultTreeImpl. ...
• XSLTEngineImpl: The Xalan workhorse -- Collaborates with the XML parser liaison, the DOM, and the XPath engine, to transform a source tree of nodes into a result tree according to instructions and templates specified by a stylesheet tree. We suggest you use one of the static XSLTProcessorFactory getProcessor() methods to instantiate the processor and return an interface that greatly simplifies the process of manipulating XSLTEngineImpl. The methods process(...) are the primary public entry points. The best way to perform transformations is to use the XSLTProcessor.process(XSLTInputSource, XSLTInputSource, XSLTResultTarget) ...
• ForwardPositionIterator: This iterator is a wrapper that always returns the position of a node in document order. It is needed for the case where a call to position() occurs in the context of an XSLT element such as xsl:for-each, xsl:apply-templates, etc. The getPosition() methods in DTMAxisIterators defined in DTMDefaultBaseIterators always return the position in document order, which is backwards for XPath in the case of the ancestor, ancestor-or-self, previous and previous-sibling. XSLTC implements position() with the BasisLibrary.positionF() method, and uses the DTMAxisIterator.isReverse() method to determine whether ...
• MatchingIterator: This is a special kind of iterator that takes a source iterator and a node N. If initialized with a node M (the parent of N) it computes the position of N amongst the children of M. This position can be obtained by calling getPosition(). It is an iterator even though next() will never be called. It is used to match patterns with a single predicate like: BOOK[position() = last()] In this example, the source iterator will return elements of type BOOK, a call to position() will return the position of N. Notice that because of the way the pattern matching is implemented, N will always be a node in ...
• SimpleResultTreeImpl: This class represents a light-weight DOM model for simple result tree fragment(RTF). A simple RTF is an RTF that has only one Text node. The Text node can be produced by a combination of Text, xsl:value-of and xsl:number instructions. It can also be produced by a control structure (xsl:if or xsl:choose) whose body is pure Text. A SimpleResultTreeImpl has only two nodes, i.e. the ROOT node and its Text child. All DOM interfaces are overridden with this in mind. For example, the getStringValue() interface returns the value of the Text node. This class receives the character data from the characters() ...
• XSLTProcessorApplet: Provides applet host for the XSLT processor. To perform transformations on an HTML client: Use an <applet> tag to embed this applet in the HTML client. Use the DocumentURL and StyleURL PARAM tags or the setDocumentURL(java.lang.String) 55 and setStyleURL(java.lang.String) 55 methods to specify the XML source document and XSL stylesheet. Call the #transformToHTML method to perform the transformation and return the result as a String.
• FuncDocument: Execute the Doc() function. When the document function has exactly one argument and the argument is a node-set, then the result is the union, for each node in the argument node-set, of the result of calling the document function with the first argument being the string-value of the node, and the second argument being a node-set with the node as its only member. When the document function has two arguments and the first argument is a node-set, then the result is the union, for each node in the argument node-set, of the result of calling the document function with the first argument being the string-value ...
• XSLTProcessor: The transformation processor -- use XSLTProcessorFactory to instantiate an implementation of this interface. It's the responsibility of the implementation (XSLTEngineImpl), collaborating with a XMLParserLiaison, the DOM, and the XPath engine, to transform a source tree of nodes into a result tree according to instructions and templates specified by a stylesheet tree. Use the process(...) are the primary public entry points. Look at the Process class main() method for for an advanced usage example. If you reuse the processor instance, you should call reset() between transformations.
• ProcessorVersion: Admin class that assigns a version number to the XSLTC software. The version number is made up from three fields as in: MAJOR.MINOR[.DELTA]. Fields are incremented based on the following: DELTA field: changes for each bug fix, developer fixing the bug should increment this field. MINOR field: API changes or a milestone culminating from several bug fixes. DELTA field goes to zero and MINOR is incremented such as: {1.0,1.0.1,1.0.2,1.0.3,...1.0.18,1.1} MAJOR field: milestone culminating in fundamental API changes or architectural changes. MINOR field goes to zero and MAJOR is incremented such as: ...
• VariableStack: Defines a class to keep track of a stack for template arguments and variables, since we can't simply bind the variables to templates and walk the preceding children and ancestors. The stack is delimited by context markers which bound call frames, and which you can't search past for a variable, and by element frames, which are Arg objects with the given ElemTemplateElement instead of a qname. You can search past element frames, and they accumulate until they are popped. Note: Someone recently made the suggestion that the globals should not be kept at the bottom of the stack, but should be implemented ...
• GetOpt: GetOpt is a Java equivalent to the C getopt() library function discussed in man page getopt(3C). It provides command line parsing for Java applications. It supports the most rules of the command line standard (see man page intro(1)) including stacked options such as '-sxm' (which is equivalent to -s -x -m); it handles special '--' option that signifies the end of options. Additionally this implementation of getopt will check for mandatory arguments to options such as in the case of '-d ' it will throw a MissingOptArgException if the option argument ' ' is not included on the commandline. getopt(3C) ...
• ObjectFactory: This class is duplicated for each JAXP subpackage so keep it in sync. It is package private and therefore is not exposed as part of the JAXP API. This code is designed to implement the JAXP 1.1 spec pluggability feature and is designed to run on JDK version 1.1 and later, and to compile on JDK 1.2 and onward. The code also runs both as part of an unbundled jar file and when bundled as part of the JDK. This class was moved from the javax.xml.parsers.ObjectFactory class and modified to be used as a general utility for creating objects dynamically.
• ObjectFactory: This class is duplicated for each JAXP subpackage so keep it in sync. It is package private and therefore is not exposed as part of the JAXP API. This code is designed to implement the JAXP 1.1 spec pluggability feature and is designed to run on JDK version 1.1 and later, and to compile on JDK 1.2 and onward. The code also runs both as part of an unbundled jar file and when bundled as part of the JDK. This class was moved from the javax.xml.parsers.ObjectFactory class and modified to be used as a general utility for creating objects dynamically.
• ObjectFactory: This class is duplicated for each JAXP subpackage so keep it in sync. It is package private and therefore is not exposed as part of the JAXP API. This code is designed to implement the JAXP 1.1 spec pluggability feature and is designed to run on JDK version 1.1 and later, and to compile on JDK 1.2 and onward. The code also runs both as part of an unbundled jar file and when bundled as part of the JDK. This class was moved from the javax.xml.parsers.ObjectFactory class and modified to be used as a general utility for creating objects dynamically.
• ObjectFactory: This class is duplicated for each JAXP subpackage so keep it in sync. It is package private and therefore is not exposed as part of the JAXP API. This code is designed to implement the JAXP 1.1 spec pluggability feature and is designed to run on JDK version 1.1 and later, and to compile on JDK 1.2 and onward. The code also runs both as part of an unbundled jar file and when bundled as part of the JDK. This class was moved from the javax.xml.parsers.ObjectFactory class and modified to be used as a general utility for creating objects dynamically.
• ObjectFactory: This class is duplicated for each JAXP subpackage so keep it in sync. It is package private and therefore is not exposed as part of the JAXP API. This code is designed to implement the JAXP 1.1 spec pluggability feature and is designed to run on JDK version 1.1 and later, and to compile on JDK 1.2 and onward. The code also runs both as part of an unbundled jar file and when bundled as part of the JDK. This class was moved from the javax.xml.parsers.ObjectFactory class and modified to be used as a general utility for creating objects dynamically.
• ObjectFactory: This class is duplicated for each JAXP subpackage so keep it in sync. It is package private and therefore is not exposed as part of the JAXP API. This code is designed to implement the JAXP 1.1 spec pluggability feature and is designed to run on JDK version 1.1 and later, and to compile on JDK 1.2 and onward. The code also runs both as part of an unbundled jar file and when bundled as part of the JDK. This class was moved from the javax.xml.parsers.ObjectFactory class and modified to be used as a general utility for creating objects dynamically.
• ObjectFactory: This class is duplicated for each JAXP subpackage so keep it in sync. It is package private and therefore is not exposed as part of the JAXP API. This code is designed to implement the JAXP 1.1 spec pluggability feature and is designed to run on JDK version 1.1 and later, and to compile on JDK 1.2 and onward. The code also runs both as part of an unbundled jar file and when bundled as part of the JDK. This class was moved from the javax.xml.parsers.ObjectFactory class and modified to be used as a general utility for creating objects dynamically.
• StepIterator: A step iterator is used to evaluate expressions like "BOOK/TITLE". A better name for this iterator would have been ParentIterator since both "BOOK" and "TITLE" are steps in XPath lingo. Step iterators are constructed from two other iterators which we are going to refer to as "outer" and "inner". Every node from the outer iterator (the one for BOOK in our example) is used to initialize the inner iterator. After this initialization, every node from the inner iterator is returned (in essence, implementing a "nested loop").
• SAXImpl: SAXImpl is the core model for SAX input source. SAXImpl objects are usually created from an XSLTCDTMManager. DOMSource inputs are handled using DOM2SAX + SAXImpl. SAXImpl has a few specific fields (e.g. _node2Ids, _document) to keep DOM-related information. They are used when the processing behavior between DOM and SAX has to be different. Examples of these include id function and unparsed entity. SAXImpl extends SAX2DTM2 instead of SAX2DTM for better performance.
• AbsoluteIterator: Absolute iterators ignore the node that is passed to setStartNode(). Instead, they always start from the root node. The node passed to setStartNode() is not totally useless, though. It is needed to obtain the DOM mask, i.e. the index into the MultiDOM table that corresponds to the DOM "owning" the node. The DOM mask is cached, so successive calls to setStartNode() passing nodes from other DOMs will have no effect (i.e. this iterator cannot migrate between DOMs).
• ClassGenerator: The class that implements any class that inherits from AbstractTranslet , i.e. any translet. Methods in this class may be of the following kinds: 1. Main method: applyTemplates, implemented by intances of MethodGenerator . 2. Named methods: for named templates, implemented by instances of NamedMethodGenerator . 3. Rt methods: for result tree fragments, implemented by instances of RtMethodGenerator .
• CurrentNodeListIterator: Iterators of this kind use a CurrentNodeListFilter to filter a subset of nodes from a source iterator. For each node from the source, the boolean method CurrentNodeListFilter.test() is called. All nodes from the source are read into an array upon calling setStartNode() (this is needed to determine the value of last, a parameter to CurrentNodeListFilter.test()). The method getLast() returns the last element after applying the filter.
| Home | Contact Us | Privacy Policy | Terms of Service |