Xalan-C++ API Documentation

The Xalan-C++ XSL Transformer Version 1.0

Main Page   Namespace List   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 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 <list>
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 <XPath/PrefixResolver.hpp>
00083 #include <XPath/NameSpace.hpp>
00084 #include <XPath/QName.hpp>
00085 
00086 
00087 
00088 #include "NamespacesHandler.hpp"
00089 #include "KeyDeclaration.hpp"
00090 #include "StylesheetExecutionContext.hpp"
00091 
00092 
00093 
00094 class AttributeList;
00095 class ExtensionNSHandler;
00096 class XalanDecimalFormatSymbols;
00097 class ElemAttributeSet;
00098 class ElemDecimalFormat;
00099 class ElemTemplate;
00100 class ElemTemplateElement;
00101 class ElemVariable;
00102 class KeyTable;
00103 class MatchPattern2;
00104 class NodeRefListBase;
00105 class PrefixResolver;
00106 class StylesheetConstructionContext;
00107 class StylesheetRoot;
00108 class XMLURL;
00109 class XObject;
00110 class XPath;
00111 class StylesheetExecutionContext;
00112 
00113 
00114 
00119 class XALAN_XSLT_EXPORT Stylesheet : public XalanDocument, private PrefixResolver
00120 {   
00121 
00122 public:
00123 
00124     typedef StylesheetExecutionContext::ParamVectorType     ParamVectorType;
00125     typedef NamespacesHandler::NamespaceVectorType          NamespaceVectorType;
00126     typedef NamespacesHandler::NamespacesStackType          NamespacesStackType;
00127 
00128 #if defined(XALAN_NO_NAMESPACES)
00129     typedef map<XalanDOMString,
00130                 XalanDOMString,
00131                 less<XalanDOMString> >              StringToStringMapType;
00132     typedef map<XalanDOMString,
00133                 ExtensionNSHandler*,
00134                 less<XalanDOMString> >              ExtensionNamespacesMapType;
00135     typedef map<QName,
00136                 ElemTemplate*,
00137                 less<QName> >                       ElemTemplateMapType;
00138     typedef vector<ElemAttributeSet*>               AttributeSetMapType;
00139     typedef vector<ElemVariable*>                   ElemVariableVectorType;
00140     typedef vector<KeyDeclaration>                  KeyDeclarationVectorType;
00141 //  typedef map<XalanDOMString,
00142 //              KeyTable*,
00143 //              less<XalanDOMString> >              KeysMapType;
00144     typedef map<const XalanNode*,
00145                 KeyTable*,
00146                 less<const XalanNode*> >            KeyTablesTableType;
00147     typedef vector<QName>                           QNameVectorType;
00148     typedef vector<Stylesheet*>                     StylesheetVectorType;
00149     typedef vector<XalanDOMString>                  URLStackType;
00150     typedef vector<const XPath*>                    XPathVectorType;
00151     typedef vector<ElemDecimalFormat*>              ElemDecimalFormatVectorType;
00152 #else
00153     typedef std::map<XalanDOMString, XalanDOMString>        StringToStringMapType;
00154     typedef std::map<XalanDOMString, ExtensionNSHandler*>   ExtensionNamespacesMapType;
00155     typedef std::map<QName, ElemTemplate*>                  ElemTemplateMapType;
00156     typedef std::vector<ElemAttributeSet*>                  AttributeSetMapType;
00157     typedef std::vector<ElemVariable*>                      ElemVariableVectorType;
00158     typedef std::vector<KeyDeclaration>                     KeyDeclarationVectorType;
00159 //  typedef std::map<XalanDOMString, KeyTable*>             KeysMapType;
00160     typedef std::map<const XalanNode*, KeyTable*>           KeyTablesTableType;
00161     typedef std::vector<QName>                              QNameVectorType;
00162     typedef std::vector<Stylesheet*>                        StylesheetVectorType;
00163     typedef std::vector<XalanDOMString>                     URLStackType;
00164     typedef std::vector<const XPath*>                       XPathVectorType;
00165     typedef std::vector<ElemDecimalFormat*>                 ElemDecimalFormatVectorType;
00166 #endif
00167 
00173     Stylesheet(
00174             StylesheetRoot&                 root,
00175             const XalanDOMString&           baseIdentifier,
00176             StylesheetConstructionContext&  constructionContext);
00177 
00178     virtual
00179     ~Stylesheet();
00180 
00186     double
00187     getXSLTVerDeclared() const
00188     {
00189         return m_XSLTVerDeclared;
00190     }
00191 
00197     void
00198     setXSLTVerDeclared(double ver)
00199     {
00200         m_XSLTVerDeclared = ver;
00201     }
00202 
00208     const StylesheetRoot&
00209     getStylesheetRoot() const
00210     {
00211         return m_stylesheetRoot;
00212     }
00213 
00219     StylesheetRoot&
00220     getStylesheetRoot()
00221     {
00222         return m_stylesheetRoot;
00223     }
00224 
00230     const NamespacesStackType&
00231     getNamespaces() const
00232     { 
00233         return m_namespaces;
00234     }
00235 
00241     NamespacesStackType&
00242     getNamespaces()
00243     { 
00244         return m_namespaces;
00245     }
00246 
00247     const NamespacesHandler&
00248     getNamespacesHandler() const
00249     {
00250         return m_namespacesHandler;
00251     }
00252 
00253     NamespacesHandler&
00254     getNamespacesHandler()
00255     {
00256         return m_namespacesHandler;
00257     }
00258 
00264     const NamespaceVectorType&
00265     getNamespaceDecls() const
00266     {
00267         return m_namespaceDecls;
00268     }
00269 
00275     NamespaceVectorType&
00276     getNamespaceDecls()
00277     {
00278         return m_namespaceDecls;
00279     }
00280 
00286     void
00287     setNamespaceDecls(const NamespaceVectorType& ns)
00288     {
00289         m_namespaceDecls = ns;
00290     }
00291 
00292     /*
00293      * Get the top entry on the namespace stack, or 0, if
00294      * there is nothing on the stack.
00295      */
00296     const NamespaceVectorType&
00297     getCurrentNamespace() const;
00298 
00305     void
00306     pushNamespaces(const AttributeList&     atts);
00307 
00311     void
00312     popNamespaces();
00313 
00317     virtual void
00318     postConstruction();
00319 
00329     bool
00330     isAttrOK(
00331             const XalanDOMChar*             attrName,
00332             const AttributeList&            atts,
00333             int                             which,
00334             StylesheetConstructionContext&  constructionContext) const;
00335 
00342     XalanDOMString
00343     getNamespaceFromStack(const XalanDOMString&     nodeName) const;
00344 
00352     XalanDOMString
00353     getNamespaceForPrefixFromStack(const XalanDOMString&    prefix) const;
00354 
00361     XalanDOMString
00362     getAliasNamespaceURI(const XalanDOMString&  uri) const;
00363 
00371     void
00372     processExcludeResultPrefixes(
00373         const XalanDOMChar*             theValue,
00374         StylesheetConstructionContext&  theConstructionContext);
00375 
00385     const Stylesheet*
00386     getPreviousImport(const Stylesheet*     stylesheet) const;
00387 
00394     void
00395     addTemplate(
00396             ElemTemplate*                   tmpl,
00397             StylesheetConstructionContext&  constructionContext);
00398 
00407     virtual bool
00408     getYesOrNo(
00409             const XalanDOMChar*             aname,
00410             const XalanDOMChar*             val,
00411             StylesheetConstructionContext&  constructionContext) const;
00412 
00418     bool
00419     isRoot() const
00420     {
00421         return m_isRoot;
00422     }
00423 
00429     const XalanDOMString
00430     getBaseIdentifier() const
00431     {
00432         return m_baseIdent;
00433     }
00434 
00440     void
00441     setBaseIdentifier(const XalanDOMString& str)
00442     {
00443         m_baseIdent = str;
00444     }
00445 
00454     const XalanDOMString
00455     getCurrentIncludeBaseIdentifier() const;
00456 
00464     void
00465     processNSAliasElement(
00466             const XalanDOMString&           name,
00467             const AttributeList&            atts,
00468             StylesheetConstructionContext&  constructionContext);
00469 
00477     void
00478     processDecimalFormatElement(
00479             ElemDecimalFormat*              elemDecimalFormat,
00480             const AttributeList&            atts,
00481             StylesheetConstructionContext&  constructionContext);
00482 
00490     const XalanDecimalFormatSymbols*
00491     getDecimalFormatSymbols(const XalanDOMString&   name) const;
00492 
00499     void
00500     addAttributeSet(
00501         const QName&        qname, 
00502         ElemAttributeSet*   attrSet);
00503 
00514     void
00515     applyAttrSets(
00516             const QNameVectorType&          attributeSetsNames,
00517             StylesheetExecutionContext&     executionContext, 
00518             XalanNode*                      sourceTree,
00519             XalanNode*                      sourceNode,
00520             const QName&                    mode) const;
00521   
00527     bool
00528     isDefaultSpaceProcessing() const
00529     {
00530         return m_defaultSpace;
00531     }
00532 
00538     void
00539     setDefaultSpaceProcessing(bool bEnabled)
00540     {
00541         m_defaultSpace = bEnabled;
00542     }
00543 
00550     void
00551     addImport(
00552             Stylesheet*     theStylesheet,
00553             bool            fFront)
00554     {
00555         m_imports.insert(fFront ? m_imports.begin() : m_imports.end(), theStylesheet);
00556     }
00557 
00563     const ElemTemplate*
00564     getWrapperlessTemplate()
00565     {
00566         return m_wrapperlessTemplate;
00567     }
00568 
00574     void
00575     setWrapperlessTemplate(ElemTemplate*    templ)
00576     {
00577         m_wrapperlessTemplate = templ;
00578     }
00579 
00585     bool
00586     isWrapperless() const
00587     {
00588         return m_isWrapperless;
00589     }
00590 
00596     void
00597     setWrapperless(bool b)
00598     {
00599         m_isWrapperless = b;
00600     }
00601 
00607     URLStackType&
00608     getIncludeStack()
00609     {
00610         return m_includeStack;
00611     }
00612 
00620     /*
00621      * (Notes to myself)
00622      * What we need to do is:
00623      * 1) As this function is called, build a table of KeyDeclarations.
00624      * 2) During either XML processing, or upon request, walk the XML 
00625      * document tree, and build a hash table:
00626      * a) keyed by name,
00627      * b) each with a value of a hashtable, keyed by the value returned by 
00628      *    the use attribute,
00629      * c) each with a value that is a nodelist.
00630      * Thus, for a given key or keyref, look up hashtable by name, 
00631      * look up the nodelist by the given reference.
00632      */
00633     void
00634     processKeyElement(
00635             ElemTemplateElement*            nsContext,
00636             const AttributeList&            atts,
00637             StylesheetConstructionContext&  constructionContext);
00638   
00646     const ElemTemplate*
00647     findNamedTemplate(
00648             const XalanDOMString&           name,
00649             StylesheetExecutionContext&     executionContext) const;
00657     const ElemTemplate*
00658     findNamedTemplate(
00659             const QName&                    qname,
00660             StylesheetExecutionContext&     executionContext) const;
00661 
00671     const ElemTemplate*
00672     findTemplate(
00673             StylesheetExecutionContext&     executionContext,
00674             XalanNode*                      sourceTree,
00675             XalanNode*                      targetNode) const;
00676 
00688     const ElemTemplate*
00689     findTemplate(
00690             StylesheetExecutionContext&     executionContext,
00691             XalanNode*                      sourceTree, 
00692             XalanNode*                      targetNode, 
00693             const QName&                    mode,
00694             bool                            useImports,
00695             const Stylesheet*&              foundStylesheet) const;
00696 
00701     class MatchPattern2
00702     {
00703     public:
00704 
00715         MatchPattern2(
00716                 const XalanDOMString&   pat,
00717                 const XPath*            exp,
00718                 const ElemTemplate*     theTemplate,
00719                 int                     posInStylesheet, 
00720                 const XalanDOMString&   targetString,
00721                 const Stylesheet*       stylesheet); 
00722 
00723         ~MatchPattern2();
00724 
00730         const Stylesheet*
00731         getStylesheet() const
00732         {
00733             return m_stylesheet;
00734         }
00735         
00741         const XalanDOMString&
00742         getTargetString() const
00743         { 
00744             return m_targetString;
00745         }
00746         
00752         const XPath*
00753         getExpression() const
00754         {
00755             return m_expression;
00756         }
00757         
00763         int
00764         getPositionInStylesheet() const
00765         {
00766             return m_posInStylesheet;
00767         }
00768         
00774         const XalanDOMString&
00775         getPattern() const
00776         {
00777             return m_pattern;
00778         }
00779         
00785         const ElemTemplate*
00786         getTemplate() const
00787         {
00788             return m_template;
00789         }
00790         
00791     private:
00792 
00793         const Stylesheet* const     m_stylesheet;
00794         const XalanDOMString        m_targetString;
00795         const XPath* const          m_expression;
00796         const int                   m_posInStylesheet;
00797         const XalanDOMString        m_pattern;
00798         const ElemTemplate* const   m_template; // ref to the corresponding template
00799 
00800         // Not implemented...
00801         MatchPattern2();
00802         MatchPattern2& operator=(const MatchPattern2&);
00803     };
00804 
00805 #if defined(XALAN_NO_NAMESPACES)
00806     typedef list<MatchPattern2*>                PatternTableListType;
00807 
00808     typedef vector<const MatchPattern2*>        PatternTableVectorType;
00809 
00810     typedef map<XalanDOMString,
00811                 PatternTableListType,
00812                 less<XalanDOMString> >          PatternTableMapType;
00813 #else
00814     typedef std::list<MatchPattern2*>           PatternTableListType;
00815 
00816     typedef std::vector<const MatchPattern2*>   PatternTableVectorType;
00817 
00818     typedef std::map<XalanDOMString,
00819                      PatternTableListType>      PatternTableMapType;
00820 #endif
00821 
00828     static void
00829     addObjectIfNotFound(
00830             const MatchPattern2*        thePattern,
00831             PatternTableVectorType&     theVector);
00832 
00839     const PatternTableListType*
00840     locateMatchPatternList2(XalanNode*  sourceNode) const;
00841 
00849     const PatternTableListType*
00850     locateMatchPatternList2(
00851             const XalanDOMString&   sourceElementType,
00852             bool                    tryWildCard = false) const;
00853 
00862     void
00863     addExtensionNamespace(
00864             const XalanDOMString&   uri,
00865             ExtensionNSHandler*     nsh);
00866 
00873     ExtensionNSHandler*
00874     lookupExtensionNSHandler(const XalanDOMString&  uri) const
00875     {
00876         const ExtensionNamespacesMapType::const_iterator    it = 
00877           m_extensionNamespaces.find(uri);
00878 
00879         return it == m_extensionNamespaces.end() ? 0 : (*it).second;
00880     }
00881 
00889     void
00890     setTopLevelVariable(ElemVariable*   var)
00891     {
00892         m_topLevelVariables.push_back(var);
00893     }
00894 
00902     void
00903     pushTopLevelVariables(
00904             StylesheetExecutionContext&     executionContext,
00905             const ParamVectorType&          topLevelParams) const;
00906 
00907     const XPathVectorType&
00908     getWhitespacePreservingElements() const
00909     {
00910         return m_whitespacePreservingElements;
00911     }
00912 
00913     void
00914     pushWhitespacePreservingElement(const XPath*    theXPath)
00915     {
00916         m_whitespacePreservingElements.push_back(theXPath);
00917     }
00918 
00919     const XPathVectorType&
00920     getWhitespaceStrippingElements() const
00921     {
00922         return m_whitespaceStrippingElements;
00923     }
00924 
00925     void
00926     pushWhitespaceStrippingElement(const XPath* theXPath)
00927     {
00928         m_whitespaceStrippingElements.push_back(theXPath);
00929     }
00930 
00931     // These interfaces are inherited from XalanDocument...
00932 
00933     virtual XalanDOMString
00934     getNodeName() const;
00935 
00936     virtual XalanDOMString
00937     getNodeValue() const;
00938 
00939     virtual NodeType
00940     getNodeType() const;
00941 
00942     virtual XalanNode*
00943     getParentNode() const;
00944 
00945     virtual const XalanNodeList*
00946     getChildNodes() const;
00947 
00948     virtual XalanNode*
00949     getFirstChild() const;
00950 
00951     virtual XalanNode*
00952     getLastChild() const;
00953 
00954     virtual XalanNode*
00955     getPreviousSibling() const;
00956 
00957     virtual XalanNode*
00958     getNextSibling() const;
00959 
00960     virtual const XalanNamedNodeMap*
00961     getAttributes() const;
00962 
00963     virtual XalanDocument*
00964     getOwnerDocument() const;
00965 
00966 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
00967     virtual XalanNode*
00968 #else
00969     virtual Stylehseet*
00970 #endif
00971     cloneNode(bool deep) const;
00972 
00973     virtual XalanNode*
00974     insertBefore(
00975             XalanNode*  newChild,
00976             XalanNode*  refChild);
00977 
00978     virtual XalanNode*
00979     replaceChild(
00980             XalanNode*  newChild,
00981             XalanNode*  oldChild);
00982 
00983     virtual XalanNode*
00984     removeChild(XalanNode*  oldChild);
00985 
00986     virtual XalanNode*
00987     appendChild(XalanNode*  newChild);
00988 
00989     virtual bool
00990     hasChildNodes() const;
00991 
00992     virtual void
00993     setNodeValue(const XalanDOMString&      nodeValue);
00994 
00995     virtual void
00996     normalize();
00997 
00998     virtual bool
00999     supports(
01000             const XalanDOMString&   feature,
01001             const XalanDOMString&   version) const;
01002 
01003     virtual XalanDOMString
01004     getNamespaceURI() const;
01005 
01006     virtual XalanDOMString
01007     getPrefix() const;
01008 
01009     virtual XalanDOMString
01010     getLocalName() const;
01011 
01012     virtual void
01013     setPrefix(const XalanDOMString& prefix);
01014 
01015     virtual unsigned long
01016     getIndex() const;
01017 
01018     virtual XalanDOMString
01019     getXSLTData() const;
01020 
01021     virtual XalanElement*
01022     createElement(const XalanDOMString& tagName);
01023 
01024     virtual XalanDocumentFragment*
01025     createDocumentFragment();
01026 
01027     virtual XalanText*
01028     createTextNode(const XalanDOMString&    data);
01029 
01030     virtual XalanComment*
01031     createComment(const XalanDOMString& data);
01032 
01033     virtual XalanCDATASection*
01034     createCDATASection(const XalanDOMString&    data);
01035 
01036     virtual XalanProcessingInstruction*
01037     createProcessingInstruction(
01038             const XalanDOMString&   target,
01039             const XalanDOMString&   data);
01040 
01041     virtual XalanAttr*
01042     createAttribute(const XalanDOMString&   name);
01043 
01044     virtual XalanEntityReference*
01045     createEntityReference(const XalanDOMString &name);
01046 
01047     virtual XalanDocumentType*
01048     getDoctype() const;
01049 
01050     virtual XalanDOMImplementation*
01051     getImplementation() const;
01052 
01053     virtual XalanElement*
01054     getDocumentElement() const;
01055 
01056     virtual XalanNodeList*
01057     getElementsByTagName(const XalanDOMString&      tagname) const;
01058 
01059     virtual XalanNode*
01060     importNode(
01061             XalanNode*  importedNode,
01062             bool        deep);
01063 
01064     virtual XalanElement*
01065     createElementNS(
01066             const XalanDOMString&   namespaceURI,
01067             const XalanDOMString&   qualifiedName);
01068 
01069     virtual XalanAttr*
01070     createAttributeNS(
01071             const XalanDOMString& namespaceURI,
01072             const XalanDOMString& qualifiedName);
01073 
01074     virtual XalanNodeList*
01075     getElementsByTagNameNS(
01076             const XalanDOMString&   namespaceURI,
01077             const XalanDOMString&   localName) const;
01078 
01079     virtual XalanElement*
01080     getElementById(const XalanDOMString&    elementId) const;
01081 
01082     virtual bool
01083     isIndexed() const;
01084 
01085     // These interfaces are inherited from PrefixResolver...
01086 
01087     virtual XalanDOMString
01088     getNamespaceForPrefix(const XalanDOMString&     prefix) const;
01089 
01090     virtual XalanDOMString
01091     getURI() const;
01092 
01093     const XalanDOMString&
01094     getXSLTNamespaceURI() const
01095     {
01096         return m_XSLTNamespaceURI;
01097     }
01098 
01099     void
01100     setXSLTNamespaceURI(const XalanDOMString&   theURI)
01101     {
01102         m_XSLTNamespaceURI = theURI;
01103     }
01104 
01105 protected:
01106 
01110     StylesheetRoot&                     m_stylesheetRoot;
01111 
01115     bool                                m_needToBuildKeysTable;
01116 
01120     XalanDOMString                      m_baseIdent;
01121 
01126     KeyDeclarationVectorType            m_keyDeclarations;
01127 
01128 private:    
01129 
01130     // Not defined...
01131     Stylesheet(const Stylesheet&);
01132 
01133     Stylesheet&
01134     operator=(const Stylesheet&);
01135 
01136     bool
01137     operator==(const Stylesheet&) const;
01138 
01143     XalanDOMString                          m_XSLTNamespaceURI;
01144 
01148     XPathVectorType                         m_whitespacePreservingElements;
01149   
01153     XPathVectorType                         m_whitespaceStrippingElements;
01154 
01158     StylesheetVectorType                    m_imports;
01159 
01163     NamespacesStackType                     m_namespaces;
01164 
01169     NamespaceVectorType                     m_namespaceDecls;
01170 
01175     static const NamespaceVectorType        s_emptyNamespace;
01176 
01180     bool                                    m_tablesAreInvalid;
01181 
01186     bool                                    m_isWrapperless;
01187 
01191     ElemTemplate*                           m_wrapperlessTemplate;
01192   
01196     ExtensionNamespacesMapType              m_extensionNamespaces;
01197 
01198   
01202     ElemTemplateElement*                    m_firstTemplate;
01203   
01208     URLStackType                            m_includeStack;
01209 
01215     bool                                    m_defaultSpace;
01216   
01222     ElemTemplateMapType                     m_namedTemplates;
01223   
01227     ElemVariableVectorType                  m_topLevelVariables;
01228 
01229 
01233     double                                  m_XSLTVerDeclared;
01234 
01235     const bool                              m_isRoot;
01236 
01242     PatternTableMapType                     m_patternTable;
01243 
01247     AttributeSetMapType                     m_attributeSets;
01248 
01249     XalanNodeListSurrogate                  m_surrogateChildren;
01250 
01251     XalanEmptyNamedNodeMap                  m_fakeAttributes;
01252 
01253     ElemDecimalFormatVectorType             m_elemDecimalFormats;
01254 
01255     StringToStringMapType                   m_prefixAliases;
01256 
01257     NamespacesHandler                       m_namespacesHandler;
01258 };
01259 
01260 
01261 
01262 #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++ XSL Transformer Version 1.0
Copyright © 2000 The Apache Software Foundation. All Rights Reserved.