Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

ElemTemplateElement.hpp

Go to the documentation of this file.
00001 /*
00002  * Copyright 1999-2004 The Apache Software Foundation.
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #if !defined(XALAN_ELEMTEMPLATEELEMENT_HEADER_GUARD)
00017 #define XALAN_ELEMTEMPLATEELEMENT_HEADER_GUARD 
00018 
00019 
00020 
00021 // Base include file.  Must be first.
00022 #include <xalanc/XSLT/XSLTDefinitions.hpp>
00023 
00024 
00025 
00026 #include <xalanc/XalanDOM/XalanDOMString.hpp>
00027 #include <xalanc/XalanDOM/XalanNode.hpp>
00028 
00029 
00030 
00031 #include <xalanc/PlatformSupport/DOMStringHelper.hpp>
00032 #include <xalanc/PlatformSupport/PrefixResolver.hpp>
00033 #include <xalanc/PlatformSupport/XalanLocator.hpp>
00034 
00035 
00036 
00037 #include <xalanc/XPath/XalanQNameByReference.hpp>
00038 
00039 
00040 
00041 #include <xalanc/XSLT/NamespacesHandler.hpp>
00042 
00043 
00044 
00045 #include "LocalMsgIndex.hpp"
00046 
00047 
00048 
00049 XALAN_DECLARE_XERCES_CLASS(AttributeList)
00050 XALAN_DECLARE_XERCES_CLASS(Locator)
00051 
00052 
00053 
00054 XALAN_CPP_NAMESPACE_BEGIN
00055 
00056 
00057 
00058 typedef XERCES_CPP_NAMESPACE_QUALIFIER AttributeList    AttributeListType;
00059 typedef XERCES_CPP_NAMESPACE_QUALIFIER Locator          LocatorType;
00060 
00061 
00062 XALAN_USING_XERCES(AttributeList)
00063 XALAN_USING_XERCES(Locator)
00064 class ElemTemplate;
00065 class ElemTextLiteral;
00066 class NamespacesHandler;
00067 class Stylesheet;
00068 class StylesheetConstructionContext;
00069 class StylesheetExecutionContext;
00070 class XPath;
00071 
00072 
00073 
00074 class XALAN_XSLT_EXPORT ElemTemplateElement : public PrefixResolver
00075 {
00076      
00077 public:
00078 
00089     ElemTemplateElement(
00090             StylesheetConstructionContext&  constructionContext,
00091             Stylesheet&                     stylesheetTree,
00092             int                             lineNumber,
00093             int                             columnNumber,
00094             int                             xslToken);
00095 
00108     ElemTemplateElement(
00109             StylesheetConstructionContext&  constructionContext,
00110             Stylesheet&                     stylesheetTree,
00111             int                             xslToken,
00112             const XalanDOMString&           baseURI = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
00113             int                             lineNumber = XalanLocator::getUnknownValue(),
00114             int                             columnNumber = XalanLocator::getUnknownValue());
00115 
00116     virtual
00117     ~ElemTemplateElement();
00118 
00124     virtual const LocatorType*
00125     getLocator() const;
00126 
00137     virtual bool
00138     isAttrOK(
00139             const XalanDOMChar*             attrName,
00140             const AttributeListType&        atts,
00141             int                             which,
00142             StylesheetConstructionContext&  constructionContext) const;
00143 
00154     bool
00155     processSpaceAttr(
00156             const XalanDOMChar*             elementName,
00157             const XalanDOMChar*             aname,
00158             const AttributeListType&        atts,
00159             int                             which,
00160             StylesheetConstructionContext&  constructionContext);
00161 
00169     static bool
00170     isValidNCName(const XalanDOMString&     s);
00171 
00172 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
00173 
00181     virtual const ElemTemplateElement*
00182     startElement(StylesheetExecutionContext&    executionContext) const;
00183 
00191     virtual void
00192     endElement(StylesheetExecutionContext&      executionContext) const;
00193 
00199     virtual void
00200     execute(StylesheetExecutionContext&     executionContext) const;
00201 
00207     virtual void
00208     executeChildren(StylesheetExecutionContext&     executionContext) const;
00209 
00214     virtual const ElemTemplateElement*
00215     getInvoker(StylesheetExecutionContext&  executionContext) const;
00216 
00217 #else
00218 
00225     virtual void
00226     execute(StylesheetExecutionContext&     executionContext) const;
00227 
00233     virtual void
00234     executeChildren(StylesheetExecutionContext&     executionContext) const;
00235 
00242     virtual void
00243     executeChildren(
00244             StylesheetExecutionContext&     executionContext,
00245             XalanNode*                      sourceNode) const;
00246 
00258     const XalanDOMString&
00259     childrenToString(
00260             StylesheetExecutionContext&     executionContext,
00261             XalanDOMString&                 result) const;
00262 
00271     void
00272     childrenToResultAttribute(
00273             StylesheetExecutionContext&     executionContext,
00274             const XalanDOMString&           theName) const;
00275 
00283     void
00284     childrenToResultComment(StylesheetExecutionContext& executionContext) const;
00285 
00295     void
00296     childrenToResultPI(
00297             StylesheetExecutionContext&     executionContext,
00298             const XalanDOMString&           theTarget) const;
00299 
00307 #endif
00308     
00309     int
00310     getXSLToken() const
00311     {
00312         return m_xslToken;
00313     }
00314 
00320     virtual bool
00321     isWhitespace() const;
00322 
00329     virtual const XalanDOMString&
00330     getElementName() const = 0;
00331 
00338     virtual const XalanQName&
00339     getNameAttribute() const;
00340 
00349     virtual void
00350     addToStylesheet(
00351             StylesheetConstructionContext&  constructionContext,
00352             Stylesheet&                     theStylesheet);
00353 
00365     virtual void
00366     processSortElement(
00367             StylesheetConstructionContext&  constructionContext,
00368             Stylesheet&                     theStylesheet,
00369             const AttributeListType&        atts,
00370             const LocatorType*              locator = 0);
00371 
00377     virtual void
00378     setDefaultTemplate(bool     value);
00379 
00385     const NamespacesHandler&
00386     getNamespacesHandler() const
00387     {
00388         return m_namespacesHandler;
00389     }
00390 
00396     const Stylesheet&
00397     getStylesheet() const
00398     {
00399         return m_stylesheet;
00400     }
00401 
00407     void
00408     setFinishedConstruction(bool    fValue)
00409     {
00410         setFlag(eFinishedConstruction, fValue);
00411     }
00412 
00416     bool
00417     getFinishedConstruction() const
00418     {
00419         return getFlag(eFinishedConstruction);
00420     }
00421 
00425     virtual void
00426     postConstruction(
00427             StylesheetConstructionContext&  constructionContext,
00428             const NamespacesHandler&        theParentHandler);
00429 
00430     // Type-safe getters/setters...
00431 
00437     virtual ElemTemplateElement*
00438     getFirstChildElem() const;
00439 
00440 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
00441 
00447     virtual const ElemTemplateElement*
00448     beginExecuteChildren(
00449             StylesheetExecutionContext& executionContext) const;
00450 
00451 
00458     virtual void
00459     endExecuteChildren(
00460             StylesheetExecutionContext& executionContext) const;
00461 
00470     const ElemTemplateElement*
00471     beginChildrenToString(
00472             StylesheetExecutionContext&     executionContext,
00473             XalanDOMString&                 result) const;
00474 
00475     
00482     void
00483     endChildrenToString(
00484             StylesheetExecutionContext&     executionContext) const;
00485 #endif
00486 
00487 
00495     virtual void
00496     setFirstChildElem(ElemTemplateElement*  theChild);
00497 
00503     virtual ElemTemplateElement*
00504     getLastChildElem() const;
00505 
00511     virtual ElemTemplateElement*
00512     getNextSiblingElem() const;
00513 
00514 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
00515 
00524     virtual const ElemTemplateElement*
00525     getNextChildElemToExecute(
00526             StylesheetExecutionContext& executionContext,
00527             const ElemTemplateElement*  currentElem) const;
00528 
00536     virtual const ElemTemplateElement*
00537     getFirstChildElemToExecute(
00538             StylesheetExecutionContext& executionContext) const;
00539 
00547     virtual bool executeChildElement(
00548             StylesheetExecutionContext& executionContext,
00549             const ElemTemplateElement* element) const;
00550 #endif
00551 
00559     virtual void
00560     setNextSiblingElem(ElemTemplateElement*     theSibling);
00561 
00567     virtual ElemTemplateElement*
00568     getPreviousSiblingElem() const;
00569 
00577     virtual void
00578     setPreviousSiblingElem(ElemTemplateElement*     theSibling);
00579 
00585     virtual ElemTemplateElement*
00586     getParentNodeElem() const;
00587 
00595     virtual void
00596     setParentNodeElem(ElemTemplateElement*      theParent);
00597 
00605     virtual ElemTemplateElement*
00606     appendChildElem(ElemTemplateElement*    newChild);
00607 
00617     virtual const XPath*
00618     getXPath(unsigned int   index = 0) const;
00619 
00620     // These interfaces are inherited from PrefixResolver...
00621 
00622     virtual const XalanDOMString*
00623     getNamespaceForPrefix(const XalanDOMString& prefix) const;
00624 
00625     virtual const XalanDOMString&
00626     getURI() const;
00627 
00628     // A class that implements the XalanLocator
00629     // abstract base class.  ElemTemplateElement
00630     // uses this class to provide locator information.
00631     class LocatorProxy : public XalanLocator
00632     {
00633     public:
00634 
00635         LocatorProxy(
00636                     size_type               theLineNumber,
00637                     size_type               theColumnNumber,
00638                     const XalanDOMString&   theURI);
00639 
00640         virtual
00641         ~LocatorProxy();
00642 
00643         virtual const XMLCh*
00644         getPublicId() const;
00645 
00646         virtual const XMLCh*
00647         getSystemId() const;
00648 
00649         virtual size_type
00650         getLineNumber() const;
00651 
00652         virtual size_type
00653         getColumnNumber() const;
00654 
00655         const XalanDOMString&
00656         getURI() const
00657         {
00658             return m_uri;
00659         }
00660 
00661     private:
00662 
00663         // Not implemented...
00664         LocatorProxy(const LocatorProxy&);
00665 
00666         LocatorProxy&
00667         operator=(const LocatorProxy&);
00668 
00669         bool
00670         operator==(const LocatorProxy&) const;
00671 
00672         // data members...
00673         const size_type         m_lineNumber;
00674 
00675         const size_type         m_columnNumber;
00676 
00677         const XalanDOMString&   m_uri;
00678     };
00679 
00680 
00681     LocatorProxy::size_type
00682     getLineNumber() const
00683     {
00684         return m_locatorProxy.getLineNumber();
00685     }
00686 
00687     LocatorProxy::size_type
00688     getColumnNumber() const
00689     {
00690         return m_locatorProxy.getColumnNumber();
00691     }
00692 
00693     bool
00694     hasParams() const
00695     {
00696         return getFlag(eHasParams);
00697     }
00698 
00699     bool
00700     hasVariables() const
00701     {
00702         return getFlag(eHasVariables);
00703     }
00704 
00705     bool
00706     hasSingleTextChild() const
00707     {
00708         return getFlag(eHasSingleTextChild);
00709     }
00710 
00711     bool
00712     hasChildren() const
00713     {
00714         return m_firstChild != 0 ? true : false;
00715     }
00716 
00717     bool
00718     hasDirectTemplate() const
00719     {
00720         return getFlag(eHasDirectTemplate);
00721     }
00722 
00723     bool
00724     canGenerateAttributes() const
00725     {
00726         return getFlag(eCanGenerateAttributes);
00727     }
00728 
00729     bool
00730     isDefaultTemplate() const
00731     {
00732         return getFlag(eDefaultTemplate);
00733     }
00734 
00735 protected:
00736 
00737     void
00738     canGenerateAttributes(bool  value)
00739     {
00740         setFlag(eCanGenerateAttributes, value);
00741     }
00742 
00743     void
00744     hasPrefix(bool  value)
00745     {
00746         setFlag(eHasPrefix, value);
00747     }
00748 
00749     bool
00750     hasPrefix() const
00751     {
00752         return getFlag(eHasPrefix);
00753     }
00754 
00755     void
00756     preserveSpace(bool  value)
00757     {
00758         setFlag(eSpacePreserve, value);
00759     }
00760 
00761     bool
00762     preserveSpace() const
00763     {
00764         return getFlag(eSpacePreserve);
00765     }
00766 
00767     void
00768     disableOutputEscaping(bool  value)
00769     {
00770         setFlag(eDisableOutputEscaping, value);
00771     }
00772 
00773     bool
00774     disableOutputEscaping() const
00775     {
00776         return getFlag(eDisableOutputEscaping);
00777     }
00778 
00788     bool
00789     processPrefixControl(
00790             StylesheetConstructionContext&  constructionContext,
00791             const Stylesheet&               stylesheetTree,
00792             const XalanDOMString&           localName,
00793             const XalanDOMChar*             attrValue);
00794 
00802     const XalanDOMString*
00803     getNamespaceForPrefixInternal(const XalanDOMString&     prefix) const;
00804 
00805 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
00806 
00816     virtual const ElemTemplateElement*
00817     findTemplateToTransformChild(
00818             StylesheetExecutionContext&     executionContext,
00819             const ElemTemplateElement&      xslInstruction,
00820             const ElemTemplateElement*      theTemplate,
00821             XalanNode*                      child) const;
00822 
00834     virtual const ElemTemplateElement*
00835     findTemplateToTransformChild(
00836             StylesheetExecutionContext&     executionContext,
00837             const ElemTemplateElement&      xslInstruction,
00838             const ElemTemplateElement*      theTemplate,
00839             XalanNode*                      child,
00840             XalanNode::NodeType             nodeType) const;
00841 #else
00842 
00851     virtual void
00852     transformChild(
00853             StylesheetExecutionContext&     executionContext,
00854             const ElemTemplateElement&      xslInstruction,
00855             const ElemTemplateElement*      theTemplate,
00856             XalanNode*                      child) const;
00857 
00868     virtual void
00869     transformChild(
00870             StylesheetExecutionContext&     executionContext,
00871             const ElemTemplateElement&      xslInstruction,
00872             const ElemTemplateElement*      theTemplate,
00873             XalanNode*                      child,
00874             XalanNode::NodeType             nodeType) const;
00875 #endif
00876     
00889     virtual bool
00890     childTypeAllowed(int    xslToken) const;
00891 
00898     virtual void
00899     namespacesPostConstruction(
00900             StylesheetConstructionContext&  constructionContext,
00901             const NamespacesHandler&        theParentHandler,
00902             NamespacesHandler&              theHandler);
00903 
00904     const NamespacesHandler&
00905     getNamespaces() const
00906     {
00907         return m_namespacesHandler;
00908     }
00909 
00918     void
00919     error(
00920             StylesheetExecutionContext&     theContext,
00921             XalanMessages::Codes            theCode) const;
00922 
00932     void
00933     error(
00934             StylesheetExecutionContext&     theContext,
00935             XalanMessages::Codes            theCode,
00936             const XalanDOMString&           theToken) const;
00937 
00947     void
00948     error(
00949             StylesheetExecutionContext&     theContext,
00950             XalanMessages::Codes            theCode,
00951             const Locator*                  theLocator) const;
00952 
00961     void
00962     warn(
00963             StylesheetExecutionContext&     theContext,
00964             XalanMessages::Codes            theCode) const;
00965 
00975     void
00976     warn(
00977             StylesheetExecutionContext&     theContext,
00978             XalanMessages::Codes            theCode,
00979             const XalanDOMString&           theToken) const;
00980 
00990     void
00991     warn(
00992             StylesheetExecutionContext&     theContext,
00993             XalanMessages::Codes            theCode,
00994             const Locator*                  theLocator) const;
00995 
01004     void
01005     error(
01006             StylesheetConstructionContext&  theContext,
01007             XalanMessages::Codes            theCode);
01008 
01019     void
01020     error(
01021             StylesheetConstructionContext&  theContext,
01022             XalanMessages::Codes            theCode,
01023             const XalanDOMString&           theToken);
01024 
01035     void
01036     error(
01037             StylesheetConstructionContext&  theContext,
01038             XalanMessages::Codes            theCode,
01039             const XalanDOMString&           theToken,
01040             const Locator*                  theLocator);
01041 
01052     void
01053     error(
01054             StylesheetConstructionContext&  theContext,
01055             XalanMessages::Codes            theCode,
01056             const XalanDOMString&           theToken1,
01057             const XalanDOMString&           theToken2);
01058 
01069     void
01070     error(
01071             StylesheetConstructionContext&  theContext,
01072             XalanMessages::Codes            theCode,
01073             const XalanDOMChar*             theToken1,
01074             const XalanDOMChar*             theToken2);
01075 
01087     void
01088     error(
01089             StylesheetConstructionContext&  theContext,
01090             XalanMessages::Codes            theCode,
01091             const XalanDOMChar*             theToken1,
01092             const XalanDOMChar*             theToken2,
01093             const XalanDOMChar*             theToken3);
01094 
01106     void
01107     warn(
01108             StylesheetConstructionContext&  theContext,
01109             XalanMessages::Codes            theCode,
01110             const XalanDOMChar*             theToken1,
01111             const XalanDOMChar*             theToken2,
01112             const XalanDOMChar*             theToken3);
01113 
01114     // A handy empty XalanDOMString instance for
01115     // derived classes to use.
01116     static const XalanDOMString     s_emptyString;
01117 
01118 private:
01119 
01120     enum eFlags
01121     { 
01122         eHasParams = 1,
01123         eHasSingleTextChild = 2,
01124         eHasVariables = 4,
01125         eHasDirectTemplate = 8,
01126         eCanGenerateAttributes = 16,
01127         eDefaultTemplate = 32,
01128         eSpacePreserve = 64,
01129         eFinishedConstruction = 128,
01130         eHasPrefix = 256,
01131         eDisableOutputEscaping = 512
01132     };
01133 
01134     bool
01135     getFlag(eFlags  theFlag) const
01136     {
01137         return m_flags & theFlag ? true : false;
01138     }
01139 
01140     void
01141     setFlag(
01142             eFlags  theFlag,
01143             bool    theValue)
01144     {
01145         if (theValue == true)
01146         {
01147             m_flags |= theFlag;
01148         }
01149         else
01150         {
01151             m_flags &= ~theFlag;
01152         }
01153     }
01154 
01155 
01156 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
01157 
01165     XalanDOMString&
01166     doChildrenToString(
01167             StylesheetExecutionContext&     executionContext, 
01168             XalanDOMString&                 result) const;
01169 #endif
01170 
01171     Stylesheet&             m_stylesheet;
01172 
01173     /*
01174      * This object handles all result tree namespace processing.
01175      */
01176     NamespacesHandler       m_namespacesHandler;
01177 
01178     const int               m_xslToken;
01179 
01180     ElemTemplateElement*    m_parentNode;
01181     ElemTemplateElement*    m_nextSibling;
01182     ElemTemplateElement*    m_previousSibling;
01183 
01184     union
01185     {
01186         ElemTemplateElement*    m_firstChild;
01187         const ElemTemplate*     m_directTemplate;
01188         const ElemTextLiteral*  m_textLiteralChild;
01189     };
01190 
01191     LocatorProxy            m_locatorProxy;
01192 
01193     unsigned short          m_flags;
01194 
01195     static const XalanQNameByReference      s_emptyQName;
01196 
01197     // Not implemented...
01198     ElemTemplateElement(const ElemTemplateElement&);
01199 
01200     ElemTemplateElement&
01201     operator=(const ElemTemplateElement&);
01202 
01203     bool
01204     operator==(const ElemTemplateElement&) const;
01205 };
01206 
01207 
01208 
01209 XALAN_CPP_NAMESPACE_END
01210 
01211 
01212 
01213 #endif  // XALAN_ELEMTEMPLATEELEMENT_HEADER_GUARD

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

dot

Xalan-C++ XSLT Processor Version 1.10
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.

Apache Logo