/*
 * 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(STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680)
#define STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680


// Base include file.  Must be first.
#include <xalanc/XSLT/XSLTDefinitions.hpp>


#include <xalanc/Include/XalanVector.hpp>


#include <xalanc/PlatformSupport/ArenaAllocator.hpp>
#include <xalanc/PlatformSupport/XalanArrayAllocator.hpp>
#include <xalanc/PlatformSupport/XalanDOMStringPool.hpp>


#if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) || defined(XALAN_BUILD_DLL)
#include <xalanc/XPath/XPathProcessor.hpp>
#endif


#include <xalanc/Include/XalanMemMgrAutoPtr.hpp>


#include <xalanc/PlatformSupport/XalanDOMStringCache.hpp>


#include <xalanc/XPath/XalanQNameByReference.hpp>
#include <xalanc/XPath/XalanQNameByValue.hpp>
#include <xalanc/XPath/XalanQNameByValueAllocator.hpp>


// Base class header file...
#include <xalanc/XSLT/StylesheetConstructionContext.hpp>


#include <xalanc/XSLT/AVT.hpp>
#include <xalanc/XSLT/XalanAVTAllocator.hpp>
#include <xalanc/XSLT/AVTPartSimple.hpp>
#include <xalanc/XSLT/XalanAVTPartSimpleAllocator.hpp>
#include <xalanc/XSLT/AVTPartXPath.hpp>
#include <xalanc/XSLT/XalanAVTPartXPathAllocator.hpp>
#include <xalanc/XSLT/XalanElemApplyTemplatesAllocator.hpp>
#include <xalanc/XSLT/XalanElemAttributeAllocator.hpp>
#include <xalanc/XSLT/XalanElemAttributeSetAllocator.hpp>
#include <xalanc/XSLT/XalanElemCallTemplateAllocator.hpp>
#include <xalanc/XSLT/XalanElemElementAllocator.hpp>
#include <xalanc/XSLT/XalanElemLiteralResultAllocator.hpp>
#include <xalanc/XSLT/XalanElemTemplateAllocator.hpp>
#include <xalanc/XSLT/XalanElemTextLiteralAllocator.hpp>
#include <xalanc/XSLT/XalanElemValueOfAllocator.hpp>
#include <xalanc/XSLT/XalanElemVariableAllocator.hpp>
#include "xalanc/XSLT/XalanMatchPatternDataAllocator.hpp"


namespace XALAN_CPP_NAMESPACE {


class XPathEnvSupport;
class XPathFactory;
class XPathProcessor;
class XSLTEngineImpl;


/**
 *
 * An default implementation of an abtract class which provides support for
 * constructing the internal representation  of a stylesheet.
 *
 */
class XALAN_XSLT_EXPORT StylesheetConstructionContextDefault : public StylesheetConstructionContext
{
public:

    typedef XalanArrayAllocator<XalanDOMChar>           XalanDOMCharVectorAllocatorType;
    typedef XalanArrayAllocator<const void*>            PointerVectorAllocatorType;
    typedef XalanDOMCharVectorAllocatorType::size_type  VectorAllocatorSizeType;

    // Default size for vector allocation.
    enum {
            eDefaultXalanDOMCharVectorBlockSize = 1024,
            eDefaultAVTBlockSize = 128,
            eDefaultAVTPartSimpleBlockSize = 128,
            eDefaultAVTPartXPathBlockSize = 128,
            eDefaultXalanQNameByValueBlockSize = 32,
            eDefaultPointerVectorBlockSize = 512,
            eDefaultElemApplyTemplatesBlockSize = 10,
            eDefaultElemAttributeBlockSize = 10,
            eDefaultElemAttributeSetBlockSize = 10,
            eDefaultElemCallTemplateBlockSize = 10,
            eDefaultElemElementBlockSize = 10,
            eDefaultElemLiteralResultBlockSize = 20,
            eDefaultElemTemplateBlockSize = 10,
            eDefaultElemTextLiteralBlockSize = 20,
            eDefaultElemValueOfBlockSize = 10,
            eDefaultElemVariableBlockSize = 10,
            eDefaultMatchPatternDataBlockSize = 10 };

    /*
     * Construct an instance.  If the stylesheet(s) constructed is/are meant to be reused (a.k.a. "compiled"),
     * the XObjectFactory and XPathFactory instance must exist for the lifetime of the construction context
     * and, therefore, for the lifetime of the stylesheet(s).  Otherwise, XObject and XPath instance will be
     * destroyed when the corresponding factories are destryed, leaving pointers to destroyed objects in the.
     * stylesheet(s).
     *
     * @param processor a reference to an XSLTEngineImpl instance.  Used for error reporting.
     * @param xpathFactory a reference to an XPathFactory instance.  See comments above for important details.
     * @param theXalanDOMCharVectorAllocatorBlockSize The block size to use for allocating vectors of XalanDOMChars
     * @param theAVTAllocatorBlockSize The block size to use for allocating AVT instances.
     * @param theAVTPartSimpleAllocatorBlockSize The block size to use for allocating AVTPartSimple instances.
     * @param theAVTPartXPathAllocatorBlockSize The block size to use for allocating AVTPartXPath instances.
     * @param theXalanQNameByValueAllocatorBlockSize The block size to use for allocating XalanQNameByValue instances.
     * @param thePointerVectorAllocatorBlockSize The block size to use for allocating vectors of pointers.
     */
    StylesheetConstructionContextDefault(
            MemoryManager&                      theManager,
            XSLTEngineImpl&                         processor,
            XPathFactory&                           xpathFactory,
            VectorAllocatorSizeType                 theXalanDOMCharVectorAllocatorBlockSize = eDefaultXalanDOMCharVectorBlockSize,
            XalanAVTAllocator::size_type            theAVTAllocatorBlockSize = eDefaultAVTBlockSize,
            XalanAVTPartSimpleAllocator::size_type  theAVTPartSimpleAllocatorBlockSize = eDefaultAVTPartSimpleBlockSize,
            XalanAVTPartXPathAllocator::size_type   theAVTPartXPathAllocatorBlockSize = eDefaultAVTPartXPathBlockSize,
            XalanQNameByValueAllocator::size_type   theXalanQNameByValueAllocatorBlockSize = eDefaultXalanQNameByValueBlockSize,
            VectorAllocatorSizeType                 thePointerVectorAllocatorBlockSize = eDefaultPointerVectorBlockSize);

    virtual
    ~StylesheetConstructionContextDefault();


    // These interfaces are inherited from StylesheetConstructionContext...

    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
    reset();

    virtual const XalanDOMString&
    getPooledString(const XalanDOMString&   theString);

    virtual const XalanDOMString&
    getPooledString(
            const XalanDOMChar*         theString,
            XalanDOMString::size_type   theLength = XalanDOMString::npos);

    virtual XalanDOMString&
    getCachedString();

    virtual bool
    releaseCachedString(XalanDOMString&     theString);

    virtual StylesheetRoot*
    create(const XalanDOMString&    theBaseIdentifier);

    virtual StylesheetRoot*
    create(const XSLTInputSource&   theInputSource);

    virtual Stylesheet*
    create(
            StylesheetRoot&         theStylesheetRoot,
            const XalanDOMString&   theBaseIdentifier);

    virtual void
    destroy(StylesheetRoot*     theStylesheetRoot);

    virtual URLAutoPtrType
    getURLFromString(const XalanDOMString&  urlString);

    virtual XalanDOMString&
    getURLStringFromString(
            const XalanDOMString&   urlString,
            XalanDOMString&         theResult);

    virtual URLAutoPtrType
    getURLFromString(
            const XalanDOMString&   urlString,
            const XalanDOMString&   base);

    virtual XalanDOMString&
    getURLStringFromString(
            const XalanDOMString&   urlString,
            const XalanDOMString&   base,
            XalanDOMString& theResult);

    virtual const XalanDOMString&
    getXSLTNamespaceURI() const;

    virtual XPath*
    createMatchPattern(
            const Locator*          locator,
            const XalanDOMString&   str,
            const PrefixResolver&   resolver,
            bool                    allowVariableReferences = true,
            bool                    allowKeyFunction = true);

    virtual XPath*
    createMatchPattern(
            const Locator*          locator,
            const XalanDOMChar*     str,
            const PrefixResolver&   resolver,
            bool                    allowVariableReferences = true,
            bool                    allowKeyFunction = true);

    virtual XPath*
    createXPath(
            const Locator*          locator,
            const XalanDOMString&   str,
            const PrefixResolver&   resolver,
            bool                    allowVariableReferences = true,
            bool                    allowKeyFunction = true);

    virtual XPath*
    createXPath(
            const Locator*          locator,
            const XalanDOMChar*     str,
            const PrefixResolver&   resolver,
            bool                    allowVariableReferences = true,
            bool                    allowKeyFunction = true);

    virtual XPath*
    createXPath(
            const Locator*              locator,
            const XalanDOMChar*         str,
            XalanDOMString::size_type   len,
            const PrefixResolver&       resolver,
            bool                        allowVariableReferences = true,
            bool                        allowKeyFunction = true);

    virtual const Locator*
    getLocatorFromStack() const;

    virtual void
    pushLocatorOnStack(const Locator*   locator);

    virtual void
    popLocatorStack();

    virtual const XalanDOMString&
    getXalanXSLNameSpaceURL() const;

    virtual XalanDocument*
    parseXML(
            const XalanDOMString&   urlString,
            DocumentHandler*        docHandler, 
            XalanDocument*          docToRegister,
            ErrorHandler*           theErrorHandler = 0);

    virtual bool
    isXMLSpaceAttribute(
            const XalanDOMChar*     theAttributeName,
            const Stylesheet&       theStylesheet,
            const Locator*          theLocator = 0);

    virtual bool
    isXSLUseAttributeSetsAttribute(
            const XalanDOMChar*     theAttributeName,
            const Stylesheet&       theStylesheet,
            const Locator*          theLocator = 0);

    virtual bool
    isValidQName(
            const XalanDOMChar*     theName,
            const Stylesheet&       theStylesheet,
            const Locator*          theLocator = 0);

    virtual eElementToken
    getElementToken(const XalanDOMString&   name) const;

    virtual double
    getXSLTVersionSupported() const;

    virtual XalanDOMChar*
    allocateXalanDOMCharVector(XalanDOMString::size_type    theLength);

    virtual XalanDOMChar*
    allocateXalanDOMCharVector(
            const XalanDOMChar*         theString,
            XalanDOMString::size_type   theLength = XalanDOMString::npos,
            bool                        fTerminate = true);

    virtual const AVT*
    createAVT(
            const Locator*          locator,
            const XalanDOMChar*     name,
            const XalanDOMChar*     stringedValue,
            const PrefixResolver&   resolver);

    virtual const AVTPart*
    createAVTPart(
            const XalanDOMChar*         theString,
            XalanDOMString::size_type   theLength = XalanDOMString::npos);

    virtual const AVTPart*
    createAVTPart(
            const Locator*              locator,
            const XalanDOMChar*         str,
            XalanDOMString::size_type   len,
            const PrefixResolver&       resolver);

    virtual const AVT**
    allocateAVTPointerVector(size_type  theLength);

    virtual const AVTPart**
    allocateAVTPartPointerVector(size_type  theLength);

    virtual const XalanQName*
    createXalanQName(
            const XalanDOMString&       qname,
            const NamespacesStackType&  namespaces,
            const Locator*              locator = 0,
            bool                        fUseDefault = false);

    virtual const XalanQName*
    createXalanQName(
            const XalanDOMChar*         qname,
            const NamespacesStackType&  namespaces,
            const Locator*              locator = 0,
            bool                        fUseDefault = false);

    virtual const XalanQName**
    tokenizeQNames(
            size_type&                  count,
            const XalanDOMChar*         qnameTokens,
            const NamespacesStackType&  namespaces,
            const Locator*              locator = 0,
            bool                        fUseDefault = false);

    virtual ElemTemplateElement*
    createElement(
            int                         token,
            Stylesheet&                 stylesheetTree,
            const AttributeListType&    atts,
            const Locator*              locator = 0);

    virtual ElemTemplateElement*
    createElement(
            int                         token,
            Stylesheet&                 stylesheetTree,
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            const Locator*              locator = 0);

    virtual ElemTemplateElement*
    createElement(
            Stylesheet&                 stylesheetTree,
            const XalanDOMChar*         chars,
            XalanDOMString::size_type   length,
            bool                        preserveSpace,
            bool                        disableOutputEscaping,
            const Locator*              locator = 0);

    virtual ElemTemplateElement*
    createElement(
            Stylesheet&                 stylesheetTree,
            const XalanDOMChar*         name,
            const AttributeListType&    atts,
            ExtensionNSHandler&         handler,
            const Locator*              locator = 0);

    virtual const XalanMatchPatternData*
    createXalanMatchPatternData(
            const ElemTemplate&     theTemplate,
            size_type               thePosition,
            const XalanDOMString&   theTargetString,
            const XPath&            theMatchPattern,
            const XalanDOMString&   thePatternString,
            XPath::eMatchScore      thePriority);

    static eElementToken
    getElementNameToken(const XalanDOMString&   name);

    typedef XalanVector<StylesheetRoot*>            StylesheetVectorType;
    typedef XalanVector<ElemTemplateElement*>   ElemTemplateElementVectorType;

private:

    const AVT**
    doAllocateAVTPointerVector(size_type    theSize)
    {
        assert(sizeof(AVT**) == sizeof(PointerVectorAllocatorType::value_type));

        return reinterpret_cast<const AVT**>(m_pointerVectorAllocator.allocate(theSize));
    }

    const AVTPart**
    doAllocateAVTPartPointerVector(size_type    theSize)
    {
        assert(sizeof(AVTPart**) == sizeof(PointerVectorAllocatorType::value_type));

        return reinterpret_cast<const AVTPart**>(m_pointerVectorAllocator.allocate(theSize));
    }

    const XalanQName**
    doAllocateXalanQNamePointerVector(size_type theSize)
    {
        assert(sizeof(XalanQName**) == sizeof(PointerVectorAllocatorType::value_type));

        return reinterpret_cast<const XalanQName**>(m_pointerVectorAllocator.allocate(theSize));
    }


    XSLTEngineImpl&                         m_processor;

    XPathFactory&                           m_xpathFactory;

    typedef XalanMemMgrAutoPtr<XPathProcessor>  XPathProcessAutoPtr;

    XPathProcessAutoPtr                     m_xpathProcessor;

    StylesheetVectorType                    m_stylesheets;

    XalanDOMStringPool                      m_stringPool;

    XalanDOMCharVectorAllocatorType         m_xalanDOMCharVectorAllocator;

    mutable XalanDOMString                  m_tempBuffer;

    XalanQNameByValue                       m_scratchQName;

    XalanDOMStringCache                     m_stringCache;

    XalanAVTAllocator                       m_avtAllocator;

    XalanAVTPartSimpleAllocator             m_avtPartSimpleAllocator;

    XalanAVTPartXPathAllocator              m_avtPartXPathAllocator;

    XalanQNameByValueAllocator              m_xalanQNameByValueAllocator;

    const XalanQNameByReference             m_useAttributeSetsQName;

    PointerVectorAllocatorType              m_pointerVectorAllocator;

    ElemTemplateElementVectorType           m_allocatedElements;

    XalanElemApplyTemplatesAllocator        m_elemApplyTemplatesAllocator;

    XalanElemAttributeAllocator             m_elemAttributeAllocator;

    XalanElemAttributeSetAllocator          m_elemAttributeSetAllocator;

    XalanElemCallTemplateAllocator          m_elemCallTemplateAllocator;

    XalanElemElementAllocator               m_elemElementAllocator;

    XalanElemLiteralResultAllocator         m_elemLiteralResultAllocator;

    XalanElemTemplateAllocator              m_elemTemplateAllocator;

    XalanElemTextLiteralAllocator           m_elemTextLiteralAllocator;

    XalanElemValueOfAllocator               m_elemValueOfAllocator;

    XalanElemVariableAllocator              m_elemVariableAllocator;

    XalanMatchPatternDataAllocator          m_matchPatternDataAllocator;

    const XalanQNameByReference             m_spaceAttrQName;

    // Static strings for stylesheet compilation...

    // The string "if"
    static const XalanDOMChar   s_if[];

    // The string "key"
    static const XalanDOMChar   s_key[];

    // The string "copy"
    static const XalanDOMChar   s_copy[];

    // The string "sort"
    static const XalanDOMChar   s_sort[];

    // The string "text"
    static const XalanDOMChar   s_text[];

    // The string "when"
    static const XalanDOMChar   s_when[];

    // The string "empty"
    static const XalanDOMChar   s_empty[];

    // The string "param"
    static const XalanDOMChar   s_param[];

    // The string "choose"
    static const XalanDOMChar   s_choose[];

    // The string "import"
    static const XalanDOMChar   s_import[];

    // The string "number"
    static const XalanDOMChar   s_number[];

    // The string "output"
    static const XalanDOMChar   s_output[];

    // The string "comment"
    static const XalanDOMChar   s_comment[];

    // The string "copy-of"
    static const XalanDOMChar   s_copyOf[];

    // The string "element"
    static const XalanDOMChar   s_element[];

    // The string "include"
    static const XalanDOMChar   s_include[];

    // The string "message"
    static const XalanDOMChar   s_message[];

    // The string "fallback"
    static const XalanDOMChar   s_fallback[];

    // The string "for-each"
    static const XalanDOMChar   s_forEach[];

    // The string "template"
    static const XalanDOMChar   s_template[];

    // The string "value-of"
    static const XalanDOMChar   s_valueOf[];

    // The string "variable"
    static const XalanDOMChar   s_variable[];

    // The string "attribute"
    static const XalanDOMChar   s_attribute[];

    // The string "otherwise"
    static const XalanDOMChar   s_otherwise[];

    // The string "transform"
    static const XalanDOMChar   s_transform[];

    // The string "stylesheet"
    static const XalanDOMChar   s_stylesheet[];

    // The string "with-param"
    static const XalanDOMChar   s_withParam[];

    // The string "strip-space"
    static const XalanDOMChar   s_stripSpace[];

    // The string "apply-imports"
    static const XalanDOMChar   s_applyImports[];

    // The string "attribute-set"
    static const XalanDOMChar   s_attributeSet[];

    // The string "call-template"
    static const XalanDOMChar   s_callTemplate[];

    // The string "decimal-format"
    static const XalanDOMChar   s_decimalFormat[];

    // The string "preserve-space"
    static const XalanDOMChar   s_preserveSpace[];

    // The string "apply-templates"
    static const XalanDOMChar   s_applyTemplates[];

    // The string "namespace-alias"
    static const XalanDOMChar   s_namespaceAlias[];

    // The string "processing-instruction"
    static const XalanDOMChar   s_processingInstruction[];

    // A struct for an array that maps stylesheet element names
    // to int tokens.
    struct ElementTokenTableEntry
    {
        const XalanDOMChar*     m_name;

        eElementToken           m_token;
    };

    static const ElementTokenTableEntry     s_elementTokenTable[];

    static const XalanSize_t                s_elementTokenTableSize;

    static const ElementTokenTableEntry&    s_elementTokenTableLast;

    static const ElementTokenTableEntry&    s_elementTokenTableDummy;
};


}


#endif  // STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680