XPathExecutionContextDefault.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(XPATHEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680)
#define XPATHEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680
 
 
 
// Base include file.  Must be first.
#include <xalanc/XPath/XPathDefinitions.hpp>
 
 
 
#include <xalanc/Include/XalanObjectCache.hpp>
#include <xalanc/Include/XalanVector.hpp>
 
 
 
#include <xalanc/XalanDOM/XalanDOMString.hpp>
 
 
 
// Base class include file.
#include <xalanc/XPath/XPathExecutionContext.hpp>
 
 
 
#include <xalanc/PlatformSupport/XalanDOMStringCache.hpp>
 
 
 
#include <xalanc/XPath/MutableNodeRefList.hpp>
#include <xalanc/XPath/XalanQNameByValue.hpp>
 
 
 
namespace XALAN_CPP_NAMESPACE {
 
 
 
class DOMSupport;
class XPathEnvSupport;
class XalanQName;
 
 
 
/**
 * A basic implementation of the class XPathExecutionContext.
 */
class XALAN_XPATH_EXPORT XPathExecutionContextDefault : public XPathExecutionContext
{
public:
 
    typedef XalanVector<XalanNode*>             CurrentNodeStackType;
    typedef XalanVector<const NodeRefListBase*> ContextNodeListStackType;
 
    /**
     * Construct an XPathExecutionContextDefault object
     *
     * @param theXPathEnvSupport XPathEnvSupport class instance
     * @param theDOMSupport      DOMSupport class instance
     * @param theXobjectFactory  factory class instance for XObjects
     * @param theCurrentNode     current node in the source tree
     * @param theContextNodeList node list for current context
     * @param thePrefixResolver  pointer to prefix resolver to use
     */ 
    XPathExecutionContextDefault(
            XPathEnvSupport&        theXPathEnvSupport,
            DOMSupport&             theDOMSupport,
            XObjectFactory&         theXObjectFactory,
            XalanNode*              theCurrentNode = 0,
            const NodeRefListBase*  theContextNodeList = 0,
            const PrefixResolver*   thePrefixResolver = 0);
 
    /**
     * Construct an XPathExecutionContextDefault object
     *
     * @param theXPathEnvSupport XPathEnvSupport class instance
     * @param theXObjectFactory  factory class instance for XObjects
     * @param theCurrentNode     current node in the source tree
     * @param theContextNodeList node list for current context
     * @param thePrefixResolver  pointer to prefix resolver to use
     */
    explicit
    XPathExecutionContextDefault(
            MemoryManager&      theManager,
            XalanNode*              theCurrentNode = 0,
            const NodeRefListBase*  theContextNodeList = 0,
            const PrefixResolver*   thePrefixResolver = 0);
 
    static XPathExecutionContextDefault*
    create(
            MemoryManager&      theManager,
            XalanNode*              theCurrentNode = 0,
            const NodeRefListBase*  theContextNodeList = 0,
            const PrefixResolver*   thePrefixResolver = 0);
 
    virtual
    ~XPathExecutionContextDefault();
 
 
    /**
     * Get the XPathEnvSupport instance.
     *
     * @return a pointer to the instance.
     */
    XPathEnvSupport*
    getXPathEnvSupport() const
    {
        return m_xpathEnvSupport;
    }
 
    /**
     * Set the XPathEnvSupport instance.
     *
     * @param theSupport a reference to the instance to use.
     */
    void
    setXPathEnvSupport(XPathEnvSupport*     theSupport)
    {
        m_xpathEnvSupport = theSupport;
    }
 
    /**
     * Set the DOMSupport instance.
     *
     * @param theDOMSupport a reference to the instance to use.
     */
    void
    setDOMSupport(DOMSupport*   theDOMSupport)
    {
        m_domSupport = theDOMSupport;
    }
 
    /**
     * Set the XObjectFactory instance.
     *
     * @param theFactory a reference to the instance to use.
     */
    void
    setXObjectFactory(XObjectFactory*   theXObjectFactory)
    {
        m_xobjectFactory = theXObjectFactory;
    }
 
    /**
     * Get a reference to the scratch QNameByValue instance.
     *
     * @return A reference to a QNameByValue instance.
     */
    XalanQNameByValue&
    getScratchQName() const
    {
        return m_scratchQName;
    }
 
    virtual void doFormatNumber(
            double                              number,
            const XalanDOMString&               pattern,
            const XalanDecimalFormatSymbols*    theDFS,
            XalanDOMString&                     theResult,
            const XalanNode*                    context = 0,
            const Locator*                      locator = 0);
 
    // These interfaces are inherited from XPathExecutionContext...
 
    virtual void
    reset();
 
    virtual XalanNode*
    getCurrentNode() const;
 
    virtual void
    pushCurrentNode(XalanNode*      theCurrentNode);
 
    virtual void
    popCurrentNode();
 
    virtual bool
    isNodeAfter(
            const XalanNode&    node1,
            const XalanNode&    node2) const;
 
    virtual void
    pushContextNodeList(const NodeRefListBase&  theList);
 
    virtual void    
    popContextNodeList();
 
    virtual const NodeRefListBase&
    getContextNodeList() const;
 
    virtual size_type
    getContextNodeListLength() const;
 
    virtual size_type
    getContextNodeListPosition(const XalanNode&     contextNode) const;
 
    virtual bool
    elementAvailable(const XalanQName&  theQName) const;
 
    virtual bool
    elementAvailable(
            const XalanDOMString&   theName,
            const Locator*          locator) const;
 
    virtual bool
    functionAvailable(const XalanQName&     theQName) const;
 
    virtual bool
    functionAvailable(
            const XalanDOMString&   theName,
            const Locator*          locator) const;
 
    virtual const XObjectPtr
    extFunction(
            const XalanDOMString&           theNamespace,
            const XalanDOMString&           functionName,
            XalanNode*                      context,
            const XObjectArgVectorType&     argVec,
            const Locator*                  locator);
 
    virtual XalanDocument*
    parseXML(
            MemoryManager&      theManager,
            const XalanDOMString&   urlString,
            const XalanDOMString&   base,
            ErrorHandler*           theErrorHandler = 0) const;
 
    virtual MutableNodeRefList*
    borrowMutableNodeRefList();
 
    virtual bool
    returnMutableNodeRefList(MutableNodeRefList*    theList);
 
    virtual MutableNodeRefList*
    createMutableNodeRefList(MemoryManager& theManager) const;
 
    virtual XalanDOMString&
    getCachedString();
 
    virtual bool
    releaseCachedString(XalanDOMString&     theString);
 
    virtual void
    getNodeSetByKey(
            XalanNode*              context,
            const XalanQName&       qname,
            const XalanDOMString&   ref,
            const Locator*          locator,
            MutableNodeRefList&     nodelist);
 
    virtual void
    getNodeSetByKey(
            XalanNode*              context,
            const XalanDOMString&   name,
            const XalanDOMString&   ref,
            const Locator*          locator,
            MutableNodeRefList&     nodelist);
 
    virtual const XObjectPtr
    getVariable(
            const XalanQName&   name,
            const Locator*      locator = 0);
 
    virtual const PrefixResolver*
    getPrefixResolver() const;
 
    virtual void
    setPrefixResolver(const PrefixResolver*     thePrefixResolver);
 
    virtual const XalanDOMString*
    getNamespaceForPrefix(const XalanDOMString&     prefix) const;
 
    virtual const XalanDOMString&
    findURIFromDoc(const XalanDocument*     owner) const;
 
    virtual const XalanDOMString&
    getUnparsedEntityURI(
            const XalanDOMString&   theName,
            const XalanDocument&    theDocument) const;
 
    virtual XalanDocument*
    getSourceDocument(const XalanDOMString&     theURI) const;
 
    virtual void
    setSourceDocument(
            const XalanDOMString&   theURI,
            XalanDocument*          theDocument);
 
    virtual void formatNumber(
            double                              number,
            const XalanDOMString&               pattern,
            XalanDOMString&                     theResult,
            const XalanNode*                    context = 0,
            const Locator*                      locator = 0);
 
    virtual void formatNumber(
            double                              number,
            const XalanDOMString&               pattern,
            const XalanDOMString&               dfsName,
            XalanDOMString&                     theResult,
            const XalanNode*                    context = 0,
            const Locator*                      locator = 0);
 
 
    // These interfaces are inherited from ExecutionContext...
 
    virtual void
    problem(
            eSource                 source,
            eClassification         classification,
            const XalanDOMString&   msg,
            const Locator*          locator,
            const XalanNode*        sourceNode);
 
    virtual void
    problem(
            eSource                 source,
            eClassification         classification,
            const XalanDOMString&   msg,
            const XalanNode*        sourceNode);
 
    virtual void
    error(
            const XalanDOMString&   msg,
            const XalanNode*        sourceNode = 0,
            const Locator*          locator = 0) const;
 
    virtual void
    warn(
            const XalanDOMString&   msg,
            const XalanNode*        sourceNode = 0,
            const Locator*          locator = 0) const;
 
    virtual void
    message(
            const XalanDOMString&   msg,
            const XalanNode*        sourceNode = 0,
            const Locator*          locator = 0) const;
 
    virtual bool
    shouldStripSourceNode(const XalanText&  node);
 
protected:
 
    typedef XalanObjectCache<
                MutableNodeRefList,
                DefaultCacheCreateFunctorMemMgr<MutableNodeRefList>,
                DeleteFunctor<MutableNodeRefList>,
                ClearCacheResetFunctor<MutableNodeRefList> >    NodeListCacheType;
 
    enum { eNodeListCacheListSize = 50 };
 
    struct ContextNodeListPositionCache
    {
        ContextNodeListPositionCache() :
            m_node(0),
            m_index(0)
        {
        }
 
        void
        clear()
        {
            if (m_node != 0)
            {
                m_node = 0;
            }
        }
 
        const XalanNode*    m_node;
 
        size_type           m_index;
    };
 
    XPathEnvSupport*                        m_xpathEnvSupport;
 
    DOMSupport*                             m_domSupport;
 
    CurrentNodeStackType                    m_currentNodeStack;
 
    ContextNodeListStackType                m_contextNodeListStack;
 
    const PrefixResolver*                   m_prefixResolver;
 
    XalanDOMString                          m_currentPattern;
 
    NodeListCacheType                       m_nodeListCache;
 
    XalanDOMStringCache                     m_stringCache;
 
    mutable ContextNodeListPositionCache    m_cachedPosition;
 
    mutable XalanQNameByValue               m_scratchQName;
 
    static const NodeRefList                s_dummyList;
};
 
 
 
}
 
 
 
#endif  // XPATHEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680