## org.apache.xalan.extensions
Class ExtensionHandlerJavaPackage

    java.lang.Object
      org.apache.xalan.extensions.ExtensionHandler
          org.apache.xalan.extensions.ExtensionHandlerJava
              org.apache.xalan.extensions.ExtensionHandlerJavaPackage

    public class ExtensionHandlerJavaPackage

extends ExtensionHandlerJava

Represents an extension namespace for XPath that handles java packages that may be fully or partially specified. It is recommended that the class URI be of one of the following forms:

       xalan://partial.class.name
       xalan://
       http://xml.apache.org/xalan/java (which is the same as xalan://)

However, we do not enforce this. If the class name contains a a /, we only use the part to the right of the rightmost slash. In addition, we ignore any "class:" prefix. Provides functions to test a function's existence and call a function. Also provides functions to test an element's existence and call an element.

Author:
  Gary L Peskin
Usage:
  **For internal use only**

Constructor Summary
`ExtensionHandlerJavaPackage(java.lang.String namespaceUri, java.lang.String scriptLang, java.lang.String className)` Construct a new extension namespace handler given all the information needed.

Method Summary
`java.lang.Object` `callFunction(FuncExtFunction extFunction, java.util.Vector args, ExpressionContext exprContext)` Process a call to an XPath extension function
`java.lang.Object` `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.
`boolean` `isElementAvailable(java.lang.String element)` Tests whether a certain element name is known within this namespace.
`boolean` `isFunctionAvailable(java.lang.String function)` Tests whether a certain function name is known within this namespace.
`void` `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.

Methods inherited from class org.apache.xalan.extensions.ExtensionHandlerJava
`getFromCache, putToCache`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ExtensionHandlerJavaPackage

    public ExtensionHandlerJavaPackage(java.lang.String namespaceUri,
                                       java.lang.String scriptLang,
                                       java.lang.String className)

  Construct a new extension namespace handler given all the information needed.

  Parameters:
    `namespaceUri` - the extension namespace URI that I'm implementing
    `scriptLang` - language of code implementing the extension
    `className` - the beginning of the class name of the class. This should be followed by a dot (.)

Method Detail

### isFunctionAvailable

    public boolean isFunctionAvailable(java.lang.String function)

  Tests whether a certain function name is known within this namespace. Since this is for a package, we concatenate the package name used when this handler was created and the function name specified in the argument. There is no information regarding the arguments to the function call or whether the method implementing the function is a static method or an instance method.

  Specified by:
    `isFunctionAvailable` in class `ExtensionHandler`
  Parameters:
    `function` - name of the function being tested
  Returns:
    true if its known, false if not.

### isElementAvailable

    public boolean isElementAvailable(java.lang.String element)

  Tests whether a certain element name is known within this namespace. Looks for a method with the appropriate name and signature. This method examines both static and instance methods.

  Specified by:
    `isElementAvailable` in class `ExtensionHandler`
  Parameters:
    `element` - name of the element being tested
  Returns:
    true if its known, false if not.

### callFunction

    public java.lang.Object callFunction(java.lang.String funcName,
                                         java.util.Vector args,
                                         java.lang.Object methodKey,
                                         ExpressionContext exprContext)
                                  throws javax.xml.transform.TransformerException

  Process a call to a function in the package java namespace. There are three possible types of calls:

         Constructor:
           packagens:class.name.new(arg1, arg2, ...)

         Static method:
           packagens:class.name.method(arg1, arg2, ...)

         Instance method:
           packagens:method(obj, arg1, arg2, ...)

  We use the following rules to determine the type of call made:
  1. If the function name ends with a ".new", call the best constructor for class whose name is formed by concatenating the value specified on the namespace with the value specified in the function invocation before ".new".
  2. If the function name contains a period, call the best static method "method" in the class whose name is formed by concatenating the value specified on the namespace with the value specified in the function invocation.
  3. Otherwise, call the best instance method "method" in the class whose name is formed by concatenating the value specified on the namespace with the value specified in the function invocation. Note that a static method of the same name will not be called in the current implementation. This module does not verify that the obj argument is a member of the package namespace.

  Specified by:
    `callFunction` in class `ExtensionHandler`
  Parameters:
    `funcName` - Function name.
    `args` - The arguments of the function call.
    `methodKey` - A key that uniquely identifies this class and method call.
    `exprContext` - The context in which this expression is being executed.
  Returns:
    the return value of the function evaluation.
  Throws:
    `javax.xml.transform.TransformerException` - if parsing trouble

### callFunction

    public java.lang.Object callFunction(FuncExtFunction extFunction,
                                         java.util.Vector args,
                                         ExpressionContext exprContext)
                                  throws javax.xml.transform.TransformerException

  Process a call to an XPath extension function

  Specified by:
    `callFunction` in class `ExtensionHandler`
  Parameters:
    `extFunction` - The XPath extension function
    `args` - The arguments of the function call.
    `exprContext` - The context in which this expression is being executed.
  Returns:
    the return value of the function evaluation.
  Throws:
    `javax.xml.transform.TransformerException`

### processElement

    public void processElement(java.lang.String localPart,
                               ElemTemplateElement element,
                               TransformerImpl transformer,
                               Stylesheet stylesheetTree,
                               java.lang.Object methodKey)
                        throws javax.xml.transform.TransformerException,
                               java.io.IOException

  Process a call to this extension namespace via an element. As a side effect, the results are sent to the TransformerImpl's result tree. For this namespace, only static element methods are currently supported. If instance methods are needed, please let us know your requirements.

  Specified by:
    `processElement` in class `ExtensionHandler`
  Parameters:
    `localPart` - Element name's local part.
    `element` - The extension element being processed.
    `transformer` - Handle to TransformerImpl.
    `stylesheetTree` - The compiled stylesheet tree.
    `methodKey` - A key that uniquely identifies this element call.
  Throws:
    `java.io.IOException` - if loading trouble
    `javax.xml.transform.TransformerException` - if parsing trouble

Copyright © 2005 Apache XML Project. All Rights Reserved.