<HTML><HEAD><TITLE>Xalan-C++ API Documentation</TITLE></HEAD>
<BODY>
<h2 align="center">Xalan-C++ API Documentation</h2>
<h3 align="center">The Xalan C++ XSLT Processor Version 1.10</h3>
</BODY>
<!-- Generated by Doxygen 1.2.8.1 -->
<center>
<a class="qindex" href="index.html">Main Page</a> &nbsp; <a class="qindex" href="hierarchy.html">Class Hierarchy</a> &nbsp; <a class="qindex" href="classes.html">Alphabetical List</a> &nbsp; <a class="qindex" href="annotated.html">Compound List</a> &nbsp; <a class="qindex" href="files.html">File List</a> &nbsp; <a class="qindex" href="functions.html">Compound Members</a> &nbsp; <a class="qindex" href="globals.html">File Members</a> &nbsp; </center>
<hr><h1>ElemLiteralResult Member List</h1>This is the complete list of members for <a class="el" href="classElemLiteralResult.html">ElemLiteralResult</a>, including all inherited members.<ul>
<li><a class="el" href="classElemTemplateElement.html#a15">addToStylesheet</a>(StylesheetConstructionContext &amp;constructionContext, Stylesheet &amp;theStylesheet)
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a39">appendChildElem</a>(ElemTemplateElement *newChild)
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a26">beginChildrenToString</a>(StylesheetExecutionContext &amp;executionContext, XalanDOMString &amp;result) const
<li><a class="el" href="classElemTemplateElement.html#a24">beginExecuteChildren</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a50">canGenerateAttributes</a>() const
<li><a class="el" href="classElemTemplateElement.html#b0">canGenerateAttributes</a>(bool value)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b11">childTypeAllowed</a>(int xslToken) const
<code> [protected, virtual]</code><li><a class="el" href="classElemTemplateElement.html#b5">disableOutputEscaping</a>(bool value)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b6">disableOutputEscaping</a>() const
<code> [protected]</code><li><a class="el" href="classElemLiteralResult.html#a0">ElemLiteralResult</a>(StylesheetConstructionContext &amp;constructionContext, Stylesheet &amp;stylesheetTree, const XalanDOMChar *name, const AttributeListType &amp;atts, int lineNumber, int columnNumber)
<li><a class="el" href="classElemLiteralResult.html#b1">ElemLiteralResult</a>(StylesheetConstructionContext &amp;constructionContext, Stylesheet &amp;stylesheetTree, const XalanDOMChar *name, const AttributeListType &amp;atts, int lineNumber, int columnNumber, int xslToken)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#a0">ElemTemplateElement</a>(StylesheetConstructionContext &amp;constructionContext, Stylesheet &amp;stylesheetTree, int lineNumber, int columnNumber, int xslToken)
<li><a class="el" href="classElemTemplateElement.html#a1">ElemTemplateElement</a>(StylesheetConstructionContext &amp;constructionContext, Stylesheet &amp;stylesheetTree, int xslToken, const XalanDOMString &amp;baseURI=XalanDOMString(XalanMemMgrs::getDummyMemMgr()), int lineNumber=XalanLocator::getUnknownValue(), int columnNumber=XalanLocator::getUnknownValue())
<li><a class="el" href="classElemUse.html#a0">ElemUse</a>(StylesheetConstructionContext &amp;constructionContext, Stylesheet &amp;stylesheetTree, int lineNumber, int columnNumber, int xslToken)
<li><a class="el" href="classElemTemplateElement.html#a27">endChildrenToString</a>(StylesheetExecutionContext &amp;executionContext) const
<li><a class="el" href="classElemLiteralResult.html#a6">endElement</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a25">endExecuteChildren</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#b14">error</a>(StylesheetExecutionContext &amp;theContext, XalanMessages::Codes theCode) const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b15">error</a>(StylesheetExecutionContext &amp;theContext, XalanMessages::Codes theCode, const XalanDOMString &amp;theToken) const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b16">error</a>(StylesheetExecutionContext &amp;theContext, XalanMessages::Codes theCode, const Locator *theLocator) const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b20">error</a>(StylesheetConstructionContext &amp;theContext, XalanMessages::Codes theCode)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b21">error</a>(StylesheetConstructionContext &amp;theContext, XalanMessages::Codes theCode, const XalanDOMString &amp;theToken)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b22">error</a>(StylesheetConstructionContext &amp;theContext, XalanMessages::Codes theCode, const XalanDOMString &amp;theToken, const Locator *theLocator)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b23">error</a>(StylesheetConstructionContext &amp;theContext, XalanMessages::Codes theCode, const XalanDOMString &amp;theToken1, const XalanDOMString &amp;theToken2)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b24">error</a>(StylesheetConstructionContext &amp;theContext, XalanMessages::Codes theCode, const XalanDOMChar *theToken1, const XalanDOMChar *theToken2)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b25">error</a>(StylesheetConstructionContext &amp;theContext, XalanMessages::Codes theCode, const XalanDOMChar *theToken1, const XalanDOMChar *theToken2, const XalanDOMChar *theToken3)
<code> [protected]</code><li><a class="el" href="classElemLiteralResult.html#a7">evaluateAVTs</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a8">execute</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a33">executeChildElement</a>(StylesheetExecutionContext &amp;executionContext, const ElemTemplateElement *element) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a9">executeChildren</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#b9">findTemplateToTransformChild</a>(StylesheetExecutionContext &amp;executionContext, const ElemTemplateElement &amp;xslInstruction, const ElemTemplateElement *theTemplate, XalanNode *child) const
<code> [protected, virtual]</code><li><a class="el" href="classElemTemplateElement.html#b10">findTemplateToTransformChild</a>(StylesheetExecutionContext &amp;executionContext, const ElemTemplateElement &amp;xslInstruction, const ElemTemplateElement *theTemplate, XalanNode *child, XalanNode::NodeType nodeType) const
<code> [protected, virtual]</code><li><a class="el" href="classElemTemplateElement.html#a44">getColumnNumber</a>() const
<li><a class="el" href="classElemLiteralResult.html#a2">getElementName</a>() const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a21">getFinishedConstruction</a>() const
<li><a class="el" href="classElemTemplateElement.html#a23">getFirstChildElem</a>() const
<code> [virtual]</code><li><a class="el" href="classElemUse.html#a8">getFirstChildElemToExecute</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a10">getInvoker</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a29">getLastChildElem</a>() const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a43">getLineNumber</a>() const
<li><a class="el" href="classElemTemplateElement.html#a3">getLocator</a>() const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a14">getNameAttribute</a>() const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a41">getNamespaceForPrefix</a>(const XalanDOMString &amp;prefix) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#b8">getNamespaceForPrefixInternal</a>(const XalanDOMString &amp;prefix) const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b13">getNamespaces</a>() const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#a18">getNamespacesHandler</a>() const
<li><a class="el" href="classElemUse.html#b0">getNextAttributeSet</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [protected]</code><li><a class="el" href="classElemUse.html#a7">getNextChildElemToExecute</a>(StylesheetExecutionContext &amp;executionContext, const ElemTemplateElement *currentElem) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a30">getNextSiblingElem</a>() const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a37">getParentNodeElem</a>() const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a35">getPreviousSiblingElem</a>() const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a19">getStylesheet</a>() const
<li><a class="el" href="classElemTemplateElement.html#a42">getURI</a>() const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a40">getXPath</a>(unsigned int index=0) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a11">getXSLToken</a>() const
<li><a class="el" href="classElemTemplateElement.html#a48">hasChildren</a>() const
<li><a class="el" href="classElemTemplateElement.html#a49">hasDirectTemplate</a>() const
<li><a class="el" href="classElemTemplateElement.html#a45">hasParams</a>() const
<li><a class="el" href="classElemTemplateElement.html#b1">hasPrefix</a>(bool value)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b2">hasPrefix</a>() const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#a47">hasSingleTextChild</a>() const
<li><a class="el" href="classElemTemplateElement.html#a46">hasVariables</a>() const
<li><a class="el" href="classElemLiteralResult.html#b0">init</a>(StylesheetConstructionContext &amp;constructionContext, Stylesheet &amp;stylesheetTree, const XalanDOMChar *name, const AttributeListType &amp;atts)
<code> [protected]</code><li><a class="el" href="classElemLiteralResult.html#a4">isAttrOK</a>(const XalanDOMChar *attrName, const AttributeListType &amp;atts, int which, StylesheetConstructionContext &amp;constructionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a51">isDefaultTemplate</a>() const
<li><a class="el" href="classElemTemplateElement.html#d0">isValidNCName</a>(const XalanDOMString &amp;s)
<code> [static]</code><li><a class="el" href="classElemTemplateElement.html#a12">isWhitespace</a>() const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#m1">m_directTemplate</a>
<li><a class="el" href="classElemTemplateElement.html#m0">m_firstChild</a>
<li><a class="el" href="classElemTemplateElement.html#m2">m_textLiteralChild</a>
<li><a class="el" href="classElemLiteralResult.html#b2">namespacesPostConstruction</a>(StylesheetConstructionContext &amp;constructionContext, const NamespacesHandler &amp;theParentHandler, NamespacesHandler &amp;theHandler)
<code> [protected, virtual]</code><li><a class="el" href="classElemLiteralResult.html#a3">postConstruction</a>(StylesheetConstructionContext &amp;constructionContext, const NamespacesHandler &amp;theParentHandler)
<code> [virtual]</code><li><a class="el" href="classPrefixResolver.html#a0">PrefixResolver</a>()
<li><a class="el" href="classPrefixResolver.html#a1">PrefixResolver</a>(const PrefixResolver &amp;)
<li><a class="el" href="classElemTemplateElement.html#b3">preserveSpace</a>(bool value)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b4">preserveSpace</a>() const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b7">processPrefixControl</a>(StylesheetConstructionContext &amp;constructionContext, const Stylesheet &amp;stylesheetTree, const XalanDOMString &amp;localName, const XalanDOMChar *attrValue)
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#a16">processSortElement</a>(StylesheetConstructionContext &amp;constructionContext, Stylesheet &amp;theStylesheet, const AttributeListType &amp;atts, const LocatorType *locator=0)
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a5">processSpaceAttr</a>(const XalanDOMChar *elementName, const XalanDOMChar *aname, const AttributeListType &amp;atts, int which, StylesheetConstructionContext &amp;constructionContext)
<li><a class="el" href="classElemUse.html#a2">processUseAttributeSets</a>(StylesheetConstructionContext &amp;constructionContext, const XalanDOMChar *attrName, const AttributeListType &amp;atts, int which)
<li><a class="el" href="classElemTemplateElement.html#q0">s_emptyString</a>
<code> [protected, static]</code><li><a class="el" href="classElemTemplateElement.html#a17">setDefaultTemplate</a>(bool value)
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a20">setFinishedConstruction</a>(bool fValue)
<li><a class="el" href="classElemTemplateElement.html#a28">setFirstChildElem</a>(ElemTemplateElement *theChild)
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a34">setNextSiblingElem</a>(ElemTemplateElement *theSibling)
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a38">setParentNodeElem</a>(ElemTemplateElement *theParent)
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a36">setPreviousSiblingElem</a>(ElemTemplateElement *theSibling)
<code> [virtual]</code><li><a class="el" href="classElemUse.html#s0">size_type</a> typedef
<li><a class="el" href="classElemLiteralResult.html#a5">startElement</a>(StylesheetExecutionContext &amp;executionContext) const
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#b17">warn</a>(StylesheetExecutionContext &amp;theContext, XalanMessages::Codes theCode) const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b18">warn</a>(StylesheetExecutionContext &amp;theContext, XalanMessages::Codes theCode, const XalanDOMString &amp;theToken) const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b19">warn</a>(StylesheetExecutionContext &amp;theContext, XalanMessages::Codes theCode, const Locator *theLocator) const
<code> [protected]</code><li><a class="el" href="classElemTemplateElement.html#b26">warn</a>(StylesheetConstructionContext &amp;theContext, XalanMessages::Codes theCode, const XalanDOMChar *theToken1, const XalanDOMChar *theToken2, const XalanDOMChar *theToken3)
<code> [protected]</code><li><a class="el" href="classElemLiteralResult.html#a1">~ElemLiteralResult</a>()
<code> [virtual]</code><li><a class="el" href="classElemTemplateElement.html#a2">~ElemTemplateElement</a>()
<code> [virtual]</code><li><a class="el" href="classElemUse.html#a1">~ElemUse</a>()
<code> [virtual]</code><li><a class="el" href="classPrefixResolver.html#a2">~PrefixResolver</a>()
<code> [virtual]</code></ul>
<p align="center"><a href="diagramnotes.html">Interpreting class diagrams</a></p>
<p><FONT color="#000000" face="arial,helvetica,sanserif" size="-1">
<i><A href="http://www.stack.nl/~dimitri/doxygen/">Doxygen</A> and 
<A href="http://www.research.att.com/sw/tools/graphviz/">GraphViz</A> are used to generate this API documentation from the Xalan-C header files.</I></FONT></p>

<TABLE border="0" cellpadding="0" cellspacing="0" width="820"><TR><TD bgcolor="#0086b2"><IMG height="1" src="../resources/dot.gif" width="1" alt="dot"></TD></TR></TABLE>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0" WIDTH="80%">
	<TR>
		<TD WIDTH="80%" VALIGN="TOP">
			<P ALIGN="CENTER"><B>Xalan-C++ XSLT Processor Version 1.10</B><BR>
			Copyright &copy; 1999-2004 The Apache Software Foundation. All Rights Reserved.</i></p>
		</TD>
	</TR>
	<TR>
		<TD WIDTH="100%">
			<P ALIGN="CENTER"><IMG SRC="ApacheLogo.jpg" WIDTH="387" HEIGHT="100" ALIGN="BOTTOM" BORDER="0" ALT="Apache Logo">
		</TD>
	</TR>
</TABLE>
