StylesheetExecutionContextDefault.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(STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680)
#define STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680
 
 
 
// Base class include file.
#include <xalanc/XSLT/StylesheetExecutionContext.hpp>
 
 
 
#include <ctime>
#include <memory>
 
 
 
#include <xalanc/Include/XalanVector.hpp>
#include <xalanc/Include/XalanMap.hpp>
#include <xalanc/Include/XalanSet.hpp>
#include <xalanc/Include/XalanObjectCache.hpp>
#include <xalanc/Include/XalanObjectStackCache.hpp>
 
 
#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
 
 
#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
#include <xalanc/PlatformSupport/DOMStringPrintWriter.hpp>
#endif
 
 
 
#include <xalanc/XPath/XPathExecutionContextDefault.hpp>
 
 
 
#include <xalanc/XMLSupport/FormatterToText.hpp>
 
 
 
#if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION)
#include <xalanc/XalanSourceTree/XalanSourceTreeDocument.hpp>
#endif
#include <xalanc/XalanSourceTree/FormatterToSourceTree.hpp>
#include <xalanc/XalanSourceTree/XalanSourceTreeDocumentFragment.hpp>
 
 
 
#include <xalanc/XSLT/CountersTable.hpp>
#include <xalanc/XSLT/NodeSorter.hpp>
#include <xalanc/XSLT/Stylesheet.hpp>
#include <xalanc/XSLT/VariablesStack.hpp>
#include <xalanc/XSLT/XResultTreeFragAllocator.hpp>
#include <xalanc/XSLT/XalanSourceTreeDocumentAllocator.hpp>
#include <xalanc/XSLT/XalanSourceTreeDocumentFragmentAllocator.hpp>
 
 
 
namespace XALAN_CPP_NAMESPACE {
 
 
 
class XalanSourceTreeDocument;
class XPathProcessor;
class XSLTEngineImpl;
 
typedef VariablesStack::ParamsVectorType            ParamsVectorTypeDecl;
XALAN_USES_MEMORY_MANAGER(ParamsVectorTypeDecl)
//
// An class which provides support for executing stylesheets.
//
class XALAN_XSLT_EXPORT StylesheetExecutionContextDefault : public StylesheetExecutionContext
{
public:
 
    typedef std::clock_t    ClockType;
 
    typedef XalanVector<FormatterListener*>             FormatterListenerVectorType;
    typedef XalanVector<PrintWriter*>                   PrintWriterVectorType;
    typedef XalanVector<XalanOutputStream*>             OutputStreamVectorType;
 
    typedef XalanVector<const ElemTemplateElement*> ElementTemplateElementStackType;
    typedef std::pair<const XPath*, ClockType>       XPathCacheEntry;
    typedef XalanMap <XalanDOMString, XPathCacheEntry>              XPathCacheMapType;
    typedef XalanVector<const ElemTemplate*>            CurrentTemplateStackType;
 
    typedef Stylesheet::KeyTablesTableType              KeyTablesTableType;
    typedef ParamsVectorTypeDecl                        ParamsVectorType;
 
    /**
     * Construct a StylesheetExecutionContextDefault object
     *
     * @param theXPathEnvSupport XPath environment support 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
     */ 
    StylesheetExecutionContextDefault(
            MemoryManager&      theManager,
            XSLTEngineImpl&         xsltProcessor,
            XPathEnvSupport&        theXPathEnvSupport,
            DOMSupport&             theDOMSupport,
            XObjectFactory&         theXObjectFactory,
            XalanNode*              theCurrentNode = 0,
            const NodeRefListBase*  theContextNodeList = 0,
            const PrefixResolver*   thePrefixResolver = 0);
 
    /**
     * Construct a StylesheetExecutionContextDefault object
     *
     * @param theXPathEnvSupport XPath environment support 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
     */
    explicit
    StylesheetExecutionContextDefault(
            MemoryManager&      theManager,
            XalanNode*              theCurrentNode = 0,
            const NodeRefListBase*  theContextNodeList = 0,
            const PrefixResolver*   thePrefixResolver = 0);
 
    static StylesheetExecutionContextDefault*
    create(
            MemoryManager&      theManager,
            XalanNode*              theCurrentNode = 0,
            const NodeRefListBase*  theContextNodeList = 0,
            const PrefixResolver*   thePrefixResolver = 0);
 
    virtual
    ~StylesheetExecutionContextDefault();
 
 
    /**
     * Set the XPathEnvSupport instance.
     *
     * @param theSupport a reference to the instance to use.
     */
    void
    setXPathEnvSupport(XPathEnvSupport*     theSupport)
    {
        m_xpathExecutionContextDefault.setXPathEnvSupport(theSupport);
    }
 
    /**
     * Set the DOMSupport instance.
     *
     * @param theDOMSupport a reference to the instance to use.
     */
    void
    setDOMSupport(DOMSupport*   theDOMSupport)
    {
        m_xpathExecutionContextDefault.setDOMSupport(theDOMSupport);
    }
 
    /**
     * Set the XObjectFactory instance.
     *
     * @param theFactory a reference to the instance to use.
     */
    void
    setXObjectFactory(XObjectFactory*   theXObjectFactory)
    {
        m_xpathExecutionContextDefault.setXObjectFactory(theXObjectFactory);
 
        m_xobjectFactory = theXObjectFactory;
    }
 
 
    /**
     * Set the DOMSupport instance.
     *
     * @param theDOMSupport a reference to the instance to use.
     */
    void
    setXSLTProcessor(XSLTEngineImpl*    theProcessor)
    {
        m_xsltProcessor = theProcessor;
    }
 
    bool
    getUsePerInstanceDocumentFactory() const
    {
        return m_usePerInstanceDocumentFactory;
    }
 
    void
    setUsePerInstanceDocumentFactory(bool   fValue)
    {
        m_usePerInstanceDocumentFactory = fValue;
    }
 
 
    // These interfaces are inherited from StylesheetExecutionContext...
 
    virtual bool
    getQuietConflictWarnings() const;
 
    virtual bool
    getCopyTextNodesOnly() const;
 
    virtual void
    pushCopyTextNodesOnly(bool copyTextNodesOnly);
 
    virtual bool
    popCopyTextNodesOnly();
 
#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
    virtual void
    pushProcessCurrentAttribute(bool processAttribute);
 
    virtual bool
    popProcessCurrentAttribute();
 
    virtual void
    pushSkipElementAttributes(bool skipAttributes);
 
    virtual bool
    getSkipElementAttributes() const;
 
    virtual bool
    popSkipElementAttributes();
 
    virtual void
    pushExecuteIf(bool executeIf);
    
    virtual bool
    popExecuteIf();
#endif
 
    virtual XalanNode*
    getRootDocument() const;
 
    virtual void
    setRootDocument(XalanNode*  theDocument);
 
    virtual void
    setStylesheetRoot(const StylesheetRoot*     theStylesheet);
 
    virtual const XalanQName*
    getCurrentMode() const;
 
    virtual void
    pushCurrentMode(const XalanQName*   theMode);
    
    virtual void
    popCurrentMode();
 
    virtual const ElemTemplate*
    getCurrentTemplate() const;
 
    virtual void
    pushCurrentTemplate(const ElemTemplate* theTemplate);
 
    virtual void
    popCurrentTemplate();
 
    virtual bool
    isElementPending() const;
 
    virtual void
    replacePendingAttribute(
            const XalanDOMChar*     theName,
            const XalanDOMChar*     theNewType,
            const XalanDOMChar*     theNewValue);
 
    virtual void
    pushOutputContext(FormatterListener*    flistener = 0);
 
    virtual void
    popOutputContext();
 
    virtual void
    addResultAttribute(
            const XalanDOMString&   aname,
            const XalanDOMString&   value);
 
    virtual void
    addResultAttribute(
            const XalanDOMString&   aname,
            const XalanDOMChar*     value);
 
    virtual void
    copyNamespaceAttributes(const XalanNode&    src);
 
    virtual const XalanDOMString*
    getResultPrefixForNamespace(const XalanDOMString&   theNamespace) const;
 
    virtual const XalanDOMString*
    getResultNamespaceForPrefix(const XalanDOMString&   thePrefix) const;
 
    virtual bool
    isPendingResultPrefix(const XalanDOMString& thePrefix);
 
    virtual void
    getUniqueNamespaceValue(XalanDOMString&     theValue) const;
 
    virtual FormatterListener*
    getFormatterListener() const;
 
    virtual void
    setFormatterListener(FormatterListener*     flistener);
 
    virtual int
    getIndent() const;
 
    virtual void
    setIndent(int   indentAmount);
 
    virtual const XPath*
    createMatchPattern(
            const XalanDOMString&   str,
            const PrefixResolver&   resolver);
 
    virtual void
    returnXPath(const XPath*    xpath);
 
    virtual void
    pushTopLevelVariables(const ParamVectorType&    topLevelParams);
 
 
    virtual const XObjectPtr
    createVariable(
            const XPath&                xpath,
            XalanNode*                  contextNode,
            const PrefixResolver&       resolver);
 
#if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
    virtual const XObjectPtr
    createVariable(
            const ElemTemplateElement&  templateChild,
            XalanNode*                  sourceNode);
#endif
 
    virtual void
    pushVariable(
            const XalanQName&           name,
            const ElemTemplateElement*  element,
            const XalanDOMString&       str,
            XalanNode*                  contextNode,
            const PrefixResolver&       resolver);
 
    virtual void
    pushVariable(
            const XalanQName&           name,
            const XObjectPtr            val,
            const ElemTemplateElement*  element);
 
    virtual void
    pushVariable(
            const XalanQName&           name,
            const ElemVariable*         var,
            const ElemTemplateElement*  element);
 
    virtual void
    pushVariable(
            const XalanQName&           name,
            const ElemTemplateElement*  element,
            const XPath&                xpath,
            XalanNode*                  contextNode,
            const PrefixResolver&       resolver);
 
#if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
    virtual void
    pushVariable(
            const XalanQName&           name,
            const ElemTemplateElement*  element,
            const ElemTemplateElement&  templateChild,
            XalanNode*                  sourceNode);
#endif
 
 
    virtual void
    pushContextMarker();
 
    virtual void
    popContextMarker();
 
    virtual void
    resolveTopLevelParams();
 
    virtual void
    clearTopLevelParams();
 
#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
    virtual void beginParams();
 
    virtual void endParams();
 
    virtual void pushParam(const XalanQName& qName,const XObjectPtr& theValue);
#else
    virtual void
    pushParams(const ElemTemplateElement&   xslCallTemplateElement);
#endif
 
    virtual const XObjectPtr
    getParamVariable(const XalanQName&  theName);
 
    virtual void
    pushElementFrame(const ElemTemplateElement*     elem);
 
    virtual void
    popElementFrame();
 
    virtual int
    getGlobalStackFrameIndex() const;
 
    virtual int
    getCurrentStackFrameIndex() const;
 
    virtual void
    pushCurrentStackFrameIndex(int currentStackFrameIndex = -1);
 
    virtual void
    popCurrentStackFrameIndex();
 
    virtual void
    startDocument();
 
    virtual void
    endDocument();