Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.7

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-2004 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 ElemDecimalFormat;
00103 class ElemTemplate;
00104 class ElemTemplateElement;
00105 class ElemVariable;
00106 class KeyTable;
00107 class NodeRefListBase;
00108 class PrefixResolver;
00109 class StylesheetConstructionContext;
00110 class StylesheetRoot;
00111 class XalanQName;
00112 class XObject;
00113 class StylesheetExecutionContext;
00114 
00115 
00116 
00121 class XALAN_XSLT_EXPORT Stylesheet : protected PrefixResolver
00122 {   
00123 
00124 public:
00125 
00126 #if defined(XALAN_STRICT_ANSI_HEADERS)
00127     typedef std::size_t     size_type;
00128 #else
00129     typedef size_t          size_type;
00130 #endif
00131 
00132     typedef StylesheetExecutionContext::ParamVectorType     ParamVectorType;
00133     typedef XalanQName::NamespaceVectorType                 NamespaceVectorType;
00134     typedef XalanQName::NamespacesStackType                 NamespacesStackType;
00135 
00136 #if defined(XALAN_NO_STD_NAMESPACE)
00137     typedef map<XalanDOMString,
00138                 ExtensionNSHandler*,
00139                 less<XalanDOMString> >              ExtensionNamespacesMapType;
00140     typedef map<XalanQNameByReference,
00141                 const ElemTemplate*,
00142                 less<XalanQName> >                  ElemTemplateMapType;
00143     typedef vector<ElemVariable*>                   ElemVariableVectorType;
00144     typedef vector<KeyDeclaration>                  KeyDeclarationVectorType;
00145     typedef map<const XalanNode*,
00146                 KeyTable*,
00147                 less<const XalanNode*> >            KeyTablesTableType;
00148     typedef vector<Stylesheet*>                     StylesheetVectorType;
00149     typedef vector<XalanDOMString>                  URLStackType;
00150     typedef vector<ElemDecimalFormat*>              ElemDecimalFormatVectorType;
00151 #else
00152     typedef std::map<XalanDOMString, ExtensionNSHandler*>   ExtensionNamespacesMapType;
00153     typedef std::map<XalanQNameByReference,
00154                      const ElemTemplate*,
00155                      std::less<XalanQName> >                ElemTemplateMapType;
00156     typedef std::vector<ElemVariable*>                      ElemVariableVectorType;
00157     typedef std::vector<KeyDeclaration>                     KeyDeclarationVectorType;
00158     typedef std::map<const XalanNode*, KeyTable*>           KeyTablesTableType;
00159     typedef std::vector<Stylesheet*>                        StylesheetVectorType;
00160     typedef std::vector<XalanDOMString>                     URLStackType;
00161     typedef std::vector<ElemDecimalFormat*>                 ElemDecimalFormatVectorType;
00162 #endif
00163 
00169     Stylesheet(
00170             StylesheetRoot&                 root,
00171             const XalanDOMString&           baseIdentifier,
00172             StylesheetConstructionContext&  constructionContext);
00173 
00174     virtual
00175     ~Stylesheet();
00176 
00182     double
00183     getXSLTVerDeclared() const
00184     {
00185         return m_XSLTVerDeclared;
00186     }
00187 
00193     void
00194     setXSLTVerDeclared(double ver)
00195     {
00196         m_XSLTVerDeclared = ver;
00197     }
00198 
00204     const StylesheetRoot&
00205     getStylesheetRoot() const
00206     {
00207         return m_stylesheetRoot;
00208     }
00209 
00215     StylesheetRoot&
00216     getStylesheetRoot()
00217     {
00218         return m_stylesheetRoot;
00219     }
00220 
00226     const NamespacesStackType&
00227     getNamespaces() const
00228     { 
00229         return m_namespaces;
00230     }
00231 
00237     NamespacesStackType&
00238     getNamespaces()
00239     { 
00240         return m_namespaces;
00241     }
00242 
00243     const NamespacesHandler&
00244     getNamespacesHandler() const
00245     {
00246         return m_namespacesHandler;
00247     }
00248 
00249     NamespacesHandler&
00250     getNamespacesHandler()
00251     {
00252         return m_namespacesHandler;
00253     }
00254 
00260     const NamespaceVectorType&
00261     getNamespaceDecls() const
00262     {
00263         return m_namespaceDecls;
00264     }
00265 
00271     NamespaceVectorType&
00272     getNamespaceDecls()
00273     {
00274         return m_namespaceDecls;
00275     }
00276 
00282     void
00283     setNamespaceDecls(const NamespaceVectorType& ns)
00284     {
00285         m_namespaceDecls = ns;
00286     }
00287 
00294     void
00295     pushNamespaces(const AttributeListType&     atts);
00296 
00300     void
00301     popNamespaces()
00302     {
00303         assert(m_namespaces.empty() == false);
00304 
00305         m_namespaces.pop_back(); 
00306     }
00307 
00311     virtual void
00312     postConstruction(StylesheetConstructionContext&     constructionContext);
00313 
00323     bool
00324     isAttrOK(
00325             const XalanDOMChar*             attrName,
00326             const AttributeListType&        atts,
00327             int                             which,
00328             StylesheetConstructionContext&  constructionContext) const;
00329 
00336     const XalanDOMString*
00337     getNamespaceFromStack(const XalanDOMString&     nodeName) const
00338     {
00339         return getNamespaceFromStack(c_wstr(nodeName));
00340     }
00341 
00348     const XalanDOMString*
00349     getNamespaceFromStack(const XalanDOMChar*   nodeName) const;
00350 
00358     const XalanDOMString*
00359     getNamespaceForPrefixFromStack(const XalanDOMString&    prefix) const
00360     {
00361         return XalanQName::getNamespaceForPrefix(m_namespaces, prefix);
00362     }
00363 
00371     const XalanDOMString*
00372     getNamespaceForPrefixFromStack(const XalanDOMChar*  prefix) const
00373     {
00374         assert(prefix != 0);
00375 
00376         return XalanQName::getNamespaceForPrefix(m_namespaces, XalanDOMString(prefix));
00377     }
00378 
00386     const XalanDOMString*
00387     getNamespaceForPrefix(
00388             const XalanDOMString&           prefix,
00389             StylesheetConstructionContext&  constructionContext) const;
00390 
00398     const XalanDOMString*
00399     getNamespaceForPrefix(
00400             const XalanDOMChar*             prefix,
00401             StylesheetConstructionContext&  constructionContext) const;
00402 
00410     void
00411     processExcludeResultPrefixes(
00412         StylesheetConstructionContext&  theConstructionContext,
00413         const XalanDOMChar*             theValue)
00414     {
00415         m_namespacesHandler.processExcludeResultPrefixes(
00416                 theConstructionContext,
00417                 theValue,
00418                 m_namespaces);
00419     }
00420 
00427     void
00428     addTemplate(
00429             ElemTemplate*                   theTemplate,
00430             StylesheetConstructionContext&  constructionContext);
00431 
00440     bool
00441     getYesOrNo(
00442             const XalanDOMChar*             aname,
00443             const XalanDOMChar*             val,
00444             StylesheetConstructionContext&  constructionContext) const;
00445 
00451     const XalanDOMString&
00452     getBaseIdentifier() const
00453     {
00454         return m_baseIdent;
00455     }
00456 
00465     const XalanDOMString&
00466     getCurrentIncludeBaseIdentifier() const
00467     {
00468         return m_includeStack.empty() == true ? getBaseIdentifier() : m_includeStack.back();
00469     }
00470 
00478     void
00479     processNSAliasElement(
00480             const XalanDOMChar*             name,
00481             const AttributeListType&        atts,
00482             StylesheetConstructionContext&  constructionContext);
00483 
00489     void
00490     processDecimalFormatElement(
00491             StylesheetConstructionContext&  constructionContext,
00492             const AttributeListType&        atts,
00493             const LocatorType*              locator = 0);
00494 
00502     const XalanDecimalFormatSymbols*
00503     getDecimalFormatSymbols(const XalanQName&   theQName) const;
00504 
00510     void
00511     addImport(Stylesheet*   theStylesheet)
00512     {
00513         m_imports.insert(m_imports.begin(), theStylesheet);
00514     }
00515 
00521     bool
00522     isWrapperless() const
00523     {
00524         return m_isWrapperless;
00525     }
00526 
00527     ElemTemplateElement*
00528     initWrapperless(
00529             StylesheetConstructionContext&  constructionContext,
00530             const LocatorType*              locator);
00531 
00537     URLStackType&
00538     getIncludeStack()
00539     {
00540         return m_includeStack;
00541     }
00542 
00551     void
00552     processKeyElement(
00553             const PrefixResolver&           nsContext,
00554             const AttributeListType&        atts,
00555             const LocatorType*              locator,
00556             StylesheetConstructionContext&  constructionContext);
00557 
00564     const ElemTemplate*
00565     findNamedTemplate(const XalanQName&     qname) const;
00566 
00575     const ElemTemplate*
00576     findTemplate(
00577             StylesheetExecutionContext&     executionContext,
00578             XalanNode*                      targetNode) const
00579     {
00580         assert(targetNode != 0);
00581 
00582         return findTemplate(
00583                 executionContext,
00584                 targetNode,
00585                 targetNode->getNodeType(),
00586                 s_emptyQName,
00587                 false);
00588     }
00589 
00601     const ElemTemplate*
00602     findTemplate(
00603             StylesheetExecutionContext&     executionContext,
00604             XalanNode*                      targetNode,
00605             XalanNode::NodeType             targetNodeType,
00606             const XalanQName&               mode,
00607             bool                            onlyUseImports) const;
00608 
00613     class MatchPattern2
00614     {
00615     public:
00616 
00617         typedef XPath::eMatchScore  eMatchScore;
00618 
00629         MatchPattern2(
00630                 const ElemTemplate&     theTemplate,
00631                 size_type               posInStylesheet,
00632                 const XalanDOMString&   targetString,
00633                 const XPath&            matchPattern,
00634                 const XalanDOMString&   pattern,
00635                 eMatchScore             priority) :
00636             m_template(&theTemplate),
00637             m_posInStylesheet(posInStylesheet),
00638             m_targetString(targetString),
00639             m_matchPattern(&matchPattern),
00640             m_pattern(&pattern),
00641             m_priority(priority)
00642         {
00643         }
00644 
00645         MatchPattern2() :
00646             m_template(0),
00647             m_posInStylesheet(0),
00648             m_targetString(),
00649             m_matchPattern(0),
00650             m_pattern(0),
00651             m_priority(XPath::eMatchScoreNone)
00652         {
00653         }
00654 
00655         ~MatchPattern2()
00656         {
00657         }
00658 
00664         const XalanDOMString&
00665         getTargetString() const
00666         {
00667             return m_targetString;
00668         }
00669 
00675         const XPath*
00676         getExpression() const
00677         {
00678             return m_matchPattern;
00679         }
00680 
00686         size_type
00687         getPositionInStylesheet() const
00688         {
00689             return m_posInStylesheet;
00690         }
00691 
00697         const XalanDOMString*
00698         getPattern() const
00699         {
00700             return m_pattern;
00701         }
00702 
00708         const ElemTemplate*
00709         getTemplate() const
00710         {
00711             return m_template;
00712         }
00713 
00714         eMatchScore
00715         getDefaultPriority() const
00716         {
00717             return m_priority;
00718         }
00719 
00720         double
00721         getPriorityOrDefault() const;
00722 
00723     private:
00724 
00725         const ElemTemplate*     m_template;
00726         size_type               m_posInStylesheet;
00727         XalanDOMString          m_targetString;
00728         const XPath*            m_matchPattern;
00729         const XalanDOMString*   m_pattern;
00730         eMatchScore             m_priority;
00731     };
00732 
00733 #if defined(XALAN_NO_STD_NAMESPACE)
00734     typedef vector<const MatchPattern2*>        PatternTableVectorType;
00735 
00736     typedef map<XalanDOMString,
00737                 PatternTableVectorType,
00738                 less<XalanDOMString> >          PatternTableMapType;
00739 
00740     typedef deque<MatchPattern2>                MatchPattern2Container;
00741 #else
00742     typedef std::vector<const MatchPattern2*>   PatternTableVectorType;
00743 
00744     typedef std::map<XalanDOMString,
00745                      PatternTableVectorType>    PatternTableMapType;
00746 
00747     typedef std::deque<MatchPattern2>           MatchPattern2Container;
00748 #endif
00749 
00756     static void
00757     addObjectIfNotFound(
00758             const MatchPattern2*        thePattern,
00759             PatternTableVectorType&     theVector);
00760 
00770     static void
00771     addObjectIfNotFound(
00772             const MatchPattern2*    thePattern,
00773             const MatchPattern2*    theArray[],
00774             unsigned int&           theArraySize);
00775 
00783     const PatternTableVectorType*
00784     locateElementMatchPatternList2(const XalanDOMString&    theName) const;
00785 
00793     const PatternTableVectorType*
00794     locateAttributeMatchPatternList2(const XalanDOMString&  theName) const;
00795 
00802     const PatternTableVectorType*
00803     locateMatchPatternList2(
00804             const XalanNode&        theNode,
00805             XalanNode::NodeType     targetNodeType) const;
00806 
00815     void
00816     processExtensionNamespace(
00817             StylesheetConstructionContext&  theConstructionContext,
00818             const XalanDOMString&           uri);
00819 
00826     ExtensionNSHandler*
00827     lookupExtensionNSHandler(const XalanDOMString&  uri) const
00828     {
00829         const ExtensionNamespacesMapType::const_iterator    it = 
00830           m_extensionNamespaces.find(uri);
00831 
00832         return it == m_extensionNamespaces.end() ? 0 : (*it).second;
00833     }
00834 
00841     void
00842     setTopLevelVariable(ElemVariable*   var)
00843     {
00844         m_topLevelVariables.push_back(var);
00845     }
00846 
00854     void
00855     pushTopLevelVariables(
00856             StylesheetExecutionContext&     executionContext,
00857             const ParamVectorType&          topLevelParams) const;
00858 
00859 
00860     // These interfaces are inherited from PrefixResolver...
00861 
00862     virtual const XalanDOMString*
00863     getNamespaceForPrefix(const XalanDOMString&     prefix) const;
00864 
00865     virtual const XalanDOMString&
00866     getURI() const;
00867 
00868     const XalanDOMString&
00869     getXSLTNamespaceURI() const
00870     {
00871         return m_XSLTNamespaceURI;
00872     }
00873 
00874     void
00875     setXSLTNamespaceURI(const XalanDOMString&   theURI)
00876     {
00877         m_XSLTNamespaceURI = theURI;
00878     }
00879 
00880     const ElemTemplate* 
00881     getFirstTemplate() const    
00882     {
00883         return m_firstTemplate;
00884     }
00885     
00886 protected:
00887 
00891     StylesheetRoot&                     m_stylesheetRoot;
00892 
00896     XalanDOMString                      m_baseIdent;
00897 
00902     KeyDeclarationVectorType            m_keyDeclarations;
00903 
00904     static const XalanQNameByReference  s_emptyQName;
00905 
00906 private:    
00907 
00908     // Not defined...
00909     Stylesheet(const Stylesheet&);
00910 
00911     Stylesheet&
00912     operator=(const Stylesheet&);
00913 
00914     bool
00915     operator==(const Stylesheet&) const;
00916 
00917 
00928     const ElemTemplate*
00929     findTemplateInImports(
00930             StylesheetExecutionContext&     executionContext,
00931             XalanNode*                      targetNode,
00932             XalanNode::NodeType             targetNodeType,
00933             const XalanQName&               mode) const;
00934 
00939     XalanDOMString                          m_XSLTNamespaceURI;
00940 
00944     StylesheetVectorType                    m_imports;
00945 
00946     StylesheetVectorType::size_type         m_importsSize;
00947 
00951     NamespacesStackType                     m_namespaces;
00952 
00957     NamespaceVectorType                     m_namespaceDecls;
00958 
00963     bool                                    m_isWrapperless;
00964 
00968     ExtensionNamespacesMapType              m_extensionNamespaces;
00969 
00973     ElemTemplate*                           m_firstTemplate;
00974 
00979     URLStackType                            m_includeStack;
00980 
00986     ElemTemplateMapType                     m_namedTemplates;
00987 
00991     ElemVariableVectorType                  m_topLevelVariables;
00992 
00996     double                                  m_XSLTVerDeclared;
00997 
01003     PatternTableMapType                         m_elementPatternTable;
01004 
01005     const PatternTableMapType::const_iterator   m_elementPatternTableEnd;
01006 
01007     PatternTableVectorType                      m_elementAnyPatternList;
01008 
01014     PatternTableMapType                         m_attributePatternTable;
01015 
01016     const PatternTableMapType::const_iterator   m_attributePatternTableEnd;
01017 
01018     PatternTableVectorType                      m_attributeAnyPatternList;
01019 
01023     PatternTableVectorType                  m_textPatternList;
01024 
01025     PatternTableVectorType                  m_commentPatternList;
01026 
01027     PatternTableVectorType                  m_rootPatternList;
01028 
01029     PatternTableVectorType                  m_piPatternList;
01030 
01034     PatternTableVectorType                  m_nodePatternList;
01035 
01040     MatchPattern2Container                  m_matchPattern2Container;
01041 
01045     MatchPattern2Container::size_type       m_patternCount;
01046 
01047     ElemDecimalFormatVectorType             m_elemDecimalFormats;
01048 
01049     NamespacesHandler                       m_namespacesHandler;
01050 
01051     static const XalanDOMString             s_emptyString;
01052 };
01053 
01054 
01055 
01056 XALAN_CPP_NAMESPACE_END
01057 
01058 
01059 
01060 #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.7
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.