## 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.