Xalan-C++ API Documentation

The Xalan C++ XSL Transformer Version 1.1

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 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 <DOMSupport/PrefixResolver.hpp>
00083 
00084 
00085 
00086 #include <XPath/NameSpace.hpp>
00087 #include <XPath/QNameByReference.hpp>
00088 
00089 
00090 
00091 #include "NamespacesHandler.hpp"
00092 #include "KeyDeclaration.hpp"
00093 #include "StylesheetExecutionContext.hpp"
00094 
00095 
00096 
00097 class AttributeList;
00098 class ExtensionNSHandler;
00099 class XalanDecimalFormatSymbols;
00100 class ElemAttributeSet;
00101 class ElemDecimalFormat;
00102 class ElemTemplate;
00103 class ElemTemplateElement;
00104 class ElemVariable;
00105 class KeyTable;
00106 class MatchPattern2;
00107 class NodeRefListBase;
00108 class PrefixResolver;
00109 class StylesheetConstructionContext;
00110 class StylesheetRoot;
00111 class XMLURL;
00112 class XObject;
00113 class XPath;
00114 class StylesheetExecutionContext;
00115 
00116 
00117 
00122 class XALAN_XSLT_EXPORT Stylesheet : public XalanDocument, private PrefixResolver
00123 {   
00124 
00125 public:
00126 
00127     typedef StylesheetExecutionContext::ParamVectorType     ParamVectorType;
00128     typedef NamespacesHandler::NamespaceVectorType          NamespaceVectorType;
00129     typedef NamespacesHandler::NamespacesStackType          NamespacesStackType;
00130 
00131 #if defined(XALAN_NO_NAMESPACES)
00132     typedef map<XalanDOMString,
00133                 XalanDOMString,
00134                 less<XalanDOMString> >              StringToStringMapType;
00135     typedef map<XalanDOMString,
00136                 ExtensionNSHandler*,
00137                 less<XalanDOMString> >              ExtensionNamespacesMapType;
00138     typedef map<QNameByReference,
00139                 ElemTemplate*,
00140                 less<QName> >                       ElemTemplateMapType;
00141     typedef vector<ElemAttributeSet*>               AttributeSetMapType;
00142     typedef vector<ElemVariable*>                   ElemVariableVectorType;
00143     typedef vector<KeyDeclaration>                  KeyDeclarationVectorType;
00144     typedef map<const XalanNode*,
00145                 KeyTable*,
00146                 less<const XalanNode*> >            KeyTablesTableType;
00147     typedef vector<QNameByValue>                    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<QNameByReference, ElemTemplate*>       ElemTemplateMapType;
00156     typedef std::vector<ElemAttributeSet*>                  AttributeSetMapType;
00157     typedef std::vector<ElemVariable*>                      ElemVariableVectorType;
00158     typedef std::vector<KeyDeclaration>                     KeyDeclarationVectorType;
00159     typedef std::map<const XalanNode*, KeyTable*>           KeyTablesTableType;
00160     typedef std::vector<QNameByValue>                       QNameVectorType;
00161     typedef std::vector<Stylesheet*>                        StylesheetVectorType;
00162     typedef std::vector<XalanDOMString>                     URLStackType;
00163     typedef std::vector<const XPath*>                       XPathVectorType;
00164     typedef std::vector<ElemDecimalFormat*>                 ElemDecimalFormatVectorType;
00165 #endif
00166 
00172     Stylesheet(
00173             StylesheetRoot&                 root,
00174             const XalanDOMString&           baseIdentifier,
00175             StylesheetConstructionContext&  constructionContext);
00176 
00177     virtual
00178     ~Stylesheet();
00179 
00185     double
00186     getXSLTVerDeclared() const
00187     {
00188         return m_XSLTVerDeclared;
00189     }
00190 
00196     void
00197     setXSLTVerDeclared(double ver)
00198     {
00199         m_XSLTVerDeclared = ver;
00200     }
00201 
00207     const StylesheetRoot&
00208     getStylesheetRoot() const
00209     {
00210         return m_stylesheetRoot;
00211     }
00212 
00218     StylesheetRoot&
00219     getStylesheetRoot()
00220     {
00221         return m_stylesheetRoot;
00222     }
00223 
00229     const NamespacesStackType&
00230     getNamespaces() const
00231     { 
00232         return m_namespaces;
00233     }
00234 
00240     NamespacesStackType&
00241     getNamespaces()
00242     { 
00243         return m_namespaces;
00244     }
00245 
00246     const NamespacesHandler&
00247     getNamespacesHandler() const
00248     {
00249         return m_namespacesHandler;
00250     }
00251 
00252     NamespacesHandler&
00253     getNamespacesHandler()
00254     {
00255         return m_namespacesHandler;
00256     }
00257 
00263     const NamespaceVectorType&
00264     getNamespaceDecls() const
00265     {
00266         return m_namespaceDecls;
00267     }
00268 
00274     NamespaceVectorType&
00275     getNamespaceDecls()
00276     {
00277         return m_namespaceDecls;
00278     }
00279 
00285     void
00286     setNamespaceDecls(const NamespaceVectorType& ns)
00287     {
00288         m_namespaceDecls = ns;
00289     }
00290 
00291     /*
00292      * Get the top entry on the namespace stack, or 0, if
00293      * there is nothing on the stack.
00294      */
00295     const NamespaceVectorType&
00296     getCurrentNamespace() const;
00297 
00304     void
00305     pushNamespaces(const AttributeList&     atts);
00306 
00310     void
00311     popNamespaces();
00312 
00316     virtual void
00317     postConstruction();
00318 
00328     bool
00329     isAttrOK(
00330             const XalanDOMChar*             attrName,
00331             const AttributeList&            atts,
00332             int                             which,
00333             StylesheetConstructionContext&  constructionContext) const;
00334 
00341     const XalanDOMString&
00342     getNamespaceFromStack(const XalanDOMString&     nodeName) const;
00343 
00350     const XalanDOMString&
00351     getNamespaceFromStack(const XalanDOMChar*   nodeName) const;
00352 
00360     const XalanDOMString&
00361     getNamespaceForPrefixFromStack(const XalanDOMString&    prefix) const;
00362 
00370     const XalanDOMString&
00371     getNamespaceForPrefixFromStack(const XalanDOMChar*  prefix) const;
00372 
00379     XalanDOMString
00380     getAliasNamespaceURI(const XalanDOMChar*    uri) const;
00381 
00388     XalanDOMString
00389     getAliasNamespaceURI(const XalanDOMString&  uri) const;
00390 
00398     void
00399     processExcludeResultPrefixes(
00400         const XalanDOMChar*             theValue,
00401         StylesheetConstructionContext&  theConstructionContext);
00402 
00412     const Stylesheet*
00413     getPreviousImport(const Stylesheet*     stylesheet) const;
00414 
00421     void
00422     addTemplate(
00423             ElemTemplate*                   tmpl,
00424             StylesheetConstructionContext&  constructionContext);
00425 
00434     virtual bool
00435     getYesOrNo(
00436             const XalanDOMChar*             aname,
00437             const XalanDOMChar*             val,
00438             StylesheetConstructionContext&  constructionContext) const;
00439 
00445     bool
00446     isRoot() const
00447     {
00448         return m_isRoot;
00449     }
00450 
00456     const XalanDOMString&
00457     getBaseIdentifier() const
00458     {
00459         return m_baseIdent;
00460     }
00461 
00467     void
00468     setBaseIdentifier(const XalanDOMString&     str)
00469     {
00470         m_baseIdent = str;
00471     }
00472 
00481     const XalanDOMString&
00482     getCurrentIncludeBaseIdentifier() const;
00483 
00491     void
00492     processNSAliasElement(
00493             const XalanDOMChar*             name,
00494             const AttributeList&            atts,
00495             StylesheetConstructionContext&  constructionContext);
00496 
00504     void
00505     processDecimalFormatElement(
00506             ElemDecimalFormat*              elemDecimalFormat,
00507             const AttributeList&            atts,
00508             StylesheetConstructionContext&  constructionContext);
00509 
00517     const XalanDecimalFormatSymbols*
00518     getDecimalFormatSymbols(const XalanDOMString&   name) const;
00519 
00526     void
00527     addAttributeSet(
00528         const QName&        qname, 
00529         ElemAttributeSet*   attrSet);
00530 
00541     void
00542     applyAttrSets(
00543             const QNameVectorType&          attributeSetsNames,
00544             StylesheetExecutionContext&     executionContext, 
00545             XalanNode*                      sourceTree,
00546             XalanNode*                      sourceNode,
00547             const QName&                    mode) const;
00548   
00554     bool
00555     isDefaultSpaceProcessing() const
00556     {
00557         return m_defaultSpace;
00558     }
00559 
00565     void
00566     setDefaultSpaceProcessing(bool bEnabled)
00567     {
00568         m_defaultSpace = bEnabled;
00569     }
00570 
00577     void
00578     addImport(
00579             Stylesheet*     theStylesheet,
00580             bool            fFront)
00581     {
00582         m_imports.insert(fFront ? m_imports.begin() : m_imports.end(), theStylesheet);
00583     }
00584 
00590     const ElemTemplate*
00591     getWrapperlessTemplate()
00592     {
00593         return m_wrapperlessTemplate;
00594     }
00595 
00601     void
00602     setWrapperlessTemplate(ElemTemplate*    templ)
00603     {
00604         m_wrapperlessTemplate = templ;
00605     }
00606 
00612     bool
00613     isWrapperless() const
00614     {
00615         return m_isWrapperless;
00616     }
00617 
00623     void
00624     setWrapperless(bool b)
00625     {
00626         m_isWrapperless = b;
00627     }
00628 
00634     URLStackType&
00635     getIncludeStack()
00636     {
00637         return m_includeStack;
00638     }
00639 
00647     /*
00648      * (Notes to myself)
00649      * What we need to do is:
00650      * 1) As this function is called, build a table of KeyDeclarations.
00651      * 2) During either XML processing, or upon request, walk the XML 
00652      * document tree, and build a hash table:
00653      * a) keyed by name,
00654      * b) each with a value of a hashtable, keyed by the value returned by 
00655      *    the use attribute,
00656      * c) each with a value that is a nodelist.
00657      * Thus, for a given key or keyref, look up hashtable by name, 
00658      * look up the nodelist by the given reference.
00659      */
00660     void
00661     processKeyElement(
00662             ElemTemplateElement*            nsContext,
00663             const AttributeList&            atts,
00664             StylesheetConstructionContext&  constructionContext);
00665 
00673     const ElemTemplate*
00674     findNamedTemplate(
00675             const QName&                    qname,
00676             StylesheetExecutionContext&     executionContext) const;
00677 
00687     const ElemTemplate*
00688     findTemplate(
00689             StylesheetExecutionContext&     executionContext,
00690             XalanNode*                      sourceTree,
00691             XalanNode*                      targetNode) const;
00692 
00704     const ElemTemplate*
00705     findTemplate(
00706             StylesheetExecutionContext&     executionContext,
00707             XalanNode*                      sourceTree, 
00708             XalanNode*                      targetNode, 
00709             const QName&                    mode,
00710             bool                            useImports,
00711             const Stylesheet*&              foundStylesheet) const;
00712 
00717     class MatchPattern2
00718     {
00719     public:
00720 
00731         MatchPattern2(
00732                 const XalanDOMString&   pat,
00733                 const XPath*            exp,
00734                 const ElemTemplate*     theTemplate,
00735                 int                     posInStylesheet, 
00736                 const XalanDOMString&   targetString,
00737                 const Stylesheet*       stylesheet); 
00738 
00739         ~MatchPattern2();
00740 
00746         const Stylesheet*
00747         getStylesheet() const
00748         {
00749             return m_stylesheet;
00750         }
00751         
00757         const XalanDOMString&
00758         getTargetString() const
00759         { 
00760             return m_targetString;
00761         }
00762         
00768         const XPath*
00769         getExpression() const
00770         {
00771             return m_expression;
00772         }
00773         
00779         int
00780         getPositionInStylesheet() const
00781         {
00782             return m_posInStylesheet;
00783         }
00784         
00790         const XalanDOMString&
00791         getPattern() const
00792         {
00793             return m_pattern;
00794         }
00795         
00801         const ElemTemplate*
00802         getTemplate() const
00803         {
00804             return m_template;
00805         }
00806         
00807     private:
00808 
00809         const Stylesheet* const     m_stylesheet;
00810         const XalanDOMString        m_targetString;
00811         const XPath* const          m_expression;
00812         const int                   m_posInStylesheet;
00813         const XalanDOMString        m_pattern;
00814         const ElemTemplate* const   m_template; // ref to the corresponding template
00815 
00816         // Not implemented...
00817         MatchPattern2();
00818         MatchPattern2& operator=(const MatchPattern2&);
00819     };
00820 
00821 #if defined(XALAN_NO_NAMESPACES)
00822     typedef list<MatchPattern2*>                PatternTableListType;
00823 
00824     typedef vector<const MatchPattern2*>        PatternTableVectorType;
00825 
00826     typedef map<XalanDOMString,
00827                 PatternTableListType,
00828                 less<XalanDOMString> >          PatternTableMapType;
00829 #else
00830     typedef std::list<MatchPattern2*>           PatternTableListType;
00831 
00832     typedef std::vector<const MatchPattern2*>   PatternTableVectorType;
00833 
00834     typedef std::map<XalanDOMString,
00835                      PatternTableListType>      PatternTableMapType;
00836 #endif
00837 
00844     static void
00845     addObjectIfNotFound(
00846             const MatchPattern2*        thePattern,
00847             PatternTableVectorType&     theVector);
00848 
00858     static void
00859     addObjectIfNotFound(
00860             const MatchPattern2*    thePattern,
00861             const MatchPattern2*    theArray[],
00862             unsigned int&           theArraySize);
00863 
00870     const PatternTableListType*
00871     locateMatchPatternList2(XalanNode*  sourceNode) const;
00872 
00880     const PatternTableListType*
00881     locateMatchPatternList2(
00882             const XalanDOMString&   sourceElementType,
00883             bool                    tryWildCard = false) const;
00884 
00893     void
00894     addExtensionNamespace(
00895             const XalanDOMString&   uri,
00896             ExtensionNSHandler*     nsh);
00897 
00904     ExtensionNSHandler*
00905     lookupExtensionNSHandler(const XalanDOMString&  uri) const
00906     {
00907         const ExtensionNamespacesMapType::const_iterator    it = 
00908           m_extensionNamespaces.find(uri);
00909 
00910         return it == m_extensionNamespaces.end() ? 0 : (*it).second;
00911     }
00912 
00920     void
00921     setTopLevelVariable(ElemVariable*   var)
00922     {
00923         m_topLevelVariables.push_back(var);
00924     }
00925 
00933     void
00934     pushTopLevelVariables(
00935             StylesheetExecutionContext&     executionContext,
00936             const ParamVectorType&          topLevelParams) const;
00937 
00938     const XPathVectorType&
00939     getWhitespacePreservingElements() const
00940     {
00941         return m_whitespacePreservingElements;
00942     }
00943 
00944     void
00945     pushWhitespacePreservingElement(const XPath*    theXPath)
00946     {
00947         m_whitespacePreservingElements.push_back(theXPath);
00948     }
00949 
00950     const XPathVectorType&
00951     getWhitespaceStrippingElements() const
00952     {
00953         return m_whitespaceStrippingElements;
00954     }
00955 
00956     void
00957     pushWhitespaceStrippingElement(const XPath* theXPath)
00958     {
00959         m_whitespaceStrippingElements.push_back(theXPath);
00960     }
00961 
00962     // These interfaces are inherited from XalanDocument...
00963 
00964     virtual const XalanDOMString&
00965     getNodeName() const;
00966 
00967     virtual const XalanDOMString&
00968     getNodeValue() const;
00969 
00970     virtual NodeType
00971     getNodeType() const;
00972 
00973     virtual XalanNode*
00974     getParentNode() const;
00975 
00976     virtual const XalanNodeList*
00977     getChildNodes() const;
00978 
00979     virtual XalanNode*
00980     getFirstChild() const;
00981 
00982     virtual XalanNode*
00983     getLastChild() const;
00984 
00985     virtual XalanNode*
00986     getPreviousSibling() const;
00987 
00988     virtual XalanNode*
00989     getNextSibling() const;
00990 
00991     virtual const XalanNamedNodeMap*
00992     getAttributes() const;
00993 
00994     virtual XalanDocument*
00995     getOwnerDocument() const;
00996 
00997 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
00998     virtual XalanNode*
00999 #else
01000     virtual Stylesheet*
01001 #endif
01002     cloneNode(bool deep) const;
01003 
01004     virtual XalanNode*
01005     insertBefore(
01006             XalanNode*  newChild,
01007             XalanNode*  refChild);
01008 
01009     virtual XalanNode*
01010     replaceChild(
01011             XalanNode*  newChild,
01012             XalanNode*  oldChild);
01013 
01014     virtual XalanNode*
01015     removeChild(XalanNode*  oldChild);
01016 
01017     virtual XalanNode*
01018     appendChild(XalanNode*  newChild);
01019 
01020     virtual bool
01021     hasChildNodes() const;
01022 
01023     virtual void
01024     setNodeValue(const XalanDOMString&      nodeValue);
01025 
01026     virtual void
01027     normalize();
01028 
01029     virtual bool
01030     supports(
01031             const XalanDOMString&   feature,
01032             const XalanDOMString&   version) const;
01033 
01034     virtual const XalanDOMString&
01035     getNamespaceURI() const;
01036 
01037     virtual const XalanDOMString&
01038     getPrefix() const;
01039 
01040     virtual const XalanDOMString&
01041     getLocalName() const;
01042 
01043     virtual void
01044     setPrefix(const XalanDOMString& prefix);
01045 
01046     virtual unsigned long
01047     getIndex() const;
01048 
01049     virtual XalanElement*
01050     createElement(const XalanDOMString& tagName);
01051 
01052     virtual XalanDocumentFragment*
01053     createDocumentFragment();
01054 
01055     virtual XalanText*
01056     createTextNode(const XalanDOMString&    data);
01057 
01058     virtual XalanComment*
01059     createComment(const XalanDOMString& data);
01060 
01061     virtual XalanCDATASection*
01062     createCDATASection(const XalanDOMString&    data);
01063 
01064     virtual XalanProcessingInstruction*
01065     createProcessingInstruction(
01066             const XalanDOMString&   target,
01067             const XalanDOMString&   data);
01068 
01069     virtual XalanAttr*
01070     createAttribute(const XalanDOMString&   name);
01071 
01072     virtual XalanEntityReference*
01073     createEntityReference(const XalanDOMString &name);
01074 
01075     virtual XalanDocumentType*
01076     getDoctype() const;
01077 
01078     virtual XalanDOMImplementation*
01079     getImplementation() const;
01080 
01081     virtual XalanElement*
01082     getDocumentElement() const;
01083 
01084     virtual XalanNodeList*
01085     getElementsByTagName(const XalanDOMString&      tagname) const;
01086 
01087     virtual XalanNode*
01088     importNode(
01089             XalanNode*  importedNode,
01090             bool        deep);
01091 
01092     virtual XalanElement*
01093     createElementNS(
01094             const XalanDOMString&   namespaceURI,
01095             const XalanDOMString&   qualifiedName);
01096 
01097     virtual XalanAttr*
01098     createAttributeNS(
01099             const XalanDOMString& namespaceURI,
01100             const XalanDOMString& qualifiedName);
01101 
01102     virtual XalanNodeList*
01103     getElementsByTagNameNS(
01104             const XalanDOMString&   namespaceURI,
01105             const XalanDOMString&   localName) const;
01106 
01107     virtual XalanElement*
01108     getElementById(const XalanDOMString&    elementId) const;
01109 
01110     virtual bool
01111     isIndexed() const;
01112 
01113     // These interfaces are inherited from PrefixResolver...
01114 
01115     virtual const XalanDOMString&
01116     getNamespaceForPrefix(const XalanDOMString&     prefix) const;
01117 
01118     virtual const XalanDOMString&
01119     getURI() const;
01120 
01121     const XalanDOMString&
01122     getXSLTNamespaceURI() const
01123     {
01124         return m_XSLTNamespaceURI;
01125     }
01126 
01127     void
01128     setXSLTNamespaceURI(const XalanDOMString&   theURI)
01129     {
01130         m_XSLTNamespaceURI = theURI;
01131     }
01132 
01133 protected:
01134 
01138     StylesheetRoot&                     m_stylesheetRoot;
01139 
01143     bool                                m_needToBuildKeysTable;
01144 
01148     XalanDOMString                      m_baseIdent;
01149 
01154     KeyDeclarationVectorType            m_keyDeclarations;
01155 
01156 private:    
01157 
01158     // Not defined...
01159     Stylesheet(const Stylesheet&);
01160 
01161     Stylesheet&
01162     operator=(const Stylesheet&);
01163 
01164     bool
01165     operator==(const Stylesheet&) const;
01166 
01171     XalanDOMString                          m_XSLTNamespaceURI;
01172 
01176     XPathVectorType                         m_whitespacePreservingElements;
01177   
01181     XPathVectorType                         m_whitespaceStrippingElements;
01182 
01186     StylesheetVectorType                    m_imports;
01187 
01191     NamespacesStackType                     m_namespaces;
01192 
01197     NamespaceVectorType                     m_namespaceDecls;
01198 
01203     static const NamespaceVectorType        s_emptyNamespace;
01204 
01208     bool                                    m_tablesAreInvalid;
01209 
01214     bool                                    m_isWrapperless;
01215 
01219     ElemTemplate*                           m_wrapperlessTemplate;
01220   
01224     ExtensionNamespacesMapType              m_extensionNamespaces;
01225 
01226   
01230     ElemTemplateElement*                    m_firstTemplate;
01231   
01236     URLStackType                            m_includeStack;
01237 
01243     bool                                    m_defaultSpace;
01244   
01250     ElemTemplateMapType                     m_namedTemplates;
01251   
01255     ElemVariableVectorType                  m_topLevelVariables;
01256 
01257 
01261     double                                  m_XSLTVerDeclared;
01262 
01263     const bool                              m_isRoot;
01264 
01270     PatternTableMapType                     m_patternTable;
01271 
01276     PatternTableMapType::size_type          m_patternCount;
01277 
01281     AttributeSetMapType                     m_attributeSets;
01282 
01283     XalanNodeListSurrogate                  m_surrogateChildren;
01284 
01285     XalanEmptyNamedNodeMap                  m_fakeAttributes;
01286 
01287     ElemDecimalFormatVectorType             m_elemDecimalFormats;
01288 
01289     StringToStringMapType                   m_prefixAliases;
01290 
01291     NamespacesHandler                       m_namespacesHandler;
01292 
01293     static const XalanDOMString             s_emptyString;
01294 };
01295 
01296 
01297 
01298 #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.1
Copyright © 2000, 2001 The Apache Software Foundation. All Rights Reserved.