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

# StylesheetConstructionContextDefault.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(STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680)
    00017 #define STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680
    00018
    00019
    00020
    00021 // Base include file.  Must be first.
    00022 #include <xalanc/XSLT/XSLTDefinitions.hpp>
    00023
    00024
    00025
    00026 #include <xalanc/Include/XalanVector.hpp>
    00027
    00028
    00029
    00030 #include <xalanc/PlatformSupport/ArenaAllocator.hpp>
    00031 #include <xalanc/PlatformSupport/XalanArrayAllocator.hpp>
    00032 #include <xalanc/PlatformSupport/XalanDOMStringPool.hpp>
    00033
    00034
    00035
    00036 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) || (XALAN_ALLINONE_BUILD_DLL)
    00037 #include <xalanc/XPath/XPathProcessor.hpp>
    00038 #endif
    00039
    00040
    00041
    00042 #include <xalanc/Include/XalanMemMgrAutoPtr.hpp>
    00043
    00044
    00045
    00046 #include <xalanc/PlatformSupport/XalanDOMStringCache.hpp>
    00047
    00048
    00049
    00050 #include <xalanc/XPath/XalanQNameByReference.hpp>
    00051 #include <xalanc/XPath/XalanQNameByValue.hpp>
    00052 #include <xalanc/XPath/XalanQNameByValueAllocator.hpp>
    00053
    00054
    00055
    00056 // Base class header file...
    00057 #include <xalanc/XSLT/StylesheetConstructionContext.hpp>
    00058
    00059
    00060
    00061 #include <xalanc/XSLT/AVT.hpp>
    00062 #include <xalanc/XSLT/XalanAVTAllocator.hpp>
    00063 #include <xalanc/XSLT/AVTPartSimple.hpp>
    00064 #include <xalanc/XSLT/XalanAVTPartSimpleAllocator.hpp>
    00065 #include <xalanc/XSLT/AVTPartXPath.hpp>
    00066 #include <xalanc/XSLT/XalanAVTPartXPathAllocator.hpp>
    00067 #include <xalanc/XSLT/XalanElemApplyTemplatesAllocator.hpp>
    00068 #include <xalanc/XSLT/XalanElemAttributeAllocator.hpp>
    00069 #include <xalanc/XSLT/XalanElemAttributeSetAllocator.hpp>
    00070 #include <xalanc/XSLT/XalanElemCallTemplateAllocator.hpp>
    00071 #include <xalanc/XSLT/XalanElemElementAllocator.hpp>
    00072 #include <xalanc/XSLT/XalanElemLiteralResultAllocator.hpp>
    00073 #include <xalanc/XSLT/XalanElemTemplateAllocator.hpp>
    00074 #include <xalanc/XSLT/XalanElemTextLiteralAllocator.hpp>
    00075 #include <xalanc/XSLT/XalanElemValueOfAllocator.hpp>
    00076 #include <xalanc/XSLT/XalanElemVariableAllocator.hpp>
    00077 #include "xalanc/XSLT/XalanMatchPatternDataAllocator.hpp"
    00078
    00079
    00080
    00081 XALAN_CPP_NAMESPACE_BEGIN
    00082
    00083
    00084
    00085 class XPathEnvSupport;
    00086 class XPathFactory;
    00087 class XPathProcessor;
    00088 class XSLTEngineImpl;
    00089
    00090
    00091
    00098 class XALAN_XSLT_EXPORT StylesheetConstructionContextDefault : public StylesheetConstructionContext
    00099 {
    00100 public:
    00101
    00102     typedef XalanArrayAllocator<XalanDOMChar>           XalanDOMCharVectorAllocatorType;
    00103     typedef XalanArrayAllocator<const void*>            PointerVectorAllocatorType;
    00104     typedef XalanDOMCharVectorAllocatorType::size_type  VectorAllocatorSizeType;
    00105
    00106     // Default size for vector allocation.
    00107     enum {
    00108             eDefaultXalanDOMCharVectorBlockSize = 1024,
    00109             eDefaultAVTBlockSize = 128,
    00110             eDefaultAVTPartSimpleBlockSize = 128,
    00111             eDefaultAVTPartXPathBlockSize = 128,
    00112             eDefaultXalanQNameByValueBlockSize = 32,
    00113             eDefaultPointerVectorBlockSize = 512,
    00114             eDefaultElemApplyTemplatesBlockSize = 10,
    00115             eDefaultElemAttributeBlockSize = 10,
    00116             eDefaultElemAttributeSetBlockSize = 10,
    00117             eDefaultElemCallTemplateBlockSize = 10,
    00118             eDefaultElemElementBlockSize = 10,
    00119             eDefaultElemLiteralResultBlockSize = 20,
    00120             eDefaultElemTemplateBlockSize = 10,
    00121             eDefaultElemTextLiteralBlockSize = 20,
    00122             eDefaultElemValueOfBlockSize = 10,
    00123             eDefaultElemVariableBlockSize = 10,
    00124             eDefaultMatchPatternDataBlockSize = 10 };
    00125
    00126     /*
    00127      * Construct an instance.  If the stylesheet(s) constructed is/are meant to be reused (a.k.a. "compiled"),
    00128      * the XObjectFactory and XPathFactory instance must exist for the lifetime of the construction context
    00129      * and, therefore, for the lifetime of the stylesheet(s).  Otherwise, XObject and XPath instance will be
    00130      * destroyed when the corresponding factories are destryed, leaving pointers to destroyed objects in the.
    00131      * stylesheet(s).
    00132      *
    00133      * @param processor a reference to an XSLTEngineImpl instance.  Used for error reporting.
    00134      * @param xpathFactory a reference to an XPathFactory instance.  See comments above for important details.
    00135      * @param theXalanDOMCharVectorAllocatorBlockSize The block size to use for allocating vectors of XalanDOMChars
    00136      * @param theAVTAllocatorBlockSize The block size to use for allocating AVT instances.
    00137      * @param theAVTPartSimpleAllocatorBlockSize The block size to use for allocating AVTPartSimple instances.
    00138      * @param theAVTPartXPathAllocatorBlockSize The block size to use for allocating AVTPartXPath instances.
    00139      * @param theXalanQNameByValueAllocatorBlockSize The block size to use for allocating XalanQNameByValue instances.
    00140      * @param thePointerVectorAllocatorBlockSize The block size to use for allocating vectors of pointers.
    00141      */
    00142     StylesheetConstructionContextDefault(
    00143             MemoryManagerType&                      theManager,
    00144             XSLTEngineImpl&                         processor,
    00145             XPathFactory&                           xpathFactory,
    00146             VectorAllocatorSizeType                 theXalanDOMCharVectorAllocatorBlockSize = eDefaultXalanDOMCharVectorBlockSize,
    00147             XalanAVTAllocator::size_type            theAVTAllocatorBlockSize = eDefaultAVTBlockSize,
    00148             XalanAVTPartSimpleAllocator::size_type  theAVTPartSimpleAllocatorBlockSize = eDefaultAVTPartSimpleBlockSize,
    00149             XalanAVTPartXPathAllocator::size_type   theAVTPartXPathAllocatorBlockSize = eDefaultAVTPartXPathBlockSize,
    00150             XalanQNameByValueAllocator::size_type   theXalanQNameByValueAllocatorBlockSize = eDefaultXalanQNameByValueBlockSize,
    00151             VectorAllocatorSizeType                 thePointerVectorAllocatorBlockSize = eDefaultPointerVectorBlockSize);
    00152
    00153     virtual
    00154     ~StylesheetConstructionContextDefault();
    00155
    00156
    00157     virtual void
    00158     error(
    00159             const XalanDOMString&       msg,
    00160             const XalanNode*            sourceNode = 0,
    00161             const ElemTemplateElement*  styleNode = 0) const;
    00162
    00163     virtual void
    00164     error(
    00165             const XalanDOMString&   msg,
    00166             const XalanNode*        sourceNode,
    00167             const LocatorType*      locator) const;
    00168
    00169     virtual void
    00170     warn(
    00171             const XalanDOMString&       msg,
    00172             const XalanNode*            sourceNode = 0,
    00173             const ElemTemplateElement*  styleNode = 0) const;
    00174
    00175     virtual void
    00176     warn(
    00177             const XalanDOMString&   msg,
    00178             const XalanNode*        sourceNode,
    00179             const LocatorType*      locator) const;
    00180
    00181     virtual void
    00182     message(
    00183             const XalanDOMString&       msg,
    00184             const XalanNode*            sourceNode = 0,
    00185             const ElemTemplateElement*  styleNode = 0) const;
    00186
    00187     virtual void
    00188     message(
    00189             const XalanDOMString&   msg,
    00190             const XalanNode*        sourceNode,
    00191             const LocatorType*      locator) const;
    00192
    00193     // These interfaces are inherited from StylesheetConstructionContext...
    00194
    00195     virtual void
    00196     reset();
    00197
    00198     virtual StylesheetRoot*
    00199     create(const XalanDOMString&    theBaseIdentifier);
    00200
    00201     virtual StylesheetRoot*
    00202     create(const XSLTInputSource&   theInputSource);
    00203
    00204     virtual Stylesheet*
    00205     create(
    00206             StylesheetRoot&         theStylesheetRoot,
    00207             const XalanDOMString&   theBaseIdentifier);
    00208
    00209     virtual void
    00210     destroy(StylesheetRoot*     theStylesheetRoot);
    00211
    00212     virtual URLAutoPtrType
    00213     getURLFromString(const XalanDOMString&  urlString);
    00214
    00215     virtual XalanDOMString&
    00216     getURLStringFromString(const XalanDOMString&    urlString,
    00217                             XalanDOMString& theResult);
    00218
    00219     virtual URLAutoPtrType
    00220     getURLFromString(
    00221             const XalanDOMString&   urlString,
    00222             const XalanDOMString&   base);
    00223
    00224     virtual XalanDOMString&
    00225     getURLStringFromString(
    00226             const XalanDOMString&   urlString,
    00227             const XalanDOMString&   base,
    00228             XalanDOMString& theResult);
    00229
    00230     virtual const XalanDOMString&
    00231     getXSLTNamespaceURI() const;
    00232
    00233     virtual XPath*
    00234     createMatchPattern(
    00235             const LocatorType*      locator,
    00236             const XalanDOMString&   str,
    00237             const PrefixResolver&   resolver,
    00238             bool                    allowVariableReferences = true,
    00239             bool                    allowKeyFunction = true);
    00240
    00241     virtual XPath*
    00242     createMatchPattern(
    00243             const LocatorType*      locator,
    00244             const XalanDOMChar*     str,
    00245             const PrefixResolver&   resolver,
    00246             bool                    allowVariableReferences = true,
    00247             bool                    allowKeyFunction = true);
    00248
    00249     virtual XPath*
    00250     createXPath(
    00251             const LocatorType*      locator,
    00252             const XalanDOMString&   str,
    00253             const PrefixResolver&   resolver,
    00254             bool                    allowVariableReferences = true,
    00255             bool                    allowKeyFunction = true);
    00256
    00257     virtual XPath*
    00258     createXPath(
    00259             const LocatorType*      locator,
    00260             const XalanDOMChar*     str,
    00261             const PrefixResolver&   resolver,
    00262             bool                    allowVariableReferences = true,
    00263             bool                    allowKeyFunction = true);
    00264
    00265     virtual XPath*
    00266     createXPath(
    00267             const LocatorType*          locator,
    00268             const XalanDOMChar*         str,
    00269             XalanDOMString::size_type   len,
    00270             const PrefixResolver&       resolver,
    00271             bool                        allowVariableReferences = true,
    00272             bool                        allowKeyFunction = true);
    00273
    00274     virtual const LocatorType*
    00275     getLocatorFromStack() const;
    00276
    00277     virtual void
    00278     pushLocatorOnStack(const LocatorType*   locator);
    00279
    00280     virtual void
    00281     popLocatorStack();
    00282
    00283     virtual const XalanDOMString&
    00284     getXalanXSLNameSpaceURL() const;
    00285
    00286     virtual XalanDocument*
    00287     parseXML(
    00288             const XalanDOMString&   urlString,
    00289             DocumentHandlerType*    docHandler,
    00290             XalanDocument*          docToRegister);
    00291
    00292     virtual bool
    00293     isXMLSpaceAttribute(
    00294             const XalanDOMChar*     theAttributeName,
    00295             const Stylesheet&       theStylesheet,
    00296             const LocatorType*      theLocator = 0);
    00297
    00298     virtual bool
    00299     isXSLUseAttributeSetsAttribute(
    00300             const XalanDOMChar*     theAttributeName,
    00301             const Stylesheet&       theStylesheet,
    00302             const LocatorType*      theLocator = 0);
    00303
    00304     virtual bool
    00305     isValidQName(
    00306             const XalanDOMChar*     theName,
    00307             const Stylesheet&       theStylesheet,
    00308             const LocatorType*      theLocator = 0);
    00309
    00310     virtual eElementToken
    00311     getElementToken(const XalanDOMString&   name) const;
    00312
    00313     virtual double
    00314     getXSLTVersionSupported() const;
    00315
    00316     virtual const XalanDOMString&
    00317     getPooledString(const XalanDOMString&   theString);
    00318
    00319     virtual const XalanDOMString&
    00320     getPooledString(
    00321             const XalanDOMChar*         theString,
    00322             XalanDOMString::size_type   theLength = XalanDOMString::npos);
    00323
    00324     virtual XalanDOMString&
    00325     getCachedString();
    00326
    00327     virtual bool
    00328     releaseCachedString(XalanDOMString&     theString);
    00329
    00330     virtual XalanDOMChar*
    00331     allocateXalanDOMCharVector(XalanDOMString::size_type    theLength);
    00332
    00333     virtual XalanDOMChar*
    00334     allocateXalanDOMCharVector(
    00335             const XalanDOMChar*         theString,
    00336             XalanDOMString::size_type   theLength = XalanDOMString::npos,
    00337             bool                        fTerminate = true);
    00338
    00339     virtual const AVT*
    00340     createAVT(
    00341             const LocatorType*      locator,
    00342             const XalanDOMChar*     name,
    00343             const XalanDOMChar*     stringedValue,
    00344             const PrefixResolver&   resolver);
    00345
    00346     virtual const AVTPart*
    00347     createAVTPart(
    00348             const XalanDOMChar*         theString,
    00349             XalanDOMString::size_type   theLength = XalanDOMString::npos);
    00350
    00351     virtual const AVTPart*
    00352     createAVTPart(
    00353             const LocatorType*          locator,
    00354             const XalanDOMChar*         str,
    00355             XalanDOMString::size_type   len,
    00356             const PrefixResolver&       resolver);
    00357
    00358     virtual const AVT**
    00359     allocateAVTPointerVector(size_type  theLength);
    00360
    00361     virtual const AVTPart**
    00362     allocateAVTPartPointerVector(size_type  theLength);
    00363
    00364     virtual const XalanQName*
    00365     createXalanQName(
    00366             const XalanDOMString&       qname,
    00367             const NamespacesStackType&  namespaces,
    00368             const LocatorType*          locator = 0,
    00369             bool                        fUseDefault = false);
    00370
    00371     virtual const XalanQName*
    00372     createXalanQName(
    00373             const XalanDOMChar*         qname,
    00374             const NamespacesStackType&  namespaces,
    00375             const LocatorType*          locator = 0,
    00376             bool                        fUseDefault = false);
    00377
    00378     virtual const XalanQName**
    00379     tokenizeQNames(
    00380             size_type&                  count,
    00381             const XalanDOMChar*         qnameTokens,
    00382             const NamespacesStackType&  namespaces,
    00383             const LocatorType*          locator = 0,
    00384             bool                        fUseDefault = false);
    00385
    00386     virtual ElemTemplateElement*
    00387     createElement(
    00388             int                         token,
    00389             Stylesheet&                 stylesheetTree,
    00390             const AttributeListType&    atts,
    00391             const LocatorType*          locator = 0);
    00392
    00393     virtual ElemTemplateElement*
    00394     createElement(
    00395             int                         token,
    00396             Stylesheet&                 stylesheetTree,
    00397             const XalanDOMChar*         name,
    00398             const AttributeListType&    atts,
    00399             const LocatorType*          locator = 0);
    00400
    00401     virtual ElemTemplateElement*
    00402     createElement(
    00403             Stylesheet&                 stylesheetTree,
    00404             const XalanDOMChar*         chars,
    00405             XalanDOMString::size_type   length,
    00406             bool                        preserveSpace,
    00407             bool                        disableOutputEscaping,
    00408             const LocatorType*          locator = 0);
    00409
    00410     virtual ElemTemplateElement*
    00411     createElement(
    00412             Stylesheet&                 stylesheetTree,
    00413             const XalanDOMChar*         name,
    00414             const AttributeListType&    atts,
    00415             ExtensionNSHandler&         handler,
    00416             const LocatorType*          locator = 0);
    00417
    00418     virtual const XalanMatchPatternData*
    00419     createXalanMatchPatternData(
    00420             const ElemTemplate&     theTemplate,
    00421             size_type               thePosition,
    00422             const XalanDOMString&   theTargetString,
    00423             const XPath&            theMatchPattern,
    00424             const XalanDOMString&   thePatternString,
    00425             XPath::eMatchScore      thePriority);
    00426
    00427     static eElementToken
    00428     getElementNameToken(const XalanDOMString&   name);
    00429
    00430     typedef XalanVector<StylesheetRoot*>            StylesheetVectorType;
    00431     typedef XalanVector<ElemTemplateElement*>   ElemTemplateElementVectorType;
    00432
    00433 private:
    00434
    00435     const AVT**
    00436     doAllocateAVTPointerVector(size_type    theSize)
    00437     {
    00438         assert(sizeof(AVT**) == sizeof(PointerVectorAllocatorType::value_type));
    00439
    00440 #if defined(XALAN_OLD_STYLE_CASTS)
    00441         return (const AVT**)m_pointerVectorAllocator.allocate(theSize);
    00442 #else
    00443         return reinterpret_cast<const AVT**>(m_pointerVectorAllocator.allocate(theSize));
    00444 #endif
    00445     }
    00446
    00447     const AVTPart**
    00448     doAllocateAVTPartPointerVector(size_type    theSize)
    00449     {
    00450         assert(sizeof(AVTPart**) == sizeof(PointerVectorAllocatorType::value_type));
    00451
    00452 #if defined(XALAN_OLD_STYLE_CASTS)
    00453         return (const AVTPart**)m_pointerVectorAllocator.allocate(theSize);
    00454 #else
    00455         return reinterpret_cast<const AVTPart**>(m_pointerVectorAllocator.allocate(theSize));
    00456 #endif
    00457     }
    00458
    00459     const XalanQName**
    00460     doAllocateXalanQNamePointerVector(size_type theSize)
    00461     {
    00462         assert(sizeof(XalanQName**) == sizeof(PointerVectorAllocatorType::value_type));
    00463
    00464 #if defined(XALAN_OLD_STYLE_CASTS)
    00465         return (const XalanQName**)m_pointerVectorAllocator.allocate(theSize);
    00466 #else
    00467         return reinterpret_cast<const XalanQName**>(m_pointerVectorAllocator.allocate(theSize));
    00468 #endif
    00469     }
    00470
    00471
    00472     XSLTEngineImpl&                         m_processor;
    00473
    00474     XPathFactory&                           m_xpathFactory;
    00475
    00476     typedef XalanMemMgrAutoPtr<XPathProcessor, true>    XPathProcessAutoPtr;
    00477
    00478     XPathProcessAutoPtr                     m_xpathProcessor;
    00479
    00480     StylesheetVectorType                    m_stylesheets;
    00481
    00482     XalanDOMStringPool                      m_stringPool;
    00483
    00484     XalanDOMCharVectorAllocatorType         m_xalanDOMCharVectorAllocator;
    00485
    00486     mutable XalanDOMString                  m_tempBuffer;
    00487
    00488     XalanQNameByValue                       m_scratchQName;
    00489
    00490     XalanDOMStringCache                     m_stringCache;
    00491
    00492     XalanAVTAllocator                       m_avtAllocator;
    00493
    00494     XalanAVTPartSimpleAllocator             m_avtPartSimpleAllocator;
    00495
    00496     XalanAVTPartXPathAllocator              m_avtPartXPathAllocator;
    00497
    00498     XalanQNameByValueAllocator              m_xalanQNameByValueAllocator;
    00499
    00500     const XalanQNameByReference             m_useAttributeSetsQName;
    00501
    00502     PointerVectorAllocatorType              m_pointerVectorAllocator;
    00503
    00504     ElemTemplateElementVectorType           m_allocatedElements;
    00505
    00506     XalanElemApplyTemplatesAllocator        m_elemApplyTemplatesAllocator;
    00507
    00508     XalanElemAttributeAllocator             m_elemAttributeAllocator;
    00509
    00510     XalanElemAttributeSetAllocator          m_elemAttributeSetAllocator;
    00511
    00512     XalanElemCallTemplateAllocator          m_elemCallTemplateAllocator;
    00513
    00514     XalanElemElementAllocator               m_elemElementAllocator;
    00515
    00516     XalanElemLiteralResultAllocator         m_elemLiteralResultAllocator;
    00517
    00518     XalanElemTemplateAllocator              m_elemTemplateAllocator;
    00519
    00520     XalanElemTextLiteralAllocator           m_elemTextLiteralAllocator;
    00521
    00522     XalanElemValueOfAllocator               m_elemValueOfAllocator;
    00523
    00524     XalanElemVariableAllocator              m_elemVariableAllocator;
    00525
    00526     XalanMatchPatternDataAllocator          m_matchPatternDataAllocator;
    00527
    00528     const XalanQNameByReference             m_spaceAttrQName;
    00529
    00530     // Static strings for stylesheet compilation...
    00531
    00532     // The string "if"
    00533     static const XalanDOMChar   s_if[];
    00534
    00535     // The string "key"
    00536     static const XalanDOMChar   s_key[];
    00537
    00538     // The string "copy"
    00539     static const XalanDOMChar   s_copy[];
    00540
    00541     // The string "sort"
    00542     static const XalanDOMChar   s_sort[];
    00543
    00544     // The string "text"
    00545     static const XalanDOMChar   s_text[];
    00546
    00547     // The string "when"
    00548     static const XalanDOMChar   s_when[];
    00549
    00550     // The string "empty"
    00551     static const XalanDOMChar   s_empty[];
    00552
    00553     // The string "param"
    00554     static const XalanDOMChar   s_param[];
    00555
    00556     // The string "choose"
    00557     static const XalanDOMChar   s_choose[];
    00558
    00559     // The string "import"
    00560     static const XalanDOMChar   s_import[];
    00561
    00562     // The string "number"
    00563     static const XalanDOMChar   s_number[];
    00564
    00565     // The string "output"
    00566     static const XalanDOMChar   s_output[];
    00567
    00568     // The string "comment"
    00569     static const XalanDOMChar   s_comment[];
    00570
    00571     // The string "copy-of"
    00572     static const XalanDOMChar   s_copyOf[];
    00573
    00574     // The string "element"
    00575     static const XalanDOMChar   s_element[];
    00576
    00577     // The string "include"
    00578     static const XalanDOMChar   s_include[];
    00579
    00580     // The string "message"
    00581     static const XalanDOMChar   s_message[];
    00582
    00583     // The string "fallback"
    00584     static const XalanDOMChar   s_fallback[];
    00585
    00586     // The string "for-each"
    00587     static const XalanDOMChar   s_forEach[];
    00588
    00589     // The string "template"
    00590     static const XalanDOMChar   s_template[];
    00591
    00592     // The string "value-of"
    00593     static const XalanDOMChar   s_valueOf[];
    00594
    00595     // The string "variable"
    00596     static const XalanDOMChar   s_variable[];
    00597
    00598     // The string "attribute"
    00599     static const XalanDOMChar   s_attribute[];
    00600
    00601     // The string "otherwise"
    00602     static const XalanDOMChar   s_otherwise[];
    00603
    00604     // The string "transform"
    00605     static const XalanDOMChar   s_transform[];
    00606
    00607     // The string "stylesheet"
    00608     static const XalanDOMChar   s_stylesheet[];
    00609
    00610     // The string "with-param"
    00611     static const XalanDOMChar   s_withParam[];
    00612
    00613     // The string "strip-space"
    00614     static const XalanDOMChar   s_stripSpace[];
    00615
    00616     // The string "apply-imports"
    00617     static const XalanDOMChar   s_applyImports[];
    00618
    00619     // The string "attribute-set"
    00620     static const XalanDOMChar   s_attributeSet[];
    00621
    00622     // The string "call-template"
    00623     static const XalanDOMChar   s_callTemplate[];
    00624
    00625     // The string "decimal-format"
    00626     static const XalanDOMChar   s_decimalFormat[];
    00627
    00628     // The string "preserve-space"
    00629     static const XalanDOMChar   s_preserveSpace[];
    00630
    00631     // The string "apply-templates"
    00632     static const XalanDOMChar   s_applyTemplates[];
    00633
    00634     // The string "namespace-alias"
    00635     static const XalanDOMChar   s_namespaceAlias[];
    00636
    00637     // The string "processing-instruction"
    00638     static const XalanDOMChar   s_processingInstruction[];
    00639
    00640     // A struct for an array that maps stylesheet element names
    00641     // to int tokens.
    00642     struct ElementTokenTableEntry
    00643     {
    00644         const XalanDOMChar*     m_name;
    00645
    00646         eElementToken           m_token;
    00647     };
    00648
    00649     static const ElementTokenTableEntry     s_elementTokenTable[];
    00650
    00651     static const unsigned int               s_elementTokenTableSize;
    00652
    00653     static const ElementTokenTableEntry&    s_elementTokenTableLast;
    00654
    00655     static const ElementTokenTableEntry&    s_elementTokenTableDummy;
    00656 };
    00657
    00658
    00659
    00660 XALAN_CPP_NAMESPACE_END
    00661
    00662
    00663
    00664 #endif  // STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680

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.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.