Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.5

Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

Stylesheet.hpp

Go to the documentation of this file.
00001 /*
00002  * The Apache Software License, Version 1.1
00003  *
00004  *
00005  * Copyright (c) 1999-2003 The Apache Software Foundation.  All rights 
00006  * reserved.
00007  *
00008  * Redistribution and use in source and binary forms, with or without
00009  * modification, are permitted provided that the following conditions
00010  * are met:
00011  *
00012  * 1. Redistributions of source code must retain the above copyright
00013  *    notice, this list of conditions and the following disclaimer. 
00014  *
00015  * 2. Redistributions in binary form must reproduce the above copyright
00016  *    notice, this list of conditions and the following disclaimer in
00017  *    the documentation and/or other materials provided with the
00018  *    distribution.
00019  *
00020  * 3. The end-user documentation included with the redistribution,
00021  *    if any, must include the following acknowledgment:  
00022  *       "This product includes software developed by the
00023  *        Apache Software Foundation (http://www.apache.org/)."
00024  *    Alternately, this acknowledgment may appear in the software itself,
00025  *    if and wherever such third-party acknowledgments normally appear.
00026  *
00027  * 4. The names "Xalan" and "Apache Software Foundation" must
00028  *    not be used to endorse or promote products derived from this
00029  *    software without prior written permission. For written 
00030  *    permission, please contact apache@apache.org.
00031  *
00032  * 5. Products derived from this software may not be called "Apache",
00033  *    nor may "Apache" appear in their name, without prior written
00034  *    permission of the Apache Software Foundation.
00035  *
00036  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
00037  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
00038  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00039  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
00040  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00041  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00042  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
00043  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
00044  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00045  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
00046  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00047  * SUCH DAMAGE.
00048  * ====================================================================
00049  *
00050  * This software consists of voluntary contributions made by many
00051  * individuals on behalf of the Apache Software Foundation and was
00052  * originally based on software copyright (c) 1999, International
00053  * Business Machines, Inc., http://www.ibm.com.  For more
00054  * information on the Apache Software Foundation, please see
00055  * <http://www.apache.org/>.
00056  *
00057  * $ Id: $
00058  *
00059  */
00060 
00061 #if !defined(XALAN_STYLESHEET_HEADER_GUARD)
00062 #define XALAN_STYLESHEET_HEADER_GUARD
00063 
00064 
00065 
00066 // Base include file.  Must be first.
00067 #include "XSLTDefinitions.hpp"
00068 
00069 
00070 
00071 #include <deque>
00072 #include <map>
00073 #include <vector>
00074 
00075 
00076 
00077 #include <XalanDOM/XalanDocument.hpp>
00078 #include <XalanDOM/XalanEmptyNamedNodeMap.hpp>
00079 #include <XalanDOM/XalanNodeListSurrogate.hpp>
00080 
00081 
00082 #include <PlatformSupport/PrefixResolver.hpp>
00083 
00084 
00085 
00086 #include <XPath/NameSpace.hpp>
00087 #include <XPath/XalanQNameByReference.hpp>
00088 #include <XPath/XPath.hpp>
00089 
00090 
00091 
00092 #include <XSLT/NamespacesHandler.hpp>
00093 #include <XSLT/KeyDeclaration.hpp>
00094 #include <XSLT/StylesheetExecutionContext.hpp>
00095 
00096 
00097 
00098 XALAN_CPP_NAMESPACE_BEGIN
00099 
00100 
00101 
00102 class ExtensionNSHandler;
00103 class XalanDecimalFormatSymbols;
00104 class ElemAttributeSet;
00105 class ElemDecimalFormat;
00106 class ElemTemplate;
00107 class ElemTemplateElement;
00108 class ElemVariable;
00109 class KeyTable;
00110 class NodeRefListBase;
00111 class PrefixResolver;
00112 class StylesheetConstructionContext;
00113 class StylesheetRoot;
00114 class XalanQName;
00115 class XObject;
00116 class StylesheetExecutionContext;
00117 
00118 
00119 
00124 class XALAN_XSLT_EXPORT Stylesheet : public XalanDocument, protected PrefixResolver
00125 {   
00126 
00127 public:
00128 
00129 #if defined(XALAN_STRICT_ANSI_HEADERS)
00130     typedef std::size_t     size_type;
00131 #else
00132     typedef size_t          size_type;
00133 #endif
00134 
00135     typedef StylesheetExecutionContext::ParamVectorType     ParamVectorType;
00136     typedef XalanQName::NamespaceVectorType                 NamespaceVectorType;
00137     typedef XalanQName::NamespacesStackType                 NamespacesStackType;
00138 
00139 #if defined(XALAN_NO_STD_NAMESPACE)
00140     typedef map<XalanDOMString,
00141                 ExtensionNSHandler*,
00142                 less<XalanDOMString> >              ExtensionNamespacesMapType;
00143     typedef map<XalanQNameByReference,
00144                 const ElemTemplate*,
00145                 less<XalanQName> >                  ElemTemplateMapType;
00146     typedef vector<ElemAttributeSet*>               AttributeSetVectorType;
00147     typedef vector<ElemVariable*>                   ElemVariableVectorType;
00148     typedef vector<KeyDeclaration>                  KeyDeclarationVectorType;
00149     typedef map<const XalanNode*,
00150                 KeyTable*,
00151                 less<const XalanNode*> >            KeyTablesTableType;
00152     typedef vector<Stylesheet*>                     StylesheetVectorType;
00153     typedef vector<XalanDOMString>                  URLStackType;
00154     typedef vector<ElemDecimalFormat*>              ElemDecimalFormatVectorType;
00155 #else
00156     typedef std::map<XalanDOMString, ExtensionNSHandler*>   ExtensionNamespacesMapType;
00157     typedef std::map<XalanQNameByReference,
00158                      const ElemTemplate*,
00159                      std::less<XalanQName> >                ElemTemplateMapType;
00160     typedef std::vector<ElemAttributeSet*>                  AttributeSetVectorType;
00161     typedef std::vector<ElemVariable*>                      ElemVariableVectorType;
00162     typedef std::vector<KeyDeclaration>                     KeyDeclarationVectorType;
00163     typedef std::map<const XalanNode*, KeyTable*>           KeyTablesTableType;
00164     typedef std::vector<Stylesheet*>                        StylesheetVectorType;
00165     typedef std::vector<XalanDOMString>                     URLStackType;
00166     typedef std::vector<ElemDecimalFormat*>                 ElemDecimalFormatVectorType;
00167 #endif
00168 
00174     Stylesheet(
00175             StylesheetRoot&                 root,
00176             const XalanDOMString&           baseIdentifier,
00177             StylesheetConstructionContext&  constructionContext);
00178 
00179     virtual
00180     ~Stylesheet();
00181 
00187     double
00188     getXSLTVerDeclared() const
00189     {
00190         return m_XSLTVerDeclared;
00191     }
00192 
00198     void
00199     setXSLTVerDeclared(double ver)
00200     {
00201         m_XSLTVerDeclared = ver;
00202     }
00203 
00209     const StylesheetRoot&
00210     getStylesheetRoot() const
00211     {
00212         return m_stylesheetRoot;
00213     }
00214 
00220     StylesheetRoot&
00221     getStylesheetRoot()
00222     {
00223         return m_stylesheetRoot;
00224     }
00225 
00231     const NamespacesStackType&
00232     getNamespaces() const
00233     { 
00234         return m_namespaces;
00235     }
00236 
00242     NamespacesStackType&
00243     getNamespaces()
00244     { 
00245         return m_namespaces;
00246     }
00247 
00248     const NamespacesHandler&
00249     getNamespacesHandler() const
00250     {
00251         return m_namespacesHandler;
00252     }
00253 
00254     NamespacesHandler&
00255     getNamespacesHandler()
00256     {
00257         return m_namespacesHandler;
00258     }
00259 
00265     const NamespaceVectorType&
00266     getNamespaceDecls() const
00267     {
00268         return m_namespaceDecls;
00269     }
00270 
00276     NamespaceVectorType&
00277     getNamespaceDecls()
00278     {
00279         return m_namespaceDecls;
00280     }
00281 
00287     void
00288     setNamespaceDecls(const NamespaceVectorType& ns)
00289     {
00290         m_namespaceDecls = ns;
00291     }
00292 
00299     void
00300     pushNamespaces(const AttributeListType&     atts);
00301 
00305     void
00306     popNamespaces()
00307     {
00308         assert(m_namespaces.empty() == false);
00309 
00310         m_namespaces.pop_back(); 
00311     }
00312 
00316     virtual void
00317     postConstruction(StylesheetConstructionContext&     constructionContext);
00318 
00328     bool
00329     isAttrOK(
00330             const XalanDOMChar*             attrName,
00331             const AttributeListType&        atts,
00332             int                             which,
00333             StylesheetConstructionContext&  constructionContext) const;
00334 
00341     const XalanDOMString*
00342     getNamespaceFromStack(const XalanDOMString&     nodeName) const
00343     {
00344         return getNamespaceFromStack(c_wstr(nodeName));
00345     }
00346 
00353     const XalanDOMString*
00354     getNamespaceFromStack(const XalanDOMChar*   nodeName) const;
00355 
00363     const XalanDOMString*
00364     getNamespaceForPrefixFromStack(const XalanDOMString&    prefix) const
00365     {
00366         return XalanQName::getNamespaceForPrefix(m_namespaces, prefix);
00367     }
00368 
00376     const XalanDOMString*
00377     getNamespaceForPrefixFromStack(const XalanDOMChar*  prefix) const
00378     {
00379         assert(prefix != 0);
00380 
00381         return XalanQName::getNamespaceForPrefix(m_namespaces, XalanDOMString(prefix));
00382     }
00383 
00391     void
00392     processExcludeResultPrefixes(
00393         StylesheetConstructionContext&  theConstructionContext,
00394         const XalanDOMChar*             theValue)
00395     {
00396         m_namespacesHandler.processExcludeResultPrefixes(
00397                 theConstructionContext,
00398                 theValue,
00399                 m_namespaces);
00400     }
00401 
00408     void
00409     addTemplate(
00410             ElemTemplate*                   theTemplate,
00411             StylesheetConstructionContext&  constructionContext);
00412 
00421     bool
00422     getYesOrNo(
00423             const XalanDOMChar*             aname,
00424             const XalanDOMChar*             val,
00425             StylesheetConstructionContext&  constructionContext) const;
00426 
00432     bool
00433     isRoot() const
00434     {
00435         return m_isRoot;
00436     }
00437 
00443     const XalanDOMString&
00444     getBaseIdentifier() const
00445     {
00446         return m_baseIdent;
00447     }
00448 
00454     void
00455     setBaseIdentifier(const XalanDOMString&     str)
00456     {
00457         m_baseIdent = str;
00458     }
00459 
00468     const XalanDOMString&
00469     getCurrentIncludeBaseIdentifier() const
00470     {
00471         return m_includeStack.empty() == true ? getBaseIdentifier() : m_includeStack.back();
00472     }
00473 
00481     void
00482     processNSAliasElement(
00483             const XalanDOMChar*             name,
00484             const AttributeListType&        atts,
00485             StylesheetConstructionContext&  constructionContext);
00486 
00492     void
00493     processDecimalFormatElement(
00494             StylesheetConstructionContext&  constructionContext,
00495             const AttributeListType&        atts,
00496             const LocatorType*              locator = 0);
00497 
00505     const XalanDecimalFormatSymbols*
00506     getDecimalFormatSymbols(const XalanQName&   theQName) const;
00507 
00513     void
00514     addAttributeSet(ElemAttributeSet*   attrSet)
00515     {
00516         assert(attrSet != 0);
00517 
00518         m_attributeSets.push_back(attrSet);
00519     }
00520 
00530     void
00531     applyAttrSets(
00532             const XalanQName**              attributeSetsNames,
00533             size_type                       attributeSetsNamesCount,
00534             StylesheetExecutionContext&     executionContext,
00535             XalanNode*                      sourceNode) const;
00536 
00542     void
00543     addImport(Stylesheet*   theStylesheet)
00544     {
00545         m_imports.insert(m_imports.begin(), theStylesheet);
00546     }
00547 
00553     bool
00554     isWrapperless() const
00555     {
00556         return m_isWrapperless;
00557     }
00558 
00559     ElemTemplateElement*
00560     initWrapperless(
00561             StylesheetConstructionContext&  constructionContext,
00562             const LocatorType*              locator);
00563 
00569     URLStackType&
00570     getIncludeStack()
00571     {
00572         return m_includeStack;
00573     }
00574 
00583     void
00584     processKeyElement(
00585             const PrefixResolver&           nsContext,
00586             const AttributeListType&        atts,
00587             const LocatorType*              locator,
00588             StylesheetConstructionContext&  constructionContext);
00589 
00596     const ElemTemplate*
00597     findNamedTemplate(const XalanQName&     qname) const;
00598 
00607     const ElemTemplate*
00608     findTemplate(
00609             StylesheetExecutionContext&     executionContext,
00610             XalanNode*                      targetNode) const
00611     {
00612         assert(targetNode != 0);
00613 
00614         return findTemplate(
00615                 executionContext,
00616                 targetNode,
00617                 targetNode->getNodeType(),
00618                 s_emptyQName,
00619                 false);
00620     }
00621 
00633     const ElemTemplate*
00634     findTemplate(
00635             StylesheetExecutionContext&     executionContext,
00636             XalanNode*                      targetNode,
00637             XalanNode::NodeType             targetNodeType,
00638             const XalanQName&               mode,
00639             bool                            onlyUseImports) const;
00640 
00645     class MatchPattern2
00646     {
00647     public:
00648 
00649         typedef XPath::eMatchScore  eMatchScore;
00650 
00661         MatchPattern2(
00662                 const ElemTemplate&     theTemplate,
00663                 size_type               posInStylesheet,
00664                 const XalanDOMString&   targetString,
00665                 const XPath&            matchPattern,
00666                 const XalanDOMString&   pattern,
00667                 eMatchScore             priority) :
00668             m_template(&theTemplate),
00669             m_posInStylesheet(posInStylesheet),
00670             m_targetString(targetString),
00671             m_matchPattern(&matchPattern),
00672             m_pattern(&pattern),
00673             m_priority(priority)
00674         {
00675         }
00676 
00677         MatchPattern2() :
00678             m_template(0),
00679             m_posInStylesheet(0),
00680             m_targetString(),
00681             m_matchPattern(0),
00682             m_pattern(0),
00683             m_priority(XPath::eMatchScoreNone)
00684         {
00685         }
00686 
00687         ~MatchPattern2()
00688         {
00689         }
00690 
00696         const XalanDOMString&
00697         getTargetString() const
00698         {
00699             return m_targetString;
00700         }
00701 
00707         const XPath*
00708         getExpression() const
00709         {
00710             return m_matchPattern;
00711         }
00712 
00718         size_type
00719         getPositionInStylesheet() const
00720         {
00721             return m_posInStylesheet;
00722         }
00723 
00729         const XalanDOMString*
00730         getPattern() const
00731         {
00732             return m_pattern;
00733         }
00734 
00740         const ElemTemplate*
00741         getTemplate() const
00742         {
00743             return m_template;
00744         }
00745 
00746         eMatchScore
00747         getDefaultPriority() const
00748         {
00749             return m_priority;
00750         }
00751 
00752         double
00753         getPriorityOrDefault() const;
00754 
00755     private:
00756 
00757         const ElemTemplate*     m_template;
00758         size_type               m_posInStylesheet;
00759         XalanDOMString          m_targetString;
00760         const XPath*            m_matchPattern;
00761         const XalanDOMString*   m_pattern;
00762         eMatchScore             m_priority;
00763     };
00764 
00765 #if defined(XALAN_NO_STD_NAMESPACE)
00766     typedef vector<const MatchPattern2*>        PatternTableVectorType;
00767 
00768     typedef map<XalanDOMString,
00769                 PatternTableVectorType,
00770                 less<XalanDOMString> >          PatternTableMapType;
00771 
00772     typedef deque<MatchPattern2>                MatchPattern2Container;
00773 #else
00774     typedef std::vector<const MatchPattern2*>   PatternTableVectorType;
00775 
00776     typedef std::map<XalanDOMString,
00777                      PatternTableVectorType>    PatternTableMapType;
00778 
00779     typedef std::deque<MatchPattern2>           MatchPattern2Container;
00780 #endif
00781 
00788     static void
00789     addObjectIfNotFound(
00790             const MatchPattern2*        thePattern,
00791             PatternTableVectorType&     theVector);
00792 
00802     static void
00803     addObjectIfNotFound(
00804             const MatchPattern2*    thePattern,
00805             const MatchPattern2*    theArray[],
00806             unsigned int&           theArraySize);
00807 
00815     const PatternTableVectorType*
00816     locateElementMatchPatternList2(const XalanDOMString&    theName) const;
00817 
00825     const PatternTableVectorType*
00826     locateAttributeMatchPatternList2(const XalanDOMString&  theName) const;
00827 
00834     const PatternTableVectorType*
00835     locateMatchPatternList2(
00836             const XalanNode&        theNode,
00837             XalanNode::NodeType     targetNodeType) const;
00838 
00847     void
00848     processExtensionNamespace(
00849             StylesheetConstructionContext&  theConstructionContext,
00850             const XalanDOMString&           uri);
00851 
00858     ExtensionNSHandler*
00859     lookupExtensionNSHandler(const XalanDOMString&  uri) const
00860     {
00861         const ExtensionNamespacesMapType::const_iterator    it = 
00862           m_extensionNamespaces.find(uri);
00863 
00864         return it == m_extensionNamespaces.end() ? 0 : (*it).second;
00865     }
00866 
00873     void
00874     setTopLevelVariable(ElemVariable*   var)
00875     {
00876         m_topLevelVariables.push_back(var);
00877     }
00878 
00886     void
00887     pushTopLevelVariables(
00888             StylesheetExecutionContext&     executionContext,
00889             const ParamVectorType&          topLevelParams) const;
00890 
00891     // These interfaces are inherited from XalanDocument...
00892 
00893     virtual const XalanDOMString&
00894     getNodeName() const;
00895 
00896     virtual const XalanDOMString&
00897     getNodeValue() const;
00898 
00899     virtual NodeType
00900     getNodeType() const;
00901 
00902     virtual XalanNode*
00903     getParentNode() const;
00904 
00905     virtual const XalanNodeList*
00906     getChildNodes() const;
00907 
00908     virtual XalanNode*
00909     getFirstChild() const;
00910 
00911     virtual XalanNode*
00912     getLastChild() const;
00913 
00914     virtual XalanNode*
00915     getPreviousSibling() const;
00916 
00917     virtual XalanNode*
00918     getNextSibling() const;
00919 
00920     virtual const XalanNamedNodeMap*
00921     getAttributes() const;
00922 
00923     virtual XalanDocument*
00924     getOwnerDocument() const;
00925 
00926 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
00927     virtual XalanNode*
00928 #else
00929     virtual Stylesheet*
00930 #endif
00931     cloneNode(bool deep) const;
00932 
00933     virtual XalanNode*
00934     insertBefore(
00935             XalanNode*  newChild,
00936             XalanNode*  refChild);
00937 
00938     virtual XalanNode*
00939     replaceChild(
00940             XalanNode*  newChild,
00941             XalanNode*  oldChild);
00942 
00943     virtual XalanNode*
00944     removeChild(XalanNode*  oldChild);
00945 
00946     virtual XalanNode*
00947     appendChild(XalanNode*  newChild);
00948 
00949     virtual bool
00950     hasChildNodes() const;
00951 
00952     virtual void
00953     setNodeValue(const XalanDOMString&      nodeValue);
00954 
00955     virtual void
00956     normalize();
00957 
00958     virtual bool
00959     isSupported(
00960             const XalanDOMString&   feature,
00961             const XalanDOMString&   version) const;
00962 
00963     virtual const XalanDOMString&
00964     getNamespaceURI() const;
00965 
00966     virtual const XalanDOMString&
00967     getPrefix() const;
00968 
00969     virtual const XalanDOMString&
00970     getLocalName() const;
00971 
00972     virtual void
00973     setPrefix(const XalanDOMString& prefix);
00974 
00975     virtual IndexType
00976     getIndex() const;
00977 
00978     virtual XalanElement*
00979     createElement(const XalanDOMString& tagName);
00980 
00981     virtual XalanDocumentFragment*
00982     createDocumentFragment();
00983 
00984     virtual XalanText*
00985     createTextNode(const XalanDOMString&    data);
00986 
00987     virtual XalanComment*
00988     createComment(const XalanDOMString& data);
00989 
00990     virtual XalanCDATASection*
00991     createCDATASection(const XalanDOMString&    data);
00992 
00993     virtual XalanProcessingInstruction*
00994     createProcessingInstruction(
00995             const XalanDOMString&   target,
00996             const XalanDOMString&   data);
00997 
00998     virtual XalanAttr*
00999     createAttribute(const XalanDOMString&   name);
01000 
01001     virtual XalanEntityReference*
01002     createEntityReference(const XalanDOMString &name);
01003 
01004     virtual XalanDocumentType*
01005     getDoctype() const;
01006 
01007     virtual XalanDOMImplementation*
01008     getImplementation() const;
01009 
01010     virtual XalanElement*
01011     getDocumentElement() const;
01012 
01013     virtual XalanNodeList*
01014     getElementsByTagName(const XalanDOMString&      tagname) const;
01015 
01016     virtual XalanNode*
01017     importNode(
01018             XalanNode*  importedNode,
01019             bool        deep);
01020 
01021     virtual XalanElement*
01022     createElementNS(
01023             const XalanDOMString&   namespaceURI,
01024             const XalanDOMString&   qualifiedName);
01025 
01026     virtual XalanAttr*
01027     createAttributeNS(
01028             const XalanDOMString& namespaceURI,
01029             const XalanDOMString& qualifiedName);
01030 
01031     virtual XalanNodeList*
01032     getElementsByTagNameNS(
01033             const XalanDOMString&   namespaceURI,
01034             const XalanDOMString&   localName) const;
01035 
01036     virtual XalanElement*
01037     getElementById(const XalanDOMString&    elementId) const;
01038 
01039     virtual bool
01040     isIndexed() const;
01041 
01042     // These interfaces are inherited from PrefixResolver...
01043 
01044     virtual const XalanDOMString*
01045     getNamespaceForPrefix(const XalanDOMString&     prefix) const;
01046 
01047     virtual const XalanDOMString&
01048     getURI() const;
01049 
01050     const XalanDOMString&
01051     getXSLTNamespaceURI() const
01052     {
01053         return m_XSLTNamespaceURI;
01054     }
01055 
01056     void
01057     setXSLTNamespaceURI(const XalanDOMString&   theURI)
01058     {
01059         m_XSLTNamespaceURI = theURI;
01060     }
01061 
01062 protected:
01063 
01067     StylesheetRoot&                     m_stylesheetRoot;
01068 
01072     XalanDOMString                      m_baseIdent;
01073 
01078     KeyDeclarationVectorType            m_keyDeclarations;
01079 
01080     static const XalanQNameByReference  s_emptyQName;
01081 
01082 private:    
01083 
01084     // Not defined...
01085     Stylesheet(const Stylesheet&);
01086 
01087     Stylesheet&
01088     operator=(const Stylesheet&);
01089 
01090     bool
01091     operator==(const Stylesheet&) const;
01092 
01093 
01104     const ElemTemplate*
01105     findTemplateInImports(
01106             StylesheetExecutionContext&     executionContext,
01107             XalanNode*                      targetNode,
01108             XalanNode::NodeType             targetNodeType,
01109             const XalanQName&               mode) const;
01110 
01115     XalanDOMString                          m_XSLTNamespaceURI;
01116 
01120     StylesheetVectorType                    m_imports;
01121 
01122     StylesheetVectorType::size_type         m_importsSize;
01123 
01127     NamespacesStackType                     m_namespaces;
01128 
01133     NamespaceVectorType                     m_namespaceDecls;
01134 
01139     bool                                    m_isWrapperless;
01140 
01144     ExtensionNamespacesMapType              m_extensionNamespaces;
01145 
01149     ElemTemplate*                           m_firstTemplate;
01150 
01155     URLStackType                            m_includeStack;
01156 
01162     ElemTemplateMapType                     m_namedTemplates;
01163 
01167     ElemVariableVectorType                  m_topLevelVariables;
01168 
01172     double                                  m_XSLTVerDeclared;
01173 
01174     const bool                              m_isRoot;
01175 
01181     PatternTableMapType                         m_elementPatternTable;
01182 
01183     const PatternTableMapType::const_iterator   m_elementPatternTableEnd;
01184 
01185     PatternTableVectorType                      m_elementAnyPatternList;
01186 
01192     PatternTableMapType                         m_attributePatternTable;
01193 
01194     const PatternTableMapType::const_iterator   m_attributePatternTableEnd;
01195 
01196     PatternTableVectorType                      m_attributeAnyPatternList;
01197 
01201     PatternTableVectorType                  m_textPatternList;
01202 
01203     PatternTableVectorType                  m_commentPatternList;
01204 
01205     PatternTableVectorType                  m_rootPatternList;
01206 
01207     PatternTableVectorType                  m_piPatternList;
01208 
01212     PatternTableVectorType                  m_nodePatternList;
01213 
01218     MatchPattern2Container                  m_matchPattern2Container;
01219 
01223     MatchPattern2Container::size_type       m_patternCount;
01224 
01225     AttributeSetVectorType                  m_attributeSets;
01226 
01230     AttributeSetVectorType::size_type       m_attributeSetsSize;
01231 
01232     XalanNodeListSurrogate                  m_surrogateChildren;
01233 
01234     ElemDecimalFormatVectorType             m_elemDecimalFormats;
01235 
01236     NamespacesHandler                       m_namespacesHandler;
01237 
01238     static const XalanDOMString             s_emptyString;
01239 
01240     static const XalanEmptyNamedNodeMap     s_fakeAttributes;
01241 };
01242 
01243 
01244 
01245 XALAN_CPP_NAMESPACE_END
01246 
01247 
01248 
01249 #endif  // XALAN_STYLESHEET_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.5
Copyright © 2000, 2001, 2002, 2003 The Apache Software Foundation. All Rights Reserved.