ExtensionFunctionHandler.hpp

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the  "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#if !defined(XALAN_EXTENSIONFUNCTIONHANDLER_HEADER_GUARD)
#define XALAN_EXTENSIONFUNCTIONHANDLER_HEADER_GUARD
 
 
 
// Base include file.   Must be first.
#include <xalanc/XSLT/XSLTDefinitions.hpp>
 
 
 
#include <xalanc/XalanDOM/XalanDOMString.hpp>
 
 
 
#include <xalanc/Include/XalanVector.hpp>
#include <xalanc/Include/XalanSet.hpp>
 
 
 
#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
 
 
 
#include <xalanc/XPath/XObject.hpp>
 
 
 
namespace XALAN_CPP_NAMESPACE {
 
 
 
class XObjectPtr;
 
 
 
/**
 * Class handling an extension namespace for XPath. Provides functions
 * to test a function's existence and call a function
 */
class XALAN_XSLT_EXPORT ExtensionFunctionHandler 
{
 
public:
 
    /**
     * Construct a new extension namespace handler for a given extension NS.
     * This doesn't do anything - just hang on to the namespace URI.
     * 
     * @param namespaceUri the extension namespace URI that I'm implementing
     */
    ExtensionFunctionHandler(const XalanDOMString&  namespaceUri,
                            MemoryManager& theManager);
 
    /**
     * Construct a new extension namespace handler given all the information
     * needed. 
     * 
     * @param namespaceUri the extension namespace URI that I'm implementing
     * @param funcNames    string containing list of functions of extension NS
     * @param lang         language of code implementing the extension
     * @param srcURL       value of src attribute (if any) - treated as a URL
     *                     or a classname depending on the value of lang. If
     *                     srcURL is not null, then scriptSrc is ignored.
     * @param scriptSrc    the actual script code (if any)
     */
    ExtensionFunctionHandler(
            MemoryManager& theManager,
            const XalanDOMString&   namespaceUri,
            const XalanDOMString&   funcNames,
            const XalanDOMString&   lang,
            const XalanDOMString&   srcURL,
            const XalanDOMString&   scriptSrc);
 
 
    virtual
    ~ExtensionFunctionHandler();
 
    MemoryManager&
    getMemoryManager()
    {
        return m_namespaceUri.getMemoryManager();
    }
 
    /**
     * Set function local parts of extension NS.
     *
     * @param functions whitespace separated list of function names defined
     *                  by this extension namespace.
     */
    virtual void
    setFunctions(const XalanDOMString&  funcNames);
 
    /**
     * Set the script data for this extension NS. If srcURL is !null then
     * the script body is read from that URL. If not the scriptSrc is used
     * as the src. This method does not actually execute anything - that's
     * done when the component is first hit by the user by an element or 
     * a function call.
     *
     * @param lang      language of the script.
     * @param srcURL    value of src attribute (if any) - treated as a URL
     *                  or a classname depending on the value of lang. If
     *                  srcURL is not null, then scriptSrc is ignored.
     * @param scriptSrc the actual script code (if any)
     */
    virtual void
    setScript(
            const XalanDOMString&   lang,
            const XalanDOMString&   srcURL,
            const XalanDOMString&   scriptSrc);
 
    /**
     * Tests whether a certain function name is known within this namespace.
     *
     * @param function name of the function being tested
     * @return true if its known, false if not.
     */
    virtual bool
    isFunctionAvailable(const XalanDOMString&   function) const;
 
    /// Vector of pointers to function arguments
    typedef XalanVector<void*>                          ArgVectorType;
 
    typedef XalanSet<XalanDOMString>    StringSetType;
 
    /**
     * Process a call to a function.
     *
     * @param funcName Function name.
     * @param args     The arguments of the function call.
     *
     * @return the return value of the function evaluation.
     *
     * @exception XSLProcessorException thrown if something goes wrong 
     *            while running the extension handler.
     * @exception MalformedURLException if loading trouble
     * @exception FileNotFoundException if loading trouble
     * @exception IOException           if loading trouble
     * @exception SAXException          if parsing trouble
     */
 
    virtual XObjectPtr
    callFunction(
            const XalanDOMString&   funcName,
            const ArgVectorType&    args);
 
protected:
 
    XalanDOMString  m_namespaceUri;  // uri of the extension namespace
    XalanDOMString  m_scriptLang;    // scripting language of implementation
    XalanDOMString  m_scriptSrc;     // script source to run (if any)
    XalanDOMString  m_scriptSrcURL;  // URL of source of script (if any)
 
    void* m_javaObject;         // object for javaclass engine
 
    StringSetType   m_functions; // functions of namespace
 
    //  BSFManager mgr = new BSFManager (); // mgr used to run scripts
 
    bool            m_componentStarted; // true when the scripts in a
 
    // component description (if any) have been run
 
    /**
     * Start the component up by executing any script that needs to run
     * at startup time. This needs to happen before any functions can be
     * called on the component. 
     * 
     * @exception XPathProcessorException if something bad happens.
     */
    virtual void
    startupComponent();
 
    static const XalanDOMChar   s_tokenDelimiterCharacters[];
};
 
 
 
}
 
 
 
#endif  // XALAN_EXTENSIONFUNCTIONHANDLER_HEADER_GUARD