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

# ElemTemplateElement.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 #if !defined(XALAN_ELEMTEMPLATEELEMENT_HEADER_GUARD)
    00058 #define XALAN_ELEMTEMPLATEELEMENT_HEADER_GUARD
    00059
    00060
    00061
    00062 // Base include file.  Must be first.
    00063 #include <xalanc/XSLT/XSLTDefinitions.hpp>
    00064
    00065
    00066
    00067 #include <xalanc/XalanDOM/XalanDOMString.hpp>
    00068 #include <xalanc/XalanDOM/XalanNode.hpp>
    00069
    00070
    00071
    00072 #include <xalanc/PlatformSupport/DOMStringHelper.hpp>
    00073 #include <xalanc/PlatformSupport/PrefixResolver.hpp>
    00074 #include <xalanc/PlatformSupport/XalanLocator.hpp>
    00075
    00076
    00077
    00078 #include <xalanc/XPath/XalanQNameByReference.hpp>
    00079
    00080
    00081
    00082 #include <xalanc/XSLT/NamespacesHandler.hpp>
    00083
    00084
    00085
    00086 XALAN_DECLARE_XERCES_CLASS(AttributeList)
    00087 XALAN_DECLARE_XERCES_CLASS(Locator)
    00088
    00089
    00090
    00091 XALAN_CPP_NAMESPACE_BEGIN
    00092
    00093
    00094
    00095 typedef XERCES_CPP_NAMESPACE_QUALIFIER AttributeList    AttributeListType;
    00096 typedef XERCES_CPP_NAMESPACE_QUALIFIER Locator          LocatorType;
    00097
    00098
    00099
    00100 class ElemTemplate;
    00101 class ElemTextLiteral;
    00102 class NamespacesHandler;
    00103 class Stylesheet;
    00104 class StylesheetConstructionContext;
    00105 class StylesheetExecutionContext;
    00106
    00107
    00108
    00109 class XALAN_XSLT_EXPORT ElemTemplateElement : public PrefixResolver
    00110 {
    00111 public:
    00112
    00123     ElemTemplateElement(
    00124             StylesheetConstructionContext&  constructionContext,
    00125             Stylesheet&                     stylesheetTree,
    00126             int                             lineNumber,
    00127             int                             columnNumber,
    00128             int                             xslToken);
    00129
    00140     ElemTemplateElement(
    00141             Stylesheet&                     stylesheetTree,
    00142             int                             xslToken,
    00143             int                             lineNumber = XalanLocator::getUnknownValue(),
    00144             int                             columnNumber = XalanLocator::getUnknownValue());
    00145
    00146     virtual
    00147     ~ElemTemplateElement();
    00148
    00154     virtual const LocatorType*
    00155     getLocator() const;
    00156
    00167     virtual bool
    00168     isAttrOK(
    00169             const XalanDOMChar*             attrName,
    00170             const AttributeListType&        atts,
    00171             int                             which,
    00172             StylesheetConstructionContext&  constructionContext) const;
    00173
    00183     bool
    00184     processSpaceAttr(
    00185             const XalanDOMChar*             aname,
    00186             const AttributeListType&        atts,
    00187             int                             which,
    00188             StylesheetConstructionContext&  constructionContext);
    00189
    00197     static bool
    00198     isValidNCName(const XalanDOMString&     s);
    00199
    00206     virtual void
    00207     execute(StylesheetExecutionContext&     executionContext) const;
    00208
    00214     virtual void
    00215     executeChildren(StylesheetExecutionContext&     executionContext) const;
    00216
    00223     virtual void
    00224     executeChildren(
    00225             StylesheetExecutionContext&     executionContext,
    00226             XalanNode*                      sourceNode) const;
    00227
    00239     const XalanDOMString&
    00240     childrenToString(
    00241             StylesheetExecutionContext&     executionContext,
    00242             XalanDOMString&                 result) const;
    00243
    00252     void
    00253     childrenToResultAttribute(
    00254             StylesheetExecutionContext&     executionContext,
    00255             const XalanDOMString&           theName) const;
    00256
    00264     void
    00265     childrenToResultComment(StylesheetExecutionContext& executionContext) const;
    00266
    00276     void
    00277     childrenToResultPI(
    00278             StylesheetExecutionContext&     executionContext,
    00279             const XalanDOMString&           theTarget) const;
    00280
    00288     int
    00289     getXSLToken() const
    00290     {
    00291         return m_xslToken;
    00292     }
    00293
    00299     int
    00300     getLineNumber() const
    00301     {
    00302         return m_lineNumber;
    00303     }
    00304
    00310     int
    00311     getColumnNumber() const
    00312     {
    00313         return m_columnNumber;
    00314     }
    00315
    00321     virtual bool
    00322     isWhitespace() const;
    00323
    00330     virtual const XalanDOMString&
    00331     getElementName() const = 0;
    00332
    00339     virtual const XalanQName&
    00340     getNameAttribute() const;
    00341
    00350     virtual void
    00351     addToStylesheet(
    00352             StylesheetConstructionContext&  constructionContext,
    00353             Stylesheet&                     theStylesheet);
    00354
    00366     virtual void
    00367     processSortElement(
    00368             StylesheetConstructionContext&  constructionContext,
    00369             Stylesheet&                     theStylesheet,
    00370             const AttributeListType&        atts,
    00371             const LocatorType*              locator = 0);
    00372
    00378     virtual void
    00379     setDefaultTemplate(bool     value);
    00380
    00386     const NamespacesHandler&
    00387     getNamespacesHandler() const
    00388     {
    00389         return m_namespacesHandler;
    00390     }
    00391
    00397     const Stylesheet&
    00398     getStylesheet() const
    00399     {
    00400         return m_stylesheet;
    00401     }
    00402
    00408     void
    00409     setFinishedConstruction(bool    fValue)
    00410     {
    00411         setFlag(eFinishedConstruction, fValue);
    00412     }
    00413
    00417     bool
    00418     getFinishedConstruction() const
    00419     {
    00420         return getFlag(eFinishedConstruction);
    00421     }
    00422
    00426     virtual void
    00427     postConstruction(
    00428             StylesheetConstructionContext&  constructionContext,
    00429             const NamespacesHandler&        theParentHandler);
    00430
    00431     // Type-safe getters/setters...
    00432
    00438     virtual ElemTemplateElement*
    00439     getFirstChildElem() const;
    00440
    00448     virtual void
    00449     setFirstChildElem(ElemTemplateElement*  theChild);
    00450
    00456     virtual ElemTemplateElement*
    00457     getLastChildElem() const;
    00458
    00464     virtual ElemTemplateElement*
    00465     getNextSiblingElem() const;
    00466
    00474     virtual void
    00475     setNextSiblingElem(ElemTemplateElement*     theSibling);
    00476
    00482     virtual ElemTemplateElement*
    00483     getPreviousSiblingElem() const;
    00484
    00492     virtual void
    00493     setPreviousSiblingElem(ElemTemplateElement*     theSibling);
    00494
    00500     virtual ElemTemplateElement*
    00501     getParentNodeElem() const;
    00502
    00510     virtual void
    00511     setParentNodeElem(ElemTemplateElement*      theParent);
    00512
    00520     virtual ElemTemplateElement*
    00521     appendChildElem(ElemTemplateElement*    newChild);
    00522
    00523
    00524     // These interfaces are inherited from PrefixResolver...
    00525
    00526     virtual const XalanDOMString*
    00527     getNamespaceForPrefix(const XalanDOMString& prefix) const;
    00528
    00529     virtual const XalanDOMString&
    00530     getURI() const;
    00531
    00532     class LocatorProxy : public XalanLocator
    00533     {
    00534     public:
    00535
    00536         LocatorProxy(const ElemTemplateElement&     theElement);
    00537
    00538         virtual
    00539         ~LocatorProxy();
    00540
    00541         virtual const XMLCh*
    00542         getPublicId() const;
    00543
    00544         virtual const XMLCh*
    00545         getSystemId() const;
    00546
    00547         virtual size_type
    00548         getLineNumber() const;
    00549
    00550         virtual size_type
    00551         getColumnNumber() const;
    00552
    00553     private:
    00554
    00555         // Not implemented...
    00556         LocatorProxy(const LocatorProxy&);
    00557
    00558         LocatorProxy&
    00559         operator=(const LocatorProxy&);
    00560
    00561         bool
    00562         operator==(const LocatorProxy&) const;
    00563
    00564         // data members...
    00565         const ElemTemplateElement&  m_element;
    00566     };
    00567
    00568     bool
    00569     hasParams() const
    00570     {
    00571         return getFlag(eHasParams);
    00572     }
    00573
    00574     bool
    00575     hasVariables() const
    00576     {
    00577         return getFlag(eHasVariables);
    00578     }
    00579
    00580     bool
    00581     hasSingleTextChild() const
    00582     {
    00583         return getFlag(eHasSingleTextChild);
    00584     }
    00585
    00586     bool
    00587     hasChildren() const
    00588     {
    00589         return m_firstChild != 0 ? true : false;
    00590     }
    00591
    00592     bool
    00593     hasDirectTemplate() const
    00594     {
    00595         return getFlag(eHasDirectTemplate);
    00596     }
    00597
    00598     bool
    00599     canGenerateAttributes() const
    00600     {
    00601         return getFlag(eCanGenerateAttributes);
    00602     }
    00603
    00604     bool
    00605     isDefaultTemplate() const
    00606     {
    00607         return getFlag(eDefaultTemplate);
    00608     }
    00609
    00610 protected:
    00611
    00612     void
    00613     canGenerateAttributes(bool  value)
    00614     {
    00615         setFlag(eCanGenerateAttributes, value);
    00616     }
    00617
    00618     void
    00619     hasPrefix(bool  value)
    00620     {
    00621         setFlag(eHasPrefix, value);
    00622     }
    00623
    00624     bool
    00625     hasPrefix() const
    00626     {
    00627         return getFlag(eHasPrefix);
    00628     }
    00629
    00630     void
    00631     preserveSpace(bool  value)
    00632     {
    00633         setFlag(eSpacePreserve, value);
    00634     }
    00635
    00636     bool
    00637     preserveSpace() const
    00638     {
    00639         return getFlag(eSpacePreserve);
    00640     }
    00641
    00642     void
    00643     disableOutputEscaping(bool  value)
    00644     {
    00645         setFlag(eDisableOutputEscaping, value);
    00646     }
    00647
    00648     bool
    00649     disableOutputEscaping() const
    00650     {
    00651         return getFlag(eDisableOutputEscaping);
    00652     }
    00653
    00663     bool
    00664     processPrefixControl(
    00665             StylesheetConstructionContext&  constructionContext,
    00666             const Stylesheet&               stylesheetTree,
    00667             const XalanDOMString&           localName,
    00668             const XalanDOMChar*             attrValue);
    00669
    00677     const XalanDOMString*
    00678     getNamespaceForPrefixInternal(const XalanDOMString&     prefix) const;
    00679
    00689     virtual void
    00690     transformChild(
    00691             StylesheetExecutionContext&     executionContext,
    00692             const ElemTemplateElement&      xslInstruction,
    00693             const ElemTemplateElement*      theTemplate,
    00694             XalanNode*                      child) const;
    00695
    00706     virtual void
    00707     transformChild(
    00708             StylesheetExecutionContext&     executionContext,
    00709             const ElemTemplateElement&      xslInstruction,
    00710             const ElemTemplateElement*      theTemplate,
    00711             XalanNode*                      child,
    00712             XalanNode::NodeType             nodeType) const;
    00713
    00726     virtual bool
    00727     childTypeAllowed(int    xslToken) const;
    00728
    00735     virtual void
    00736     namespacesPostConstruction(
    00737             StylesheetConstructionContext&  constructionContext,
    00738             const NamespacesHandler&        theParentHandler,
    00739             NamespacesHandler&              theHandler);
    00740
    00741     static const XalanDOMString     s_emptyString;
    00742
    00743     const NamespacesHandler&
    00744     getNamespaces() const
    00745     {
    00746         return m_namespacesHandler;
    00747     }
    00748
    00749 private:
    00750
    00751     enum eFlags
    00752     {
    00753         eHasParams = 1,
    00754         eHasSingleTextChild = 2,
    00755         eHasVariables = 4,
    00756         eHasDirectTemplate = 8,
    00757         eCanGenerateAttributes = 16,
    00758         eDefaultTemplate = 32,
    00759         eSpacePreserve = 64,
    00760         eFinishedConstruction = 128,
    00761         eHasPrefix = 256,
    00762         eDisableOutputEscaping = 512
    00763     };
    00764
    00765     bool
    00766     getFlag(eFlags  theFlag) const
    00767     {
    00768         return m_flags & theFlag ? true : false;
    00769     }
    00770
    00771     void
    00772     setFlag(
    00773             eFlags  theFlag,
    00774             bool    theValue)
    00775     {
    00776         if (theValue == true)
    00777         {
    00778             m_flags |= theFlag;
    00779         }
    00780         else
    00781         {
    00782             m_flags &= ~theFlag;
    00783         }
    00784     }
    00785
    00794     XalanDOMString&
    00795     doChildrenToString(
    00796             StylesheetExecutionContext&     executionContext,
    00797             XalanDOMString&                 result) const;
    00798
    00799     Stylesheet&             m_stylesheet;
    00800
    00801     /*
    00802      * This object handles all result tree namespace processing.
    00803      */
    00804     NamespacesHandler       m_namespacesHandler;
    00805
    00806     const int               m_lineNumber;
    00807     const int               m_columnNumber;
    00808
    00809     const int               m_xslToken;
    00810
    00811     ElemTemplateElement*    m_parentNode;
    00812     ElemTemplateElement*    m_nextSibling;
    00813     ElemTemplateElement*    m_previousSibling;
    00814
    00815     union
    00816     {
    00817         ElemTemplateElement*    m_firstChild;
    00818         const ElemTemplate*     m_directTemplate;
    00819         const ElemTextLiteral*  m_textLiteralChild;
    00820     };
    00821
    00822     const XalanDOMString&   m_baseIndentifier;
    00823
    00824     LocatorProxy            m_locatorProxy;
    00825
    00826     unsigned short          m_flags;
    00827
    00828     static const XalanQNameByReference      s_emptyQName;
    00829
    00830     // Not implemented...
    00831     ElemTemplateElement(const ElemTemplateElement&);
    00832
    00833     ElemTemplateElement&
    00834     operator=(const ElemTemplateElement&);
    00835
    00836     bool
    00837     operator==(const ElemTemplateElement&) const;
    00838 };
    00839
    00840
    00841
    00842 XALAN_CPP_NAMESPACE_END
    00843
    00844
    00845
    00846 #endif  // XALAN_ELEMTEMPLATEELEMENT_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.