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 <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 
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 NodeRefListBase;
00107 class PrefixResolver;
00108 class StylesheetConstructionContext;
00109 class StylesheetRoot;
00110 class XMLURL;
00111 class XObject;
00112 class XPath;
00113 class StylesheetExecutionContext;
00114 
00115 
00116 
00121 class XALAN_XSLT_EXPORT Stylesheet : public XalanDocument, protected PrefixResolver
00122 {   
00123 
00124 public:
00125 
00126     typedef StylesheetExecutionContext::ParamVectorType     ParamVectorType;
00127     typedef NamespacesHandler::NamespaceVectorType          NamespaceVectorType;
00128     typedef NamespacesHandler::NamespacesStackType          NamespacesStackType;
00129 
00130 #if defined(XALAN_NO_NAMESPACES)
00131     typedef map<XalanDOMString,
00132                 XalanDOMString,
00133                 less<XalanDOMString> >              StringToStringMapType;
00134     typedef map<XalanDOMString,
00135                 ExtensionNSHandler*,
00136                 less<XalanDOMString> >              ExtensionNamespacesMapType;
00137     typedef map<XalanQNameByReference,
00138                 ElemTemplate*,
00139                 less<XalanQName> >                  ElemTemplateMapType;
00140     typedef vector<ElemAttributeSet*>               AttributeSetVectorType;
00141     typedef vector<ElemVariable*>                   ElemVariableVectorType;
00142     typedef vector<KeyDeclaration>                  KeyDeclarationVectorType;
00143     typedef map<const XalanNode*,
00144                 KeyTable*,
00145                 less<const XalanNode*> >            KeyTablesTableType;
00146     typedef vector<XalanQNameByValue>               QNameVectorType;
00147     typedef vector<Stylesheet*>                     StylesheetVectorType;
00148     typedef vector<XalanDOMString>                  URLStackType;
00149     typedef vector<const XPath*>                    XPathVectorType;
00150     typedef vector<ElemDecimalFormat*>              ElemDecimalFormatVectorType;
00151 #else
00152     typedef std::map<XalanDOMString, XalanDOMString>        StringToStringMapType;
00153     typedef std::map<XalanDOMString, ExtensionNSHandler*>   ExtensionNamespacesMapType;
00154     typedef std::map<XalanQNameByReference, ElemTemplate*>  ElemTemplateMapType;
00155     typedef std::vector<ElemAttributeSet*>                  AttributeSetVectorType;
00156     typedef std::vector<ElemVariable*>                      ElemVariableVectorType;
00157     typedef std::vector<KeyDeclaration>                     KeyDeclarationVectorType;
00158     typedef std::map<const XalanNode*, KeyTable*>           KeyTablesTableType;
00159     typedef std::vector<XalanQNameByValue>                  QNameVectorType;
00160     typedef std::vector<Stylesheet*>                        StylesheetVectorType;
00161     typedef std::vector<XalanDOMString>                     URLStackType;
00162     typedef std::vector<const XPath*>                       XPathVectorType;
00163     typedef std::vector<ElemDecimalFormat*>                 ElemDecimalFormatVectorType;
00164 #endif
00165 
00171     Stylesheet(
00172             StylesheetRoot&                 root,
00173             const XalanDOMString&           baseIdentifier,
00174             StylesheetConstructionContext&  constructionContext);
00175 
00176     virtual
00177     ~Stylesheet();
00178 
00184     double
00185     getXSLTVerDeclared() const
00186     {
00187         return m_XSLTVerDeclared;
00188     }
00189 
00195     void
00196     setXSLTVerDeclared(double ver)
00197     {
00198         m_XSLTVerDeclared = ver;
00199     }
00200 
00206     const StylesheetRoot&
00207     getStylesheetRoot() const
00208     {
00209         return m_stylesheetRoot;
00210     }
00211 
00217     StylesheetRoot&
00218     getStylesheetRoot()
00219     {
00220         return m_stylesheetRoot;
00221     }
00222 
00228     const NamespacesStackType&
00229     getNamespaces() const
00230     { 
00231         return m_namespaces;
00232     }
00233 
00239     NamespacesStackType&
00240     getNamespaces()
00241     { 
00242         return m_namespaces;
00243     }
00244 
00245     const NamespacesHandler&
00246     getNamespacesHandler() const
00247     {
00248         return m_namespacesHandler;
00249     }
00250 
00251     NamespacesHandler&
00252     getNamespacesHandler()
00253     {
00254         return m_namespacesHandler;
00255     }
00256 
00262     const NamespaceVectorType&
00263     getNamespaceDecls() const
00264     {
00265         return m_namespaceDecls;
00266     }
00267 
00273     NamespaceVectorType&
00274     getNamespaceDecls()
00275     {
00276         return m_namespaceDecls;
00277     }
00278 
00284     void
00285     setNamespaceDecls(const NamespaceVectorType& ns)
00286     {
00287         m_namespaceDecls = ns;
00288     }
00289 
00290     /*
00291      * Get the top entry on the namespace stack, or 0, if
00292      * there is nothing on the stack.
00293      */
00294     const NamespaceVectorType&
00295     getCurrentNamespace() const
00296     {
00297         return m_namespaces.size() > 0 ? m_namespaces.back() : s_emptyNamespace;
00298     }
00299 
00306     void
00307     pushNamespaces(const AttributeList&     atts);
00308 
00312     void
00313     popNamespaces()
00314     {
00315         assert(m_namespaces.empty() == false);
00316 
00317         m_namespaces.pop_back(); 
00318     }
00319 
00323     virtual void
00324     postConstruction(StylesheetConstructionContext&     constructionContext);
00325 
00335     bool
00336     isAttrOK(
00337             const XalanDOMChar*             attrName,
00338             const AttributeList&            atts,
00339             int                             which,
00340             StylesheetConstructionContext&  constructionContext) const;
00341 
00348     const XalanDOMString*
00349     getNamespaceFromStack(const XalanDOMString&     nodeName) const
00350     {
00351         return getNamespaceFromStack(c_wstr(nodeName));
00352     }
00353 
00360     const XalanDOMString*
00361     getNamespaceFromStack(const XalanDOMChar*   nodeName) const;
00362 
00370     const XalanDOMString*
00371     getNamespaceForPrefixFromStack(const XalanDOMString&    prefix) const
00372     {
00373         return XalanQName::getNamespaceForPrefix(m_namespaces, prefix);
00374     }
00375 
00383     const XalanDOMString*
00384     getNamespaceForPrefixFromStack(const XalanDOMChar*  prefix) const
00385     {
00386         assert(prefix != 0);
00387 
00388         return XalanQName::getNamespaceForPrefix(m_namespaces, XalanDOMString(prefix));
00389     }
00390 
00397     XalanDOMString
00398     getAliasNamespaceURI(const XalanDOMChar*    uri) const;
00399 
00406     XalanDOMString
00407     getAliasNamespaceURI(const XalanDOMString&  uri) const;
00408 
00416     void
00417     processExcludeResultPrefixes(
00418         const XalanDOMChar*             theValue,
00419         StylesheetConstructionContext&  theConstructionContext)
00420     {
00421         m_namespacesHandler.processExcludeResultPrefixes(
00422                 theValue,
00423                 m_namespaces,
00424                 theConstructionContext);
00425     }
00426 
00433     void
00434     addTemplate(
00435             ElemTemplate*                   theTemplate,
00436             StylesheetConstructionContext&  constructionContext);
00437 
00446     bool
00447     getYesOrNo(
00448             const XalanDOMChar*             aname,
00449             const XalanDOMChar*             val,
00450             StylesheetConstructionContext&  constructionContext) const;
00451 
00457     bool
00458     isRoot() const
00459     {
00460         return m_isRoot;
00461     }
00462 
00468     const XalanDOMString&
00469     getBaseIdentifier() const
00470     {
00471         return m_baseIdent;
00472     }
00473 
00479     void
00480     setBaseIdentifier(const XalanDOMString&     str)
00481     {
00482         m_baseIdent = str;
00483     }
00484 
00493     const XalanDOMString&
00494     getCurrentIncludeBaseIdentifier() const
00495     {
00496         return m_includeStack.size() == 0 ? getBaseIdentifier() : m_includeStack.back();
00497     }
00498 
00506     void
00507     processNSAliasElement(
00508             const XalanDOMChar*             name,
00509             const AttributeList&            atts,
00510             StylesheetConstructionContext&  constructionContext);
00511 
00517     void
00518     processDecimalFormatElement(ElemDecimalFormat*  elemDecimalFormat)
00519     {
00520         assert(elemDecimalFormat != 0);
00521 
00522         m_elemDecimalFormats.push_back(elemDecimalFormat);
00523     }
00524 
00532     const XalanDecimalFormatSymbols*
00533     getDecimalFormatSymbols(const XalanDOMString&   name) const;
00534 
00540     void
00541     addAttributeSet(ElemAttributeSet*   attrSet)
00542     {
00543         assert(attrSet != 0);
00544 
00545         m_attributeSets.push_back(attrSet);
00546     }
00547 
00556     void
00557     applyAttrSets(
00558             const QNameVectorType&          attributeSetsNames,
00559             StylesheetExecutionContext&     executionContext,
00560             XalanNode*                      sourceNode) const;
00561 
00568     void
00569     addImport(
00570             Stylesheet*     theStylesheet,
00571             bool            fFront)
00572     {
00573         m_imports.insert(fFront ? m_imports.begin() : m_imports.end(), theStylesheet);
00574     }
00575 
00581     const ElemTemplate*
00582     getWrapperlessTemplate()
00583     {
00584         return m_wrapperlessTemplate;
00585     }
00586 
00592     void
00593     setWrapperlessTemplate(ElemTemplate*    templ)
00594     {
00595         m_wrapperlessTemplate = templ;
00596     }
00597 
00603     bool
00604     isWrapperless() const
00605     {
00606         return m_isWrapperless;
00607     }
00608 
00614     void
00615     setWrapperless(bool b)
00616     {
00617         m_isWrapperless = b;
00618     }
00619 
00625     URLStackType&
00626     getIncludeStack()
00627     {
00628         return m_includeStack;
00629     }
00630 
00638     /*
00639      * (Notes to myself)
00640      * What we need to do is:
00641      * 1) As this function is called, build a table of KeyDeclarations.
00642      * 2) During either XML processing, or upon request, walk the XML 
00643      * document tree, and build a hash table:
00644      * a) keyed by name,
00645      * b) each with a value of a hashtable, keyed by the value returned by 
00646      *    the use attribute,
00647      * c) each with a value that is a nodelist.
00648      * Thus, for a given key or keyref, look up hashtable by name, 
00649      * look up the nodelist by the given reference.
00650      */
00651     void
00652     processKeyElement(
00653             ElemTemplateElement*            nsContext,
00654             const AttributeList&            atts,
00655             StylesheetConstructionContext&  constructionContext);
00656 
00663     const ElemTemplate*
00664     findNamedTemplate(const XalanQName&     qname) const;
00665 
00674     const ElemTemplate*
00675     findTemplate(
00676             StylesheetExecutionContext&     executionContext,
00677             XalanNode*                      targetNode) const
00678     {
00679         return findTemplate(executionContext, targetNode, s_emptyQName, false);
00680     }
00681 
00692     const ElemTemplate*
00693     findTemplate(
00694             StylesheetExecutionContext&     executionContext,
00695             XalanNode*                      targetNode, 
00696             const XalanQName&               mode,
00697             bool                            onlyUseImports) const;
00698 
00703     class MatchPattern2
00704     {
00705     public:
00706 
00716         MatchPattern2(
00717                 const ElemTemplate&     theTemplate,
00718                 int                     posInStylesheet,
00719                 const XalanDOMString&   targetString,
00720                 const XPath&            matchPattern,
00721                 const XalanDOMString&   pattern) :
00722             m_template(&theTemplate),
00723             m_posInStylesheet(posInStylesheet),
00724             m_targetString(targetString),
00725             m_matchPattern(&matchPattern),
00726             m_pattern(&pattern)
00727         {
00728         }
00729 
00730         MatchPattern2() :
00731             m_template(0),
00732             m_posInStylesheet(0),
00733             m_targetString(),
00734             m_matchPattern(0),
00735             m_pattern(0)
00736         {
00737         }
00738 
00739         ~MatchPattern2()
00740         {
00741         }
00742 
00748         const XalanDOMString&
00749         getTargetString() const
00750         {
00751             return m_targetString;
00752         }
00753 
00759         const XPath*
00760         getExpression() const
00761         {
00762             return m_matchPattern;
00763         }
00764 
00770         int
00771         getPositionInStylesheet() const
00772         {
00773             return m_posInStylesheet;
00774         }
00775 
00781         const XalanDOMString*
00782         getPattern() const
00783         {
00784             return m_pattern;
00785         }
00786 
00792         const ElemTemplate*
00793         getTemplate() const
00794         {
00795             return m_template;
00796         }
00797 
00798     private:
00799 
00800         const ElemTemplate*     m_template;
00801         int                     m_posInStylesheet;
00802         XalanDOMString          m_targetString;
00803         const XPath*            m_matchPattern;
00804         const XalanDOMString*   m_pattern;
00805     };
00806 
00807 #if defined(XALAN_NO_NAMESPACES)
00808     typedef vector<const MatchPattern2*>        PatternTableListType;
00809 
00810     typedef vector<const MatchPattern2*>        PatternTableVectorType;
00811 
00812     typedef map<XalanDOMString,
00813                 PatternTableListType,
00814                 less<XalanDOMString> >          PatternTableMapType;
00815 
00816     typedef deque<MatchPattern2>                MatchPattern2Container;
00817 #else
00818     typedef std::vector<const MatchPattern2*>   PatternTableListType;
00819 
00820     typedef std::vector<const MatchPattern2*>   PatternTableVectorType;
00821 
00822     typedef std::map<XalanDOMString,
00823                      PatternTableListType>      PatternTableMapType;
00824 
00825     typedef std::deque<MatchPattern2>           MatchPattern2Container;
00826 #endif
00827 
00834     static void
00835     addObjectIfNotFound(
00836             const MatchPattern2*        thePattern,
00837             PatternTableVectorType&     theVector);
00838 
00848     static void
00849     addObjectIfNotFound(
00850             const MatchPattern2*    thePattern,
00851             const MatchPattern2*    theArray[],
00852             unsigned int&           theArraySize);
00853 
00861     const PatternTableListType*
00862     locateMatchPatternList2(const XalanDOMString&   theName) const;
00863 
00870     const PatternTableListType*
00871     locateMatchPatternList2(const XalanNode&    theNode) const;
00872 
00881     void
00882     addExtensionNamespace(
00883             const XalanDOMString&   uri,
00884             ExtensionNSHandler*     nsh);
00885 
00892     ExtensionNSHandler*
00893     lookupExtensionNSHandler(const XalanDOMString&  uri) const
00894     {
00895         const ExtensionNamespacesMapType::const_iterator    it = 
00896           m_extensionNamespaces.find(uri);
00897 
00898         return it == m_extensionNamespaces.end() ? 0 : (*it).second;
00899     }
00900 
00908     void
00909     setTopLevelVariable(ElemVariable*   var)
00910     {
00911         m_topLevelVariables.push_back(var);
00912     }
00913 
00921     void
00922     pushTopLevelVariables(
00923             StylesheetExecutionContext&     executionContext,
00924             const ParamVectorType&          topLevelParams) const;
00925 
00926     const XPathVectorType&
00927     getWhitespacePreservingElements() const
00928     {
00929         return m_whitespacePreservingElements;
00930     }
00931 
00932     void
00933     pushWhitespacePreservingElement(const XPath*    theXPath)
00934     {
00935         m_whitespacePreservingElements.push_back(theXPath);
00936     }
00937 
00938     const XPathVectorType&
00939     getWhitespaceStrippingElements() const
00940     {
00941         return m_whitespaceStrippingElements;
00942     }
00943 
00944     void
00945     pushWhitespaceStrippingElement(const XPath* theXPath)
00946     {
00947         m_whitespaceStrippingElements.push_back(theXPath);
00948     }
00949 
00950     // These interfaces are inherited from XalanDocument...
00951 
00952     virtual const XalanDOMString&
00953     getNodeName() const;
00954 
00955     virtual const XalanDOMString&
00956     getNodeValue() const;
00957 
00958     virtual NodeType
00959     getNodeType() const;
00960 
00961     virtual XalanNode*
00962     getParentNode() const;
00963 
00964     virtual const XalanNodeList*
00965     getChildNodes() const;
00966 
00967     virtual XalanNode*
00968     getFirstChild() const;
00969 
00970     virtual XalanNode*
00971     getLastChild() const;
00972 
00973     virtual XalanNode*
00974     getPreviousSibling() const;
00975 
00976     virtual XalanNode*
00977     getNextSibling() const;
00978 
00979     virtual const XalanNamedNodeMap*
00980     getAttributes() const;
00981 
00982     virtual XalanDocument*
00983     getOwnerDocument() const;
00984 
00985 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
00986     virtual XalanNode*
00987 #else
00988     virtual Stylesheet*
00989 #endif
00990     cloneNode(bool deep) const;
00991 
00992     virtual XalanNode*
00993     insertBefore(
00994             XalanNode*  newChild,
00995             XalanNode*  refChild);
00996 
00997     virtual XalanNode*
00998     replaceChild(
00999             XalanNode*  newChild,
01000             XalanNode*  oldChild);
01001 
01002     virtual XalanNode*
01003     removeChild(XalanNode*  oldChild);
01004 
01005     virtual XalanNode*
01006     appendChild(XalanNode*  newChild);
01007 
01008     virtual bool
01009     hasChildNodes() const;
01010 
01011     virtual void
01012     setNodeValue(const XalanDOMString&      nodeValue);
01013 
01014     virtual void
01015     normalize();
01016 
01017     virtual bool
01018     supports(
01019             const XalanDOMString&   feature,
01020             const XalanDOMString&   version) const;
01021 
01022     virtual const XalanDOMString&
01023     getNamespaceURI() const;
01024 
01025     virtual const XalanDOMString&
01026     getPrefix() const;
01027 
01028     virtual const XalanDOMString&
01029     getLocalName() const;
01030 
01031     virtual void
01032     setPrefix(const XalanDOMString& prefix);
01033 
01034     virtual unsigned long
01035     getIndex() const;
01036 
01037     virtual XalanElement*
01038     createElement(const XalanDOMString& tagName);
01039 
01040     virtual XalanDocumentFragment*
01041     createDocumentFragment();
01042 
01043     virtual XalanText*
01044     createTextNode(const XalanDOMString&    data);
01045 
01046     virtual XalanComment*
01047     createComment(const XalanDOMString& data);
01048 
01049     virtual XalanCDATASection*
01050     createCDATASection(const XalanDOMString&    data);
01051 
01052     virtual XalanProcessingInstruction*
01053     createProcessingInstruction(
01054             const XalanDOMString&   target,
01055             const XalanDOMString&   data);
01056 
01057     virtual XalanAttr*
01058     createAttribute(const XalanDOMString&   name);
01059 
01060     virtual XalanEntityReference*
01061     createEntityReference(const XalanDOMString &name);
01062 
01063     virtual XalanDocumentType*
01064     getDoctype() const;
01065 
01066     virtual XalanDOMImplementation*
01067     getImplementation() const;
01068 
01069     virtual XalanElement*
01070     getDocumentElement() const;
01071 
01072     virtual XalanNodeList*
01073     getElementsByTagName(const XalanDOMString&      tagname) const;
01074 
01075     virtual XalanNode*
01076     importNode(
01077             XalanNode*  importedNode,
01078             bool        deep);
01079 
01080     virtual XalanElement*
01081     createElementNS(
01082             const XalanDOMString&   namespaceURI,
01083             const XalanDOMString&   qualifiedName);
01084 
01085     virtual XalanAttr*
01086     createAttributeNS(
01087             const XalanDOMString& namespaceURI,
01088             const XalanDOMString& qualifiedName);
01089 
01090     virtual XalanNodeList*
01091     getElementsByTagNameNS(
01092             const XalanDOMString&   namespaceURI,
01093             const XalanDOMString&   localName) const;
01094 
01095     virtual XalanElement*
01096     getElementById(const XalanDOMString&    elementId) const;
01097 
01098     virtual unsigned long
01099     getNumber() const;
01100 
01101     virtual bool
01102     isIndexed() const;
01103 
01104     // These interfaces are inherited from PrefixResolver...
01105 
01106     virtual const XalanDOMString*
01107     getNamespaceForPrefix(const XalanDOMString&     prefix) const;
01108 
01109     virtual const XalanDOMString&
01110     getURI() const;
01111 
01112     const XalanDOMString&
01113     getXSLTNamespaceURI() const
01114     {
01115         return m_XSLTNamespaceURI;
01116     }
01117 
01118     void
01119     setXSLTNamespaceURI(const XalanDOMString&   theURI)
01120     {
01121         m_XSLTNamespaceURI = theURI;
01122     }
01123 
01124 protected:
01125 
01129     StylesheetRoot&                     m_stylesheetRoot;
01130 
01134     XalanDOMString                      m_baseIdent;
01135 
01140     KeyDeclarationVectorType            m_keyDeclarations;
01141 
01142     static const XalanQNameByReference  s_emptyQName;
01143 
01144 private:    
01145 
01146     // Not defined...
01147     Stylesheet(const Stylesheet&);
01148 
01149     Stylesheet&
01150     operator=(const Stylesheet&);
01151 
01152     bool
01153     operator==(const Stylesheet&) const;
01154 
01159     XalanDOMString                          m_XSLTNamespaceURI;
01160 
01164     XPathVectorType                         m_whitespacePreservingElements;
01165   
01169     XPathVectorType                         m_whitespaceStrippingElements;
01170 
01174     StylesheetVectorType                    m_imports;
01175 
01176     StylesheetVectorType::size_type         m_importsSize;
01177 
01181     NamespacesStackType                     m_namespaces;
01182 
01187     NamespaceVectorType                     m_namespaceDecls;
01188 
01193     static const NamespaceVectorType        s_emptyNamespace;
01194 
01199     bool                                    m_isWrapperless;
01200 
01204     ElemTemplate*                           m_wrapperlessTemplate;
01205   
01209     ExtensionNamespacesMapType              m_extensionNamespaces;
01210 
01211   
01215     ElemTemplateElement*                    m_firstTemplate;
01216   
01221     URLStackType                            m_includeStack;
01222 
01228     ElemTemplateMapType                     m_namedTemplates;
01229 
01233     ElemVariableVectorType                  m_topLevelVariables;
01234 
01238     double                                  m_XSLTVerDeclared;
01239 
01240     const bool                              m_isRoot;
01241 
01247     PatternTableMapType                         m_patternTable;
01248 
01249     const PatternTableMapType::const_iterator   m_patternTableEnd;
01250 
01254     PatternTableListType                    m_textPatternList;
01255 
01256     PatternTableListType                    m_commentPatternList;
01257 
01258     PatternTableListType                    m_rootPatternList;
01259 
01260     PatternTableListType                    m_piPatternList;
01261 
01268     PatternTableListType                    m_nodePatternList;
01269 
01273     PatternTableListType                    m_anyPatternList;
01274 
01279     MatchPattern2Container                  m_matchPattern2Container;
01280 
01284     MatchPattern2Container::size_type       m_patternCount;
01285 
01286     AttributeSetVectorType                  m_attributeSets;
01287 
01288     AttributeSetVectorType::size_type       m_attributeSetsSize;
01289 
01290     XalanNodeListSurrogate                  m_surrogateChildren;
01291 
01292     ElemDecimalFormatVectorType             m_elemDecimalFormats;
01293 
01294     StringToStringMapType                   m_prefixAliases;
01295 
01296     NamespacesHandler                       m_namespacesHandler;
01297 
01298     static const XalanDOMString             s_emptyString;
01299 
01300     static const XalanEmptyNamedNodeMap     s_fakeAttributes;
01301 };
01302 
01303 
01304 
01305 #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.