Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

StylesheetRoot.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed 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_STYLESHEETROOT_HEADER_GUARD)
#define XALAN_STYLESHEETROOT_HEADER_GUARD 



// Base include file.  Must be first.
#include "XSLTDefinitions.hpp"



#include "Stylesheet.hpp"



#include <xalanc/Include/XalanMap.hpp>
#include <xalanc/Include/STLHelper.hpp>



#include <xalanc/XalanDOM/XalanDOMString.hpp>



#include <xalanc/PlatformSupport/FormatterListener.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class ElemAttributeSet;
class StylesheetConstructionContext;
class XalanText;
class XSLTResultTarget;


typedef XalanVector<ElemAttributeSet*>      AttributeSetVectorTypeDecl;
XALAN_USES_MEMORY_MANAGER(AttributeSetVectorTypeDecl)

class XALAN_XSLT_EXPORT StylesheetRoot : public Stylesheet
{
public:

    typedef XalanVector<const XalanQName*>      XalanQNameVectorType;

    typedef AttributeSetVectorTypeDecl          AttributeSetVectorType;

    typedef XalanMap<const XalanQName*,
                AttributeSetVectorType>         AttributeSetMapType;

    StylesheetRoot(
        const XalanDOMString&           baseIdentifier,
        StylesheetConstructionContext&  constructionContext);    

    virtual 
    ~StylesheetRoot();

    static StylesheetRoot*
    create(
        MemoryManagerType&              theManager,
        const XalanDOMString&           baseIdentifier,
        StylesheetConstructionContext&  constructionContext);

    MemoryManagerType&
    getMemoryManager()
    {
        return m_version.getMemoryManager();
    }
    virtual void
    postConstruction(StylesheetConstructionContext&     constructionContext);

    void
    process(
            XalanNode*                      sourceTree,
            XSLTResultTarget&               outputTarget,
            StylesheetExecutionContext&     executionContext) const;

    FormatterListener*
    setupFormatterListener(
            XSLTResultTarget&               outputTarget,
            StylesheetExecutionContext&     executionContext) const;

    FormatterListener::eFormat
    getOutputMethod() const
    {
        return m_outputMethod;
    }

    bool
    isOutputMethodSet() const
    {
        return getOutputMethod() == FormatterListener::OUTPUT_METHOD_NONE ? false : true;
    }

    XalanDOMString&
    getOutputVersion(XalanDOMString& theResult) const
    { 
        theResult.assign(m_version);
         
         return theResult;
    }

    bool 
    getOutputIndent() const
    {
        return m_indentResult == eIndentNoImplicit ||
               m_indentResult == eIndentNoExplicit ? false : true;
    }

    bool 
    getHTMLOutputIndent() const
    {
        return m_indentResult == eIndentNoExplicit ? false : true;
    }

    XalanDOMString& 
    getOutputEncoding(XalanDOMString& theResult) const
    {
        theResult.assign(m_encoding);
        
        return theResult;
    }

    XalanDOMString& 
    getOutputMediaType(XalanDOMString& theResult) const
    {
        theResult.assign(m_mediatype);
        
        return theResult;
    }

    XalanDOMString &
    getOutputDoctypeSystem(XalanDOMString& theResult) const
    {
        theResult.assign(m_doctypeSystem);
        
        return theResult;
    }

    XalanDOMString& 
    getOutputDoctypePublic(XalanDOMString& theResult) const
    {
        theResult.assign(m_doctypePublic);
        
        return theResult;
    }

    bool
    getOmitOutputXMLDecl() const
    {
        return m_omitxmlDecl;
    }

    XalanDOMString&
    getOutputStandalone(XalanDOMString& theResult) const
    {
        theResult.assign(m_standalone);
        
        return theResult;
    }

    ElemTemplateElement*
    getDefaultTextRule() const
    {
        return m_defaultTextRule;
    }

    ElemTemplateElement*
    getDefaultRule() const
    {
        return m_defaultRule;
    }

    ElemTemplateElement*
    getDefaultRootRule() const
    {
        return m_defaultRootRule;
    }

    void 
    processOutputSpec(
            const XalanDOMChar*             name, 
            const AttributeListType&        atts,
            StylesheetConstructionContext&  constructionContext);

    URLStackType&
    getImportStack()
    {
        return m_importStack;
    }

    const URLStackType&
    getImportStack() const
    {
        return m_importStack;
    }

    void
    setIndentResult(bool bIndent)
    {
        m_indentResult = bIndent == true ? eIndentYesExplicit : eIndentNoExplicit;
    }

    void
    setOutputMethod(FormatterListener::eFormat  meth)
    {
        m_outputMethod = meth;
    }

    bool
    hasCDATASectionElements() const
    {
        assert(m_hasCDATASectionElems == false && m_cdataSectionElems.empty() == true ||
               m_hasCDATASectionElems == true && m_cdataSectionElems.empty() == false);

        return m_hasCDATASectionElems;
    }

    bool
    isCDATASectionElementName(const XalanQName&     theQName) const;

    void
    getNodeSetByKey(
            XalanDocument*                  doc,
            const XalanQName&               qname,
            const XalanDOMString&           ref,
            const PrefixResolver&           resolver,
            MutableNodeRefList&             nodelist,
            StylesheetExecutionContext&     executionContext,
            KeyTablesTableType&             theKeysTable) const;

    unsigned long
    getNextElemNumberID()
    {
        return m_elemNumberNextID++;
    }

    unsigned long
    getElemNumberCount() const
    {
        return m_elemNumberNextID;
    }

    bool
    hasPreserveOrStripSpaceElements() const
    {
        return m_whitespaceElements.empty() == false;
    }

    bool
    shouldStripSourceNode(const XalanText&  textNode) const;

    void
    addAttributeSet(ElemAttributeSet&   theAttributeSet);
    
#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)

    const ElemAttributeSet*
    getAttributeSet(
            StylesheetExecutionContext&     theExecutionContext,
            const XalanQName&               theQName,
            size_type                       matchingIndex,
            const LocatorType*              theLocator) const;
#else
    void
    executeAttributeSet(
            StylesheetExecutionContext&     theExecutionContext,
            const XalanQName&               theQName,
            const LocatorType*              theLocator) const;
#endif


private:

    const XalanDOMString&
    getEncoding(const XSLTResultTarget&     outputTarget) const;

    void 
    initDefaultRule(StylesheetConstructionContext&  constructionContext);

    XalanDOMString  m_version;

    enum eIndentType { eIndentNoImplicit, eIndentNoExplicit, eIndentYesImplicit, eIndentYesExplicit };

    eIndentType     m_indentResult;

    XalanDOMString  m_encoding;

    XalanDOMString  m_mediatype;

    XalanDOMString  m_doctypeSystem;

    XalanDOMString  m_doctypePublic;

    bool            m_omitxmlDecl;

    XalanDOMString  m_standalone;

    XalanDOMString              m_resultNameSpaceURL;

    FormatterListener::eFormat  m_outputMethod;

    XalanQNameVectorType        m_cdataSectionElems;

    bool                        m_hasCDATASectionElems;

    URLStackType                m_importStack;


    ElemTemplateElement*        m_defaultTextRule;

    ElemTemplateElement*        m_defaultRule;

    ElemTemplateElement*        m_defaultRootRule;

    bool                        m_needToBuildKeysTable;

    bool                        m_outputEscapeURLs;

    int                         m_indentAmount;

    bool                        m_omitMETATag;

    unsigned long               m_elemNumberNextID;

    AttributeSetMapType         m_attributeSetsMap;


    // Not implemented...
    StylesheetRoot(const StylesheetRoot&);

    StylesheetRoot&
    operator=(const StylesheetRoot&);

    bool
    operator==(const StylesheetRoot&) const;
};



XALAN_CPP_NAMESPACE_END



#endif  // XALAN_STYLESHEETROOT_HEADER_GUARD

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.