Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.6

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 <xalanc/XalanDOM/XalanNode.hpp>
00078 
00079 
00080 #include <xalanc/PlatformSupport/PrefixResolver.hpp>
00081 
00082 
00083 
00084 #include <xalanc/XPath/NameSpace.hpp>
00085 #include <xalanc/XPath/XalanQNameByReference.hpp>
00086 #include <xalanc/XPath/XPath.hpp>
00087 
00088 
00089 
00090 #include <xalanc/XSLT/NamespacesHandler.hpp>
00091 #include <xalanc/XSLT/KeyDeclaration.hpp>
00092 #include <xalanc/XSLT/StylesheetExecutionContext.hpp>
00093 
00094 
00095 
00096 XALAN_CPP_NAMESPACE_BEGIN
00097 
00098 
00099 
00100 class ExtensionNSHandler;
00101 class XalanDecimalFormatSymbols;
00102 class ElemAttributeSet;
00103 class ElemDecimalFormat;
00104 class ElemTemplate;
00105 class ElemTemplateElement;
00106 class ElemVariable;
00107 class KeyTable;
00108 class NodeRefListBase;
00109 class PrefixResolver;
00110 class StylesheetConstructionContext;
00111 class StylesheetRoot;
00112 class XalanQName;
00113 class XObject;
00114 class StylesheetExecutionContext;
00115 
00116 
00117 
00122 class XALAN_XSLT_EXPORT Stylesheet : protected PrefixResolver
00123 {   
00124 
00125 public:
00126 
00127 #if defined(XALAN_STRICT_ANSI_HEADERS)
00128     typedef std::size_t     size_type;
00129 #else
00130     typedef size_t          size_type;
00131 #endif
00132 
00133     typedef StylesheetExecutionContext::ParamVectorType     ParamVectorType;
00134     typedef XalanQName::NamespaceVectorType                 NamespaceVectorType;
00135     typedef XalanQName::NamespacesStackType                 NamespacesStackType;
00136 
00137 #if defined(XALAN_NO_STD_NAMESPACE)
00138     typedef map<XalanDOMString,
00139                 ExtensionNSHandler*,
00140                 less<XalanDOMString> >              ExtensionNamespacesMapType;
00141     typedef map<XalanQNameByReference,
00142                 const ElemTemplate*,
00143                 less<XalanQName> >                  ElemTemplateMapType;
00144     typedef vector<ElemAttributeSet*>               AttributeSetVectorType;
00145     typedef vector<ElemVariable*>                   ElemVariableVectorType;
00146     typedef vector<KeyDeclaration>                  KeyDeclarationVectorType;
00147     typedef map<const XalanNode*,
00148                 KeyTable*,
00149                 less<const XalanNode*> >            KeyTablesTableType;
00150     typedef vector<Stylesheet*>                     StylesheetVectorType;
00151     typedef vector<XalanDOMString>                  URLStackType;
00152     typedef vector<ElemDecimalFormat*>              ElemDecimalFormatVectorType;
00153 #else
00154     typedef std::map<XalanDOMString, ExtensionNSHandler*>   ExtensionNamespacesMapType;
00155     typedef std::map<XalanQNameByReference,
00156                      const ElemTemplate*,
00157                      std::less<XalanQName> >                ElemTemplateMapType;
00158     typedef std::vector<ElemAttributeSet*>                  AttributeSetVectorType;
00159     typedef std::vector<ElemVariable*>                      ElemVariableVectorType;
00160     typedef std::vector<KeyDeclaration>                     KeyDeclarationVectorType;
00161     typedef std::map<const XalanNode*, KeyTable*>           KeyTablesTableType;
00162     typedef std::vector<Stylesheet*>                        StylesheetVectorType;
00163     typedef std::vector<XalanDOMString>                     URLStackType;
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 
00297     void
00298     pushNamespaces(const AttributeListType&     atts);
00299 
00303     void
00304     popNamespaces()
00305     {
00306         assert(m_namespaces.empty() == false);
00307 
00308         m_namespaces.pop_back(); 
00309     }
00310 
00314     virtual void
00315     postConstruction(StylesheetConstructionContext&     constructionContext);
00316 
00326     bool
00327     isAttrOK(
00328             const XalanDOMChar*             attrName,
00329             const AttributeListType&        atts,
00330             int                             which,
00331             StylesheetConstructionContext&  constructionContext) const;
00332 
00339     const XalanDOMString*
00340     getNamespaceFromStack(const XalanDOMString&     nodeName) const
00341     {
00342         return getNamespaceFromStack(c_wstr(nodeName));
00343     }
00344 
00351     const XalanDOMString*
00352     getNamespaceFromStack(const XalanDOMChar*   nodeName) const;
00353 
00361     const XalanDOMString*
00362     getNamespaceForPrefixFromStack(const XalanDOMString&    prefix) const
00363     {
00364         return XalanQName::getNamespaceForPrefix(m_namespaces, prefix);
00365     }
00366 
00374     const XalanDOMString*
00375     getNamespaceForPrefixFromStack(const XalanDOMChar*  prefix) const
00376     {
00377         assert(prefix != 0);
00378 
00379         return XalanQName::getNamespaceForPrefix(m_namespaces, XalanDOMString(prefix));
00380     }
00381 
00389     void
00390     processExcludeResultPrefixes(
00391         StylesheetConstructionContext&  theConstructionContext,
00392         const XalanDOMChar*             theValue)
00393     {
00394         m_namespacesHandler.processExcludeResultPrefixes(
00395                 theConstructionContext,
00396                 theValue,
00397                 m_namespaces);
00398     }
00399 
00406     void
00407     addTemplate(
00408             ElemTemplate*                   theTemplate,
00409             StylesheetConstructionContext&  constructionContext);
00410 
00419     bool
00420     getYesOrNo(
00421             const XalanDOMChar*             aname,
00422             const XalanDOMChar*             val,
00423             StylesheetConstructionContext&  constructionContext) const;
00424 
00430     const XalanDOMString&
00431     getBaseIdentifier() const
00432     {
00433         return m_baseIdent;
00434     }
00435 
00441     void
00442     setBaseIdentifier(const XalanDOMString&     str)
00443     {
00444         m_baseIdent = str;
00445     }
00446 
00455     const XalanDOMString&
00456     getCurrentIncludeBaseIdentifier() const
00457     {
00458         return m_includeStack.empty() == true ? getBaseIdentifier() : m_includeStack.back();
00459     }
00460 
00468     void
00469     processNSAliasElement(
00470             const XalanDOMChar*             name,
00471             const AttributeListType&        atts,
00472             StylesheetConstructionContext&  constructionContext);
00473 
00479     void
00480     processDecimalFormatElement(
00481             StylesheetConstructionContext&  constructionContext,
00482             const AttributeListType&        atts,
00483             const LocatorType*              locator = 0);
00484 
00492     const XalanDecimalFormatSymbols*
00493     getDecimalFormatSymbols(const XalanQName&   theQName) const;
00494 
00500     void
00501     addAttributeSet(ElemAttributeSet*   attrSet)
00502     {
00503         assert(attrSet != 0);
00504 
00505         m_attributeSets.push_back(attrSet);
00506     }
00507 
00517     void
00518     applyAttrSets(
00519             const XalanQName**              attributeSetsNames,
00520             size_type                       attributeSetsNamesCount,
00521             StylesheetExecutionContext&     executionContext,
00522             XalanNode*                      sourceNode) const;
00523 
00529     void
00530     addImport(Stylesheet*   theStylesheet)
00531     {
00532         m_imports.insert(m_imports.begin(), theStylesheet);
00533     }
00534 
00540     bool
00541     isWrapperless() const
00542     {
00543         return m_isWrapperless;
00544     }
00545 
00546     ElemTemplateElement*
00547     initWrapperless(
00548             StylesheetConstructionContext&  constructionContext,
00549             const LocatorType*              locator);
00550 
00556     URLStackType&
00557     getIncludeStack()
00558     {
00559         return m_includeStack;
00560     }
00561 
00570     void
00571     processKeyElement(
00572             const PrefixResolver&           nsContext,
00573             const AttributeListType&        atts,
00574             const LocatorType*              locator,
00575             StylesheetConstructionContext&  constructionContext);
00576 
00583     const ElemTemplate*
00584     findNamedTemplate(const XalanQName&     qname) const;
00585 
00594     const ElemTemplate*
00595     findTemplate(
00596             StylesheetExecutionContext&     executionContext,
00597             XalanNode*                      targetNode) const
00598     {
00599         assert(targetNode != 0);
00600 
00601         return findTemplate(
00602                 executionContext,
00603                 targetNode,
00604                 targetNode->getNodeType(),
00605                 s_emptyQName,
00606                 false);
00607     }
00608 
00620     const ElemTemplate*
00621     findTemplate(
00622             StylesheetExecutionContext&     executionContext,
00623             XalanNode*                      targetNode,
00624             XalanNode::NodeType             targetNodeType,
00625             const XalanQName&               mode,
00626             bool                            onlyUseImports) const;
00627 
00632     class MatchPattern2
00633     {
00634     public:
00635 
00636         typedef XPath::eMatchScore  eMatchScore;
00637 
00648         MatchPattern2(
00649                 const ElemTemplate&     theTemplate,
00650                 size_type               posInStylesheet,
00651                 const XalanDOMString&   targetString,
00652                 const XPath&            matchPattern,
00653                 const XalanDOMString&   pattern,
00654                 eMatchScore             priority) :
00655             m_template(&theTemplate),
00656             m_posInStylesheet(posInStylesheet),
00657             m_targetString(targetString),
00658             m_matchPattern(&matchPattern),
00659             m_pattern(&pattern),
00660             m_priority(priority)
00661         {
00662         }
00663 
00664         MatchPattern2() :
00665             m_template(0),
00666             m_posInStylesheet(0),
00667             m_targetString(),
00668             m_matchPattern(0),
00669             m_pattern(0),
00670             m_priority(XPath::eMatchScoreNone)
00671         {
00672         }
00673 
00674         ~MatchPattern2()
00675         {
00676         }
00677 
00683         const XalanDOMString&
00684         getTargetString() const
00685         {
00686             return m_targetString;
00687         }
00688 
00694         const XPath*
00695         getExpression() const
00696         {
00697             return m_matchPattern;
00698         }
00699 
00705         size_type
00706         getPositionInStylesheet() const
00707         {
00708             return m_posInStylesheet;
00709         }
00710 
00716         const XalanDOMString*
00717         getPattern() const
00718         {
00719             return m_pattern;
00720         }
00721 
00727         const ElemTemplate*
00728         getTemplate() const
00729         {
00730             return m_template;
00731         }
00732 
00733         eMatchScore
00734         getDefaultPriority() const
00735         {
00736             return m_priority;
00737         }
00738 
00739         double
00740         getPriorityOrDefault() const;
00741 
00742     private:
00743 
00744         const ElemTemplate*     m_template;
00745         size_type               m_posInStylesheet;
00746         XalanDOMString          m_targetString;
00747         const XPath*            m_matchPattern;
00748         const XalanDOMString*   m_pattern;
00749         eMatchScore             m_priority;
00750     };
00751 
00752 #if defined(XALAN_NO_STD_NAMESPACE)
00753     typedef vector<const MatchPattern2*>        PatternTableVectorType;
00754 
00755     typedef map<XalanDOMString,
00756                 PatternTableVectorType,
00757                 less<XalanDOMString> >          PatternTableMapType;
00758 
00759     typedef deque<MatchPattern2>                MatchPattern2Container;
00760 #else
00761     typedef std::vector<const MatchPattern2*>   PatternTableVectorType;
00762 
00763     typedef std::map<XalanDOMString,
00764                      PatternTableVectorType>    PatternTableMapType;
00765 
00766     typedef std::deque<MatchPattern2>           MatchPattern2Container;
00767 #endif
00768 
00775     static void
00776     addObjectIfNotFound(
00777             const MatchPattern2*        thePattern,
00778             PatternTableVectorType&     theVector);
00779 
00789     static void
00790     addObjectIfNotFound(
00791             const MatchPattern2*    thePattern,
00792             const MatchPattern2*    theArray[],
00793             unsigned int&           theArraySize);
00794 
00802     const PatternTableVectorType*
00803     locateElementMatchPatternList2(const XalanDOMString&    theName) const;
00804 
00812     const PatternTableVectorType*
00813     locateAttributeMatchPatternList2(const XalanDOMString&  theName) const;
00814 
00821     const PatternTableVectorType*
00822     locateMatchPatternList2(
00823             const XalanNode&        theNode,
00824             XalanNode::NodeType     targetNodeType) const;
00825 
00834     void
00835     processExtensionNamespace(
00836             StylesheetConstructionContext&  theConstructionContext,
00837             const XalanDOMString&           uri);
00838 
00845     ExtensionNSHandler*
00846     lookupExtensionNSHandler(const XalanDOMString&  uri) const
00847     {
00848         const ExtensionNamespacesMapType::const_iterator    it = 
00849           m_extensionNamespaces.find(uri);
00850 
00851         return it == m_extensionNamespaces.end() ? 0 : (*it).second;
00852     }
00853 
00860     void
00861     setTopLevelVariable(ElemVariable*   var)
00862     {
00863         m_topLevelVariables.push_back(var);
00864     }
00865 
00873     void
00874     pushTopLevelVariables(
00875             StylesheetExecutionContext&     executionContext,
00876             const ParamVectorType&          topLevelParams) const;
00877 
00878 
00879     // These interfaces are inherited from PrefixResolver...
00880 
00881     virtual const XalanDOMString*
00882     getNamespaceForPrefix(const XalanDOMString&     prefix) const;
00883 
00884     virtual const XalanDOMString&
00885     getURI() const;
00886 
00887     const XalanDOMString&
00888     getXSLTNamespaceURI() const
00889     {
00890         return m_XSLTNamespaceURI;
00891     }
00892 
00893     void
00894     setXSLTNamespaceURI(const XalanDOMString&   theURI)
00895     {
00896         m_XSLTNamespaceURI = theURI;
00897     }
00898 
00899 protected:
00900 
00904     StylesheetRoot&                     m_stylesheetRoot;
00905 
00909     XalanDOMString                      m_baseIdent;
00910 
00915     KeyDeclarationVectorType            m_keyDeclarations;
00916 
00917     static const XalanQNameByReference  s_emptyQName;
00918 
00919 private:    
00920 
00921     // Not defined...
00922     Stylesheet(const Stylesheet&);
00923 
00924     Stylesheet&
00925     operator=(const Stylesheet&);
00926 
00927     bool
00928     operator==(const Stylesheet&) const;
00929 
00930 
00941     const ElemTemplate*
00942     findTemplateInImports(
00943             StylesheetExecutionContext&     executionContext,
00944             XalanNode*                      targetNode,
00945             XalanNode::NodeType             targetNodeType,
00946             const XalanQName&               mode) const;
00947 
00952     XalanDOMString                          m_XSLTNamespaceURI;
00953 
00957     StylesheetVectorType                    m_imports;
00958 
00959     StylesheetVectorType::size_type         m_importsSize;
00960 
00964     NamespacesStackType                     m_namespaces;
00965 
00970     NamespaceVectorType                     m_namespaceDecls;
00971 
00976     bool                                    m_isWrapperless;
00977 
00981     ExtensionNamespacesMapType              m_extensionNamespaces;
00982 
00986     ElemTemplate*                           m_firstTemplate;
00987 
00992     URLStackType                            m_includeStack;
00993 
00999     ElemTemplateMapType                     m_namedTemplates;
01000 
01004     ElemVariableVectorType                  m_topLevelVariables;
01005 
01009     double                                  m_XSLTVerDeclared;
01010 
01016     PatternTableMapType                         m_elementPatternTable;
01017 
01018     const PatternTableMapType::const_iterator   m_elementPatternTableEnd;
01019 
01020     PatternTableVectorType                      m_elementAnyPatternList;
01021 
01027     PatternTableMapType                         m_attributePatternTable;
01028 
01029     const PatternTableMapType::const_iterator   m_attributePatternTableEnd;
01030 
01031     PatternTableVectorType                      m_attributeAnyPatternList;
01032 
01036     PatternTableVectorType                  m_textPatternList;
01037 
01038     PatternTableVectorType                  m_commentPatternList;
01039 
01040     PatternTableVectorType                  m_rootPatternList;
01041 
01042     PatternTableVectorType                  m_piPatternList;
01043 
01047     PatternTableVectorType                  m_nodePatternList;
01048 
01053     MatchPattern2Container                  m_matchPattern2Container;
01054 
01058     MatchPattern2Container::size_type       m_patternCount;
01059 
01060     AttributeSetVectorType                  m_attributeSets;
01061 
01065     AttributeSetVectorType::size_type       m_attributeSetsSize;
01066 
01067     ElemDecimalFormatVectorType             m_elemDecimalFormats;
01068 
01069     NamespacesHandler                       m_namespacesHandler;
01070 
01071     static const XalanDOMString             s_emptyString;
01072 };
01073 
01074 
01075 
01076 XALAN_CPP_NAMESPACE_END
01077 
01078 
01079 
01080 #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.6
Copyright © 2000, 2001, 2002, 2003 The Apache Software Foundation. All Rights Reserved.