Xalan-Java 2.6.0 API Reference: Uses of Class javax.xml.transform.TransformerException

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Home

PREV NEXT

FRAMES NO FRAMES

Uses of Class
javax.xml.transform.TransformerException

Packages that use TransformerException
javax.xml.transform	This package defines the generic APIs for processing transformation instructions, and performing a transformation from source to result.
org.apache.xalan.extensions	Implementation of Xalan Extension Mechanism.
org.apache.xalan.lib	Extension elements and functions shipped with Xalan-Java, including EXSLT functions.
org.apache.xalan.processor	Parses an XSLT stylesheet document (which may include and import other stylesheet documents) and produces a StylesheetRoot (a TRaX Templates object).
org.apache.xalan.serialize
org.apache.xalan.templates	Implements the `Templates` interface, and defines a set of classes that represent an XSLT stylesheet.
org.apache.xalan.trace	Implementation of Xalan Trace events, for use by a debugger.
org.apache.xalan.transformer	In charge of run-time transformations and the production of result trees.
org.apache.xalan.xsltc.trax
org.apache.xml.utils	Implementation of Xalan utility classes.
org.apache.xpath	Implementation of XPath; for the most part, only classes meant for public use are found at this root level of the XPath packages.
org.apache.xpath.axes	Implementation of XPath LocationPath support -- primary classes are LocPathIterator and UnionPathIterator.
org.apache.xpath.compiler	Implements an XPath parser which produces an OpMap, and a so-called Compiler which produces an expression tree for fast evaluation.
org.apache.xpath.functions	Implements XPath functions -- each function is derived from Function, FunctionOneArg, Function2Args, etc, with number-of-arguments checking being applied mainly at compile time -- this package only implements XPath functions, XSLT functions are found in the "templates" package.
org.apache.xpath.objects	Implementation of XPath polymorphic type objects -- this package will grow as XPath objects are expanded to support XML Schema data types.
org.apache.xpath.operations	Support for XPath operations, such as +, -, string(), etc.
org.apache.xpath.patterns	Implementation of XPath nodeTest support, and XSLT pattern matching support.

Uses of TransformerException in javax.xml.transform

Subclasses of TransformerException in javax.xml.transform
`interface`	`TransformerConfigurationException` Indicates a serious configuration error.

Methods in javax.xml.transform with parameters of type TransformerException
`void`	`ErrorListener.warning(TransformerException exception)` Receive notification of a warning.
`void`	`ErrorListener.error(TransformerException exception)` Receive notification of a recoverable error.
`void`	`ErrorListener.fatalError(TransformerException exception)` Receive notification of a non-recoverable error.

Methods in javax.xml.transform that throw TransformerException
`abstract void`	`Transformer.transform(Source xmlSource, Result outputTarget)` Process the source tree to the output result.
`Source`	`URIResolver.resolve(java.lang.String href, java.lang.String base)` Called by the processor when it encounters an xsl:include, xsl:import, or document() function.
`void`	`ErrorListener.warning(TransformerException exception)` Receive notification of a warning.
`void`	`ErrorListener.error(TransformerException exception)` Receive notification of a recoverable error.
`void`	`ErrorListener.fatalError(TransformerException exception)` Receive notification of a non-recoverable error.

Uses of TransformerException in org.apache.xalan.extensions

Methods in org.apache.xalan.extensions that throw TransformerException
`abstract java.lang.Object`	`ExtensionHandler.callFunction(java.lang.String funcName, java.util.Vector args, java.lang.Object methodKey, ExpressionContext exprContext)` Process a call to a function.
`abstract java.lang.Object`	`ExtensionHandler.callFunction(FuncExtFunction extFunction, java.util.Vector args, ExpressionContext exprContext)` Process a call to a function.
`abstract void`	`ExtensionHandler.processElement(java.lang.String localPart, ElemTemplateElement element, TransformerImpl transformer, Stylesheet stylesheetTree, java.lang.Object methodKey)` Process a call to this extension namespace via an element.
`java.lang.Object`	`ExtensionHandlerJavaPackage.callFunction(java.lang.String funcName, java.util.Vector args, java.lang.Object methodKey, ExpressionContext exprContext)` Process a call to a function in the package java namespace.
`java.lang.Object`	`ExtensionHandlerJavaPackage.callFunction(FuncExtFunction extFunction, java.util.Vector args, ExpressionContext exprContext)` Process a call to an XPath extension function
`void`	`ExtensionHandlerJavaPackage.processElement(java.lang.String localPart, ElemTemplateElement element, TransformerImpl transformer, Stylesheet stylesheetTree, java.lang.Object methodKey)` Process a call to this extension namespace via an element.
`XObject`	`ExpressionContext.getVariableOrParam(QName qname)` Get a variable based on it's qualified name.
`XPathContext`	`ExpressionContext.getXPathContext()` Get the XPathContext that owns this ExpressionContext.
`void`	`XSLProcessorContext.outputToResultTree(Stylesheet stylesheetTree, java.lang.Object obj)` Output an object to the result tree by doing the right conversions.
`boolean`	`ExtensionsTable.functionAvailable(java.lang.String ns, java.lang.String funcName)` Execute the function-available() function.
`boolean`	`ExtensionsTable.elementAvailable(java.lang.String ns, java.lang.String elemName)` Execute the element-available() function.
`java.lang.Object`	`ExtensionsTable.extFunction(java.lang.String ns, java.lang.String funcName, java.util.Vector argVec, java.lang.Object methodKey, ExpressionContext exprContext)` Handle an extension function.
`java.lang.Object`	`ExtensionsTable.extFunction(FuncExtFunction extFunction, java.util.Vector argVec, ExpressionContext exprContext)` Handle an extension function.
`void`	`ExtensionHandlerExsltFunction.processElement(java.lang.String localPart, ElemTemplateElement element, TransformerImpl transformer, Stylesheet stylesheetTree, java.lang.Object methodKey)` Required by ExtensionHandler (an abstract method).
`java.lang.Object`	`ExtensionHandlerExsltFunction.callFunction(java.lang.String funcName, java.util.Vector args, java.lang.Object methodKey, ExpressionContext exprContext)` Execute the EXSLT function and return the result value.
`java.lang.Object`	`ExtensionHandlerExsltFunction.callFunction(FuncExtFunction extFunction, java.util.Vector args, ExpressionContext exprContext)` Execute the EXSLT function and return the result value.
`ExtensionHandler`	`ExtensionNamespaceSupport.launch()` Launch the ExtensionHandler that this ExtensionNamespaceSupport object defines.
`java.lang.Object`	`ExtensionHandlerGeneral.callFunction(java.lang.String funcName, java.util.Vector args, java.lang.Object methodKey, ExpressionContext exprContext)` Process a call to a function.
`java.lang.Object`	`ExtensionHandlerGeneral.callFunction(FuncExtFunction extFunction, java.util.Vector args, ExpressionContext exprContext)` Process a call to an XPath extension function
`void`	`ExtensionHandlerGeneral.processElement(java.lang.String localPart, ElemTemplateElement element, TransformerImpl transformer, Stylesheet stylesheetTree, java.lang.Object methodKey)` Process a call to this extension namespace via an element.
`static java.lang.reflect.Constructor`	`MethodResolver.getConstructor(java.lang.Class classObj, java.lang.Object[] argsIn, java.lang.Object[][] argsOut, ExpressionContext exprContext)` Given a class, figure out the resolution of the Java Constructor from the XSLT argument types, and perform the conversion of the arguments.
`static java.lang.reflect.Method`	`MethodResolver.getMethod(java.lang.Class classObj, java.lang.String name, java.lang.Object[] argsIn, java.lang.Object[][] argsOut, ExpressionContext exprContext, int searchMethod)` Given the name of a method, figure out the resolution of the Java Method from the XSLT argument types, and perform the conversion of the arguments.
`static java.lang.reflect.Method`	`MethodResolver.getElementMethod(java.lang.Class classObj, java.lang.String name)` Given the name of a method, figure out the resolution of the Java Method
`static void`	`MethodResolver.convertParams(java.lang.Object[] argsIn, java.lang.Object[][] argsOut, java.lang.Class[] paramTypes, ExpressionContext exprContext)` Convert a set of parameters based on a set of paramTypes.
`java.lang.Object`	`ExtensionHandlerJavaClass.callFunction(java.lang.String funcName, java.util.Vector args, java.lang.Object methodKey, ExpressionContext exprContext)` Process a call to a function in the java class represented by this `ExtensionHandlerJavaClass.`
`java.lang.Object`	`ExtensionHandlerJavaClass.callFunction(FuncExtFunction extFunction, java.util.Vector args, ExpressionContext exprContext)` Process a call to an XPath extension function
`void`	`ExtensionHandlerJavaClass.processElement(java.lang.String localPart, ElemTemplateElement element, TransformerImpl transformer, Stylesheet stylesheetTree, java.lang.Object methodKey)` Process a call to this extension namespace via an element.

Constructors in org.apache.xalan.extensions that throw TransformerException
`ExtensionsTable.ExtensionsTable(StylesheetRoot sroot)` The constructor (called from TransformerImpl) registers the StylesheetRoot for the transformation and instantiates an ExtensionHandler for each extension namespace.
`ExtensionHandlerGeneral.ExtensionHandlerGeneral(java.lang.String namespaceUri, StringVector elemNames, StringVector funcNames, java.lang.String scriptLang, java.lang.String scriptSrcURL, java.lang.String scriptSrc, java.lang.String systemId)` Construct a new extension namespace handler given all the information needed.

Uses of TransformerException in org.apache.xalan.lib

Methods in org.apache.xalan.lib that throw TransformerException
`void`	`PipeDocument.pipeDocument(XSLProcessorContext context, ElemExtensionCall elem)` Extension element for piping an XML document through a series of 1 or more transformations.
`void`	`PipeDocument.usePipe(java.util.Vector vTHandler, java.lang.String source, java.lang.String target)` Uses a Vector of TransformerHandlers to pipe XML input document through a series of 1 or more transformations.
`void`	`Redirect.open(XSLProcessorContext context, ElemExtensionCall elem)` Open the given file and put it in the XML, HTML, or Text formatter listener's table.
`void`	`Redirect.write(XSLProcessorContext context, ElemExtensionCall elem)` Write the evalutation of the element children to the given file.
`void`	`Redirect.close(XSLProcessorContext context, ElemExtensionCall elem)` Close the given file and remove it from the formatter listener's table.

Uses of TransformerException in org.apache.xalan.processor

Methods in org.apache.xalan.processor that throw TransformerException
`XPath`	`StylesheetHandler.createXPath(java.lang.String str, ElemTemplateElement owningTemplate)` Process an expression string into an XPath.

Uses of TransformerException in org.apache.xalan.serialize

Methods in org.apache.xalan.serialize that throw TransformerException
`static void`	`SerializerUtils.addAttribute(SerializationHandler handler, int attr)` Copy an DOM attribute to the created output element, executing attribute templates as need be, and processing the xsl:use attribute.
`static void`	`SerializerUtils.addAttributes(SerializationHandler handler, int src)` Copy DOM attributes to the result element.
`static void`	`SerializerUtils.processNSDecls(SerializationHandler handler, int src, int type, DTM dtm)` Copy `xmlns:` attributes in if not already in scope.

Uses of TransformerException in org.apache.xalan.templates

Methods in org.apache.xalan.templates that throw TransformerException
`void`	`ElemTemplateElement.runtimeInit(TransformerImpl transformer)` This function will be called on top-level elements only, just before the transform begins.
`void`	`ElemTemplateElement.execute(TransformerImpl transformer)` Execute the element's primary function.
`void`	`ElemTemplateElement.recompose(StylesheetRoot root)` This function is called during recomposition to control how this element is composed.
`void`	`ElemTemplateElement.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemTemplateElement.endCompose(StylesheetRoot sroot)` This after the template's children have been composed.
`void`	`ElemTemplateElement.setPrefixes(NamespaceSupport nsSupport)` From the SAX2 helper class, set the namespace table for this element.
`void`	`ElemTemplateElement.setPrefixes(NamespaceSupport nsSupport, boolean excludeXSLDecl)` Copy the namespace declarations from the NamespaceSupport object.
`void`	`ElemTemplateElement.resolvePrefixTables()` Combine the parent's namespaces with this namespace for fast processing, taking care to reference the parent's namespace if this namespace adds nothing new.
`boolean`	`ElemTemplateElement.shouldStripWhiteSpace(XPathContext support, Element targetElement)` Get information about whether or not an element should strip whitespace.
`void`	`ElemTemplate.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemTemplate.endCompose(StylesheetRoot sroot)` This after the template's children have been composed.
`void`	`ElemTemplate.execute(TransformerImpl transformer)` Copy the template contents into the result tree.
`void`	`ElemExsltFunction.execute(TransformerImpl transformer, XObject[] args)`
`void`	`ElemExsltFunction.compose(StylesheetRoot sroot)` Called after everything else has been recomposed, and allows the function to set remaining values that may be based on some other property that depends on recomposition.
`XObject`	`FuncFormatNumb.execute(XPathContext xctxt)` Execute the function.
`void`	`FuncFormatNumb.warn(XPathContext xctxt, java.lang.String msg, java.lang.Object[] args)` Warn the user of a problem.
`void`	`ElemFallback.execute(TransformerImpl transformer)` This is the normal call when xsl:fallback is instantiated.
`void`	`ElemFallback.executeFallback(TransformerImpl transformer)` Execute the fallback elements.
`void`	`OutputProperties.recompose(StylesheetRoot root)` This function is called to recompose all of the output format extended elements.
`void`	`OutputProperties.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`OutputProperties.copyFrom(OutputProperties opsrc)` Copy the keys and values from the source to this object.
`void`	`ElemUse.applyAttrSets(TransformerImpl transformer, StylesheetRoot stylesheet)` Add the attributes from the named attribute sets to the attribute list.
`void`	`ElemUse.execute(TransformerImpl transformer)` Copy attributes specified by use-attribute-sets to the result tree.
`void`	`ElemLiteralResult.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemLiteralResult.resolvePrefixTables()` Augment resolvePrefixTables, resolving the namespace aliases once the superclass has resolved the tables.
`void`	`ElemLiteralResult.execute(TransformerImpl transformer)` Copy a Literal Result Element into the Result tree, copy the non-excluded namespace attributes, copy the attributes not of the XSLT namespace, and execute the children of the LRE.
`void`	`ElemUnknown.execute(TransformerImpl transformer)` Execute an unknown element.
`void`	`ElemVariable.execute(TransformerImpl transformer)` Execute a variable declaration and push it onto the variable stack.
`XObject`	`ElemVariable.getValue(TransformerImpl transformer, int sourceNode)` Get the XObject representation of the variable.
`void`	`ElemVariable.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemVariable.endCompose(StylesheetRoot sroot)` This after the template's children have been composed.
`void`	`ElemExsltFuncResult.execute(TransformerImpl transformer)` Generate the EXSLT function return value, and assign it to the variable index slot assigned for it in ElemExsltFunction compose().
`XObject`	`XUnresolvedVariable.execute(XPathContext xctxt)` For support of literal objects in xpaths.
`void`	`ElemIf.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemIf.execute(TransformerImpl transformer)` Conditionally execute a sub-template.
`void`	`ElemComment.execute(TransformerImpl transformer)` Execute the xsl:comment transformation
`void`	`ElemValueOf.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemValueOf.execute(TransformerImpl transformer)` Execute the string expression and copy the text to the result tree.
`ElemTemplate`	`Stylesheet.getTemplate(int i)` Get an "xsl:template" property.
`void`	`Stylesheet.replaceTemplate(ElemTemplate v, int i)` Replace an "xsl:template" property.
`void`	`StylesheetComposed.recompose(java.util.Vector recomposableElements)` Adds all recomposable values for this precedence level into the recomposableElements Vector that was passed in as the first parameter.
`void`	`StylesheetComposed.recomposeTemplates(boolean flushFirst)` For compilation support, we need the option of overwriting (rather than appending to) previous composition.
`void`	`ElemPI.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemPI.execute(TransformerImpl transformer)` Create a processing instruction in the result tree.
`void`	`ElemForEach.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemForEach.endCompose(StylesheetRoot sroot)` This after the template's children have been composed.
`void`	`ElemForEach.execute(TransformerImpl transformer)` Execute the xsl:for-each transformation
`DTMIterator`	`ElemForEach.sortNodes(XPathContext xctxt, java.util.Vector keys, DTMIterator sourceNodes)` Sort given nodes
`void`	`ElemForEach.transformSelectedNodes(TransformerImpl transformer)` Perform a query if needed, and call transformNode for each child.
`void`	`ElemTextLiteral.execute(TransformerImpl transformer)` Copy the text literal to the result tree.
`void`	`ElemElement.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemElement.execute(TransformerImpl transformer)` Create an element in the result tree.
`void`	`StylesheetRoot.recompose()` Recompose the values of all "composed" properties, meaning properties that need to be combined or calculated from the combination of imported and included stylesheets.
`ElemTemplate`	`StylesheetRoot.getTemplateComposed(XPathContext xctxt, int targetNode, QName mode, boolean quietConflictWarnings, DTM dtm)` Get an "xsl:template" property by node match.
`ElemTemplate`	`StylesheetRoot.getTemplateComposed(XPathContext xctxt, int targetNode, QName mode, int maxImportLevel, int endImportLevel, boolean quietConflictWarnings, DTM dtm)` Get an "xsl:template" property by node match.
`WhiteSpaceInfo`	`StylesheetRoot.getWhiteSpaceInfo(XPathContext support, int targetElement, DTM dtm)` Get information about whether or not an element should strip whitespace.
`boolean`	`StylesheetRoot.shouldStripWhiteSpace(XPathContext support, int targetElement)` Get information about whether or not an element should strip whitespace.
`abstract void`	`AVTPart.evaluate(XPathContext xctxt, FastStringBuffer buf, int context, PrefixResolver nsNode)` Write the evaluated value into the given string buffer.
`void`	`KeyDeclaration.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemExtensionDecl.compose(StylesheetRoot sroot)`
`void`	`ElemExtensionDecl.runtimeInit(TransformerImpl transformer)` This function will be called on top-level elements only, just before the transform begins.
`void`	`ElemCopy.execute(TransformerImpl transformer)` The xsl:copy element provides an easy way of copying the current node.
`void`	`ElemCallTemplate.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemCallTemplate.endCompose(StylesheetRoot sroot)` This after the template's children have been composed.
`void`	`ElemCallTemplate.execute(TransformerImpl transformer)` Invoke a named template.
`void`	`ElemApplyTemplates.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemApplyTemplates.execute(TransformerImpl transformer)` Apply the context node to the matching templates.
`void`	`ElemApplyTemplates.transformSelectedNodes(TransformerImpl transformer)` Perform a query if needed, and call transformNode for each child.
`void`	`ElemChoose.execute(TransformerImpl transformer)` Execute the xsl:choose transformation.
`void`	`AVTPartXPath.evaluate(XPathContext xctxt, FastStringBuffer buf, int context, PrefixResolver nsNode)` Write the value into the buffer.
`XObject`	`FuncDocument.execute(XPathContext xctxt)` Execute the function.
`void`	`FuncDocument.error(XPathContext xctxt, java.lang.String msg, java.lang.Object[] args)` Tell the user of an error, and probably throw an exception.
`void`	`FuncDocument.warn(XPathContext xctxt, java.lang.String msg, java.lang.Object[] args)` Warn the user of a problem.
`java.lang.String`	`AVT.evaluate(XPathContext xctxt, int context, PrefixResolver nsNode)` Evaluate the AVT and return a String.
`void`	`ElemParam.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemParam.execute(TransformerImpl transformer)` Execute a variable declaration and push it onto the variable stack.
`void`	`ElemVariablePsuedo.execute(TransformerImpl transformer)` Execute a variable declaration and push it onto the variable stack.
`XObject`	`XUnresolvedVariableSimple.execute(XPathContext xctxt)` For support of literal objects in xpaths.
`void`	`ElemCopyOf.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemCopyOf.execute(TransformerImpl transformer)` The xsl:copy-of element can be used to insert a result tree fragment into the result tree, without first converting it to a string as xsl:value-of does (see [7.6.1 Generating Text with xsl:value-of]).
`XObject`	`FuncKey.execute(XPathContext xctxt)` Execute the function.
`void`	`ElemExtensionCall.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemExtensionCall.execute(TransformerImpl transformer)` Execute an extension.
`java.lang.String`	`ElemExtensionCall.getAttribute(java.lang.String rawName, Node sourceNode, TransformerImpl transformer)` Return the value of the attribute interpreted as an Attribute Value Template (in other words, you can use curly expressions such as href="http://{website}".
`void`	`ElemSort.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemWhen.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemApplyImport.execute(TransformerImpl transformer)` Execute the xsl:apply-imports transformation.
`void`	`ElemAttributeSet.execute(TransformerImpl transformer)` Apply a set of attributes to the element.
`void`	`ElemNumber.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`void`	`ElemNumber.execute(TransformerImpl transformer)` Execute an xsl:number instruction.
`int`	`ElemNumber.getPreviousNode(XPathContext xctxt, int pos)` Get the previous node to be counted.
`int`	`ElemNumber.getTargetNode(XPathContext xctxt, int sourceNode)` Get the target node that will be counted..
`void`	`ElemAttribute.execute(TransformerImpl transformer)` Create an attribute in the result tree.
`ElemTemplate`	`TemplateList.getTemplateFast(XPathContext xctxt, int targetNode, int expTypeID, QName mode, int maxImportLevel, boolean quietConflictWarnings, DTM dtm)` Given a target element, find the template that best matches in the given XSL document, according to the rules specified in the xsl draft.
`ElemTemplate`	`TemplateList.getTemplate(XPathContext xctxt, int targetNode, QName mode, boolean quietConflictWarnings, DTM dtm)` Given a target element, find the template that best matches in the given XSL document, according to the rules specified in the xsl draft.
`ElemTemplate`	`TemplateList.getTemplate(XPathContext xctxt, int targetNode, QName mode, int maxImportLevel, int endImportLevel, boolean quietConflictWarnings, DTM dtm)` Given a target element, find the template that best matches in the given XSL document, according to the rules specified in the xsl draft.
`void`	`ElemMessage.execute(TransformerImpl transformer)` Send a message to diagnostics.
`void`	`ElemWithParam.compose(StylesheetRoot sroot)` This function is called after everything else has been recomposed, and allows the template to set remaining values that may be based on some other property that depends on recomposition.
`XObject`	`ElemWithParam.getValue(TransformerImpl transformer, int sourceNode)` Get the XObject representation of the variable.

Constructors in org.apache.xalan.templates that throw TransformerException
`ElemVariable.ElemVariable(ElemVariable param)` Copy constructor.
`AVTPartXPath.AVTPartXPath(java.lang.String val, PrefixResolver nsNode, XPathParser xpathProcessor, XPathFactory factory, XPathContext liaison)` Construct a simple AVT part.
`AVT.AVT(StylesheetHandler handler, java.lang.String uri, java.lang.String name, java.lang.String rawName, java.lang.String stringedValue, ElemTemplateElement owner)` Construct an AVT by parsing the string, and either constructing a vector of AVTParts, or simply hold on to the string if the AVT is simple.
`ElemParam.ElemParam(ElemParam param)` Copy constructor.

Uses of TransformerException in org.apache.xalan.trace

Methods in org.apache.xalan.trace that throw TransformerException
`void`	`TraceListenerEx.selectEnd(EndSelectionEvent ev)` Method that is called after an xsl:apply-templates or xsl:for-each selection occurs.
`void`	`TraceManager.fireSelectedEvent(int sourceNode, ElemTemplateElement styleNode, java.lang.String attributeName, XPath xpath, XObject selection)` Fire a selection event.
`void`	`TraceManager.fireSelectedEndEvent(int sourceNode, ElemTemplateElement styleNode, java.lang.String attributeName, XPath xpath, XObject selection)` Fire a selection event.
`void`	`TraceManager.fireSelectedEndEvent(EndSelectionEvent se)` Fire a selection event.
`void`	`TraceManager.fireSelectedEvent(SelectionEvent se)` Fire a selection event.
`void`	`PrintTraceListener.selected(SelectionEvent ev)` Method that is called just after a select attribute has been evaluated.
`void`	`PrintTraceListener.selectEnd(EndSelectionEvent ev)` Method that is called after an xsl:apply-templates or xsl:for-each selection occurs.
`void`	`TraceListener.selected(SelectionEvent ev)` Method that is called just after the formatter listener is called.

Uses of TransformerException in org.apache.xalan.transformer

Methods in org.apache.xalan.transformer that throw TransformerException
`int`	`CountersTable.countNode(XPathContext support, ElemNumber numberElem, int node)` Count forward until the given node is found, or until we have looked to the given amount.
`boolean`	`TransformerImpl.functionAvailable(java.lang.String ns, java.lang.String funcName)`
`boolean`	`TransformerImpl.elementAvailable(java.lang.String ns, java.lang.String elemName)`
`java.lang.Object`	`TransformerImpl.extFunction(java.lang.String ns, java.lang.String funcName, java.util.Vector argVec, java.lang.Object methodKey)`
`java.lang.Object`	`TransformerImpl.extFunction(FuncExtFunction extFunction, java.util.Vector argVec)`
`void`	`TransformerImpl.transform(Source source)` Process the source tree to SAX parse events.
`void`	`TransformerImpl.transform(Source source, boolean shouldRelease)` Process the source tree to SAX parse events.
`SerializationHandler`	`TransformerImpl.createSerializationHandler(Result outputTarget)` Create a result ContentHandler from a Result object, based on the current OutputProperties.
`SerializationHandler`	`TransformerImpl.createSerializationHandler(Result outputTarget, OutputProperties format)` Create a ContentHandler from a Result object and an OutputProperties.
`void`	`TransformerImpl.transform(Source xmlSource, Result outputTarget)` Process the source tree to the output result.
`void`	`TransformerImpl.transform(Source xmlSource, Result outputTarget, boolean shouldRelease)` Process the source tree to the output result.
`void`	`TransformerImpl.transformNode(int node, Result outputTarget)` Process the source node to the output result, if the processor supports the "http://xml.org/trax/features/dom/input" feature.
`void`	`TransformerImpl.transformNode(int node)` Process the source node to the output result, if the processor supports the "http://xml.org/trax/features/dom/input" feature.
`int`	`TransformerImpl.transformToRTF(ElemTemplateElement templateParent)` Given a stylesheet element, create a result tree fragment from it's contents.
`int`	`TransformerImpl.transformToGlobalRTF(ElemTemplateElement templateParent)` Given a stylesheet element, create a result tree fragment from it's contents.
`java.lang.String`	`TransformerImpl.transformToString(ElemTemplateElement elem)` Take the contents of a template element, process it, and convert it to a string.
`boolean`	`TransformerImpl.applyTemplateToNode(ElemTemplateElement xslInstruction,`

Uses of Classjavax.xml.transform.TransformerException

Uses of Class
javax.xml.transform.TransformerException