<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_281) on Sun Jan 15 15:58:36 CET 2023 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Serialized Form (FreeMarker 2.3.32 API)</title>
<meta name="date" content="2023-01-15">
<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
<script type="text/javascript" src="script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="Serialized Form (FreeMarker 2.3.32 API)";
        }
    }
    catch(err) {
    }
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="overview-summary.html">Overview</a></li>
<li>Package</li>
<li>Class</li>
<li>Use</li>
<li><a href="overview-tree.html">Tree</a></li>
<li><a href="deprecated-list.html">Deprecated</a></li>
<li><a href="index-all.html">Index</a></li>
<li><a href="help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="index.html?serialized-form.html" target="_top">Frames</a></li>
<li><a href="serialized-form.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<a name="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<div class="header">
<h1 title="Serialized Form" class="title">Serialized Form</h1>
</div>
<div class="serializedFormContainer">
<ul class="blockList">
<li class="blockList">
<h2 title="Package">Package&nbsp;freemarker.cache</h2>
<ul class="blockList">
<li class="blockList"><a name="freemarker.cache.TemplateConfigurationFactoryException">
<!--   -->
</a>
<h3>Class <a href="freemarker/cache/TemplateConfigurationFactoryException.html" title="class in freemarker.cache">freemarker.cache.TemplateConfigurationFactoryException</a> extends java.lang.Exception implements Serializable</h3>
</li>
</ul>
</li>
<li class="blockList">
<h2 title="Package">Package&nbsp;freemarker.core</h2>
<ul class="blockList">
<li class="blockList"><a name="freemarker.core._MiscTemplateException">
<!--   -->
</a>
<h3>Class freemarker.core._MiscTemplateException extends <a href="freemarker/template/TemplateException.html" title="class in freemarker.template">TemplateException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core._ObjectBuilderSettingEvaluationException">
<!--   -->
</a>
<h3>Class freemarker.core._ObjectBuilderSettingEvaluationException extends java.lang.Exception implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core._TemplateModelException">
<!--   -->
</a>
<h3>Class freemarker.core._TemplateModelException extends <a href="freemarker/template/TemplateModelException.html" title="class in freemarker.template">TemplateModelException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.BugException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/BugException.html" title="class in freemarker.core">freemarker.core.BugException</a> extends java.lang.RuntimeException implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.CallPlaceCustomDataInitializationException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/CallPlaceCustomDataInitializationException.html" title="class in freemarker.core">freemarker.core.CallPlaceCustomDataInitializationException</a> extends java.lang.Exception implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.CollectionAndSequence">
<!--   -->
</a>
<h3>Class freemarker.core.CollectionAndSequence extends java.lang.Object implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>collection</h4>
<pre><a href="freemarker/template/TemplateCollectionModel.html" title="interface in freemarker.template">TemplateCollectionModel</a> collection</pre>
</li>
<li class="blockList">
<h4>sequence</h4>
<pre><a href="freemarker/template/TemplateSequenceModel.html" title="interface in freemarker.template">TemplateSequenceModel</a> sequence</pre>
</li>
<li class="blockListLast">
<h4>data</h4>
<pre>java.util.ArrayList&lt;E&gt; data</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.core.Configurable.SettingValueAssignmentException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/Configurable.SettingValueAssignmentException.html" title="class in freemarker.core">freemarker.core.Configurable.SettingValueAssignmentException</a> extends freemarker.core._MiscTemplateException implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.Configurable.UnknownSettingException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/Configurable.UnknownSettingException.html" title="class in freemarker.core">freemarker.core.Configurable.UnknownSettingException</a> extends freemarker.core._MiscTemplateException implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.Environment.Namespace">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/Environment.Namespace.html" title="class in freemarker.core">freemarker.core.Environment.Namespace</a> extends <a href="freemarker/template/SimpleHash.html" title="class in freemarker.template">SimpleHash</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>template</h4>
<pre><a href="freemarker/template/Template.html" title="class in freemarker.template">Template</a> template</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.core.FreeMarkerTree">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/FreeMarkerTree.html" title="class in freemarker.core">freemarker.core.FreeMarkerTree</a> extends javax.swing.JTree implements Serializable</h3>
<dl class="nameValue">
<dt>serialVersionUID:</dt>
<dd>1L</dd>
</dl>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>nodeMap</h4>
<pre>java.util.Map&lt;K,V&gt; nodeMap</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.core.InvalidFormatParametersException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/InvalidFormatParametersException.html" title="class in freemarker.core">freemarker.core.InvalidFormatParametersException</a> extends <a href="freemarker/core/InvalidFormatStringException.html" title="class in freemarker.core">InvalidFormatStringException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.InvalidFormatStringException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/InvalidFormatStringException.html" title="class in freemarker.core">freemarker.core.InvalidFormatStringException</a> extends <a href="freemarker/core/TemplateValueFormatException.html" title="class in freemarker.core">TemplateValueFormatException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.InvalidReferenceException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/InvalidReferenceException.html" title="class in freemarker.core">freemarker.core.InvalidReferenceException</a> extends <a href="freemarker/template/TemplateException.html" title="class in freemarker.template">TemplateException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonBooleanException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonBooleanException.html" title="class in freemarker.core">freemarker.core.NonBooleanException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonDateException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonDateException.html" title="class in freemarker.core">freemarker.core.NonDateException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonExtendedHashException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonExtendedHashException.html" title="class in freemarker.core">freemarker.core.NonExtendedHashException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonExtendedNodeException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonExtendedNodeException.html" title="class in freemarker.core">freemarker.core.NonExtendedNodeException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonHashException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonHashException.html" title="class in freemarker.core">freemarker.core.NonHashException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonMarkupOutputException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonMarkupOutputException.html" title="class in freemarker.core">freemarker.core.NonMarkupOutputException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonMethodException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonMethodException.html" title="class in freemarker.core">freemarker.core.NonMethodException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonNodeException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonNodeException.html" title="class in freemarker.core">freemarker.core.NonNodeException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonNumericalException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonNumericalException.html" title="class in freemarker.core">freemarker.core.NonNumericalException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonSequenceException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonSequenceException.html" title="class in freemarker.core">freemarker.core.NonSequenceException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonSequenceOrCollectionException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonSequenceOrCollectionException.html" title="class in freemarker.core">freemarker.core.NonSequenceOrCollectionException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonStringException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonStringException.html" title="class in freemarker.core">freemarker.core.NonStringException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.NonStringOrTemplateOutputException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/NonStringOrTemplateOutputException.html" title="class in freemarker.core">freemarker.core.NonStringOrTemplateOutputException</a> extends <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">UnexpectedTypeException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.ParseException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/ParseException.html" title="class in freemarker.core">freemarker.core.ParseException</a> extends java.io.IOException implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>currentToken</h4>
<pre>freemarker.core.Token currentToken</pre>
<div class="block">This is the last token that has been consumed successfully.  If
 this object has been created due to a parse error, the token
 following this token will (therefore) be the first error token.</div>
</li>
<li class="blockList">
<h4>messageAndDescriptionRendered</h4>
<pre>boolean messageAndDescriptionRendered</pre>
</li>
<li class="blockList">
<h4>message</h4>
<pre>java.lang.String message</pre>
</li>
<li class="blockList">
<h4>description</h4>
<pre>java.lang.String description</pre>
</li>
<li class="blockList">
<h4>columnNumber</h4>
<pre>int columnNumber</pre>
</li>
<li class="blockList">
<h4>lineNumber</h4>
<pre>int lineNumber</pre>
</li>
<li class="blockList">
<h4>endColumnNumber</h4>
<pre>int endColumnNumber</pre>
</li>
<li class="blockList">
<h4>endLineNumber</h4>
<pre>int endLineNumber</pre>
</li>
<li class="blockList">
<h4>expectedTokenSequences</h4>
<pre>int[][] expectedTokenSequences</pre>
<div class="block">Each entry in this array is an array of integers.  Each array
 of integers represents a sequence of tokens (by their ordinal
 values) that is expected at this point of the parse.</div>
</li>
<li class="blockList">
<h4>tokenImage</h4>
<pre>java.lang.String[] tokenImage</pre>
<div class="block">This is a reference to the "tokenImage" array of the generated
 parser within which the parse error occurred.  This array is
 defined in the generated ...Constants interface.</div>
</li>
<li class="blockList">
<h4>eol</h4>
<pre>java.lang.String eol</pre>
<div class="block">The end of line string for this machine.</div>
</li>
<li class="blockList">
<h4>specialConstructor</h4>
<pre>boolean specialConstructor</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">Will be remove without replacement in 2.4.</span></div>
</li>
<li class="blockListLast">
<h4>templateName</h4>
<pre>java.lang.String templateName</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.core.ParsingNotSupportedException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/ParsingNotSupportedException.html" title="class in freemarker.core">freemarker.core.ParsingNotSupportedException</a> extends <a href="freemarker/core/TemplateValueFormatException.html" title="class in freemarker.core">TemplateValueFormatException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.ReturnInstruction.Return">
<!--   -->
</a>
<h3>Class freemarker.core.ReturnInstruction.Return extends freemarker.core.FlowControlException implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.StopException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/StopException.html" title="class in freemarker.core">freemarker.core.StopException</a> extends <a href="freemarker/template/TemplateException.html" title="class in freemarker.template">TemplateException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.TemplateElementArrayBuilder">
<!--   -->
</a>
<h3>Class freemarker.core.TemplateElementArrayBuilder extends java.lang.Object implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.TemplateValueFormatException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/TemplateValueFormatException.html" title="class in freemarker.core">freemarker.core.TemplateValueFormatException</a> extends java.lang.Exception implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.TokenMgrError">
<!--   -->
</a>
<h3>Class freemarker.core.TokenMgrError extends java.lang.Error implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>errorCode</h4>
<pre>int errorCode</pre>
</li>
<li class="blockList">
<h4>detail</h4>
<pre>java.lang.String detail</pre>
</li>
<li class="blockList">
<h4>lineNumber</h4>
<pre>java.lang.Integer lineNumber</pre>
</li>
<li class="blockList">
<h4>columnNumber</h4>
<pre>java.lang.Integer columnNumber</pre>
</li>
<li class="blockList">
<h4>endLineNumber</h4>
<pre>java.lang.Integer endLineNumber</pre>
</li>
<li class="blockListLast">
<h4>endColumnNumber</h4>
<pre>java.lang.Integer endColumnNumber</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.core.UndefinedCustomFormatException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/UndefinedCustomFormatException.html" title="class in freemarker.core">freemarker.core.UndefinedCustomFormatException</a> extends <a href="freemarker/core/InvalidFormatStringException.html" title="class in freemarker.core">InvalidFormatStringException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.UnexpectedTypeException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/UnexpectedTypeException.html" title="class in freemarker.core">freemarker.core.UnexpectedTypeException</a> extends <a href="freemarker/template/TemplateException.html" title="class in freemarker.template">TemplateException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.UnformattableValueException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/UnformattableValueException.html" title="class in freemarker.core">freemarker.core.UnformattableValueException</a> extends <a href="freemarker/core/TemplateValueFormatException.html" title="class in freemarker.core">TemplateValueFormatException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.UnknownDateTypeFormattingUnsupportedException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/UnknownDateTypeFormattingUnsupportedException.html" title="class in freemarker.core">freemarker.core.UnknownDateTypeFormattingUnsupportedException</a> extends <a href="freemarker/core/UnformattableValueException.html" title="class in freemarker.core">UnformattableValueException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.UnknownDateTypeParsingUnsupportedException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/UnknownDateTypeParsingUnsupportedException.html" title="class in freemarker.core">freemarker.core.UnknownDateTypeParsingUnsupportedException</a> extends <a href="freemarker/core/UnformattableValueException.html" title="class in freemarker.core">UnformattableValueException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.UnparsableValueException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/UnparsableValueException.html" title="class in freemarker.core">freemarker.core.UnparsableValueException</a> extends <a href="freemarker/core/TemplateValueFormatException.html" title="class in freemarker.core">TemplateValueFormatException</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.core.UnregisteredOutputFormatException">
<!--   -->
</a>
<h3>Class <a href="freemarker/core/UnregisteredOutputFormatException.html" title="class in freemarker.core">freemarker.core.UnregisteredOutputFormatException</a> extends java.lang.Exception implements Serializable</h3>
</li>
</ul>
</li>
<li class="blockList">
<h2 title="Package">Package&nbsp;freemarker.debug</h2>
<ul class="blockList">
<li class="blockList"><a name="freemarker.debug.Breakpoint">
<!--   -->
</a>
<h3>Class <a href="freemarker/debug/Breakpoint.html" title="class in freemarker.debug">freemarker.debug.Breakpoint</a> extends java.lang.Object implements Serializable</h3>
<dl class="nameValue">
<dt>serialVersionUID:</dt>
<dd>1L</dd>
</dl>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>templateName</h4>
<pre>java.lang.String templateName</pre>
</li>
<li class="blockListLast">
<h4>line</h4>
<pre>int line</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.debug.EnvironmentSuspendedEvent">
<!--   -->
</a>
<h3>Class <a href="freemarker/debug/EnvironmentSuspendedEvent.html" title="class in freemarker.debug">freemarker.debug.EnvironmentSuspendedEvent</a> extends java.util.EventObject implements Serializable</h3>
<dl class="nameValue">
<dt>serialVersionUID:</dt>
<dd>1L</dd>
</dl>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>name</h4>
<pre>java.lang.String name</pre>
</li>
<li class="blockList">
<h4>line</h4>
<pre>int line</pre>
</li>
<li class="blockListLast">
<h4>env</h4>
<pre><a href="freemarker/debug/DebuggedEnvironment.html" title="interface in freemarker.debug">DebuggedEnvironment</a> env</pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList">
<h2 title="Package">Package&nbsp;freemarker.ext.beans</h2>
<ul class="blockList">
<li class="blockList"><a name="freemarker.ext.beans.InvalidPropertyException">
<!--   -->
</a>
<h3>Class <a href="freemarker/ext/beans/InvalidPropertyException.html" title="class in freemarker.ext.beans">freemarker.ext.beans.InvalidPropertyException</a> extends <a href="freemarker/template/TemplateModelException.html" title="class in freemarker.template">TemplateModelException</a> implements Serializable</h3>
</li>
</ul>
</li>
<li class="blockList">
<h2 title="Package">Package&nbsp;freemarker.ext.beans.delme</h2>
<ul class="blockList">
<li class="blockList"><a name="freemarker.ext.beans.delme.AdhocTestNonPublicSubType">
<!--   -->
</a>
<h3>Class <a href="freemarker/ext/beans/delme/AdhocTestNonPublicSubType.html" title="class in freemarker.ext.beans.delme">freemarker.ext.beans.delme.AdhocTestNonPublicSubType</a> extends <a href="freemarker/ext/beans/delme/AdhocTestPublicType.html" title="class in freemarker.ext.beans.delme">AdhocTestPublicType</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.ext.beans.delme.AdhocTestPublicSubSubType">
<!--   -->
</a>
<h3>Class <a href="freemarker/ext/beans/delme/AdhocTestPublicSubSubType.html" title="class in freemarker.ext.beans.delme">freemarker.ext.beans.delme.AdhocTestPublicSubSubType</a> extends <a href="freemarker/ext/beans/delme/AdhocTestNonPublicSubType.html" title="class in freemarker.ext.beans.delme">AdhocTestNonPublicSubType</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.ext.beans.delme.AdhocTestPublicType">
<!--   -->
</a>
<h3>Class <a href="freemarker/ext/beans/delme/AdhocTestPublicType.html" title="class in freemarker.ext.beans.delme">freemarker.ext.beans.delme.AdhocTestPublicType</a> extends java.lang.Object implements Serializable</h3>
</li>
</ul>
</li>
<li class="blockList">
<h2 title="Package">Package&nbsp;freemarker.ext.servlet</h2>
<ul class="blockList">
<li class="blockList"><a name="freemarker.ext.servlet.AllHttpScopesHashModel">
<!--   -->
</a>
<h3>Class <a href="freemarker/ext/servlet/AllHttpScopesHashModel.html" title="class in freemarker.ext.servlet">freemarker.ext.servlet.AllHttpScopesHashModel</a> extends <a href="freemarker/template/SimpleHash.html" title="class in freemarker.template">SimpleHash</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>context</h4>
<pre>javax.servlet.ServletContext context</pre>
</li>
<li class="blockList">
<h4>request</h4>
<pre>javax.servlet.http.HttpServletRequest request</pre>
</li>
<li class="blockListLast">
<h4>unlistedModels</h4>
<pre>java.util.Map&lt;K,V&gt; unlistedModels</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.ext.servlet.FreemarkerServlet">
<!--   -->
</a>
<h3>Class <a href="freemarker/ext/servlet/FreemarkerServlet.html" title="class in freemarker.ext.servlet">freemarker.ext.servlet.FreemarkerServlet</a> extends javax.servlet.http.HttpServlet implements Serializable</h3>
<dl class="nameValue">
<dt>serialVersionUID:</dt>
<dd>-2440216393145762479L</dd>
</dl>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>templatePath</h4>
<pre>java.lang.String templatePath</pre>
</li>
<li class="blockList">
<h4>noCache</h4>
<pre>boolean noCache</pre>
</li>
<li class="blockList">
<h4>bufferSize</h4>
<pre>java.lang.Integer bufferSize</pre>
</li>
<li class="blockList">
<h4>exceptionOnMissingTemplate</h4>
<pre>boolean exceptionOnMissingTemplate</pre>
</li>
<li class="blockList">
<h4>debug</h4>
<pre>boolean debug</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">Not used anymore; to enable/disable debug logging, just set the logging level of the logging library
             used by <a href="freemarker/log/Logger.html" title="class in freemarker.log"><code>Logger</code></a>.</span></div>
</li>
<li class="blockList">
<h4>config</h4>
<pre><a href="freemarker/template/Configuration.html" title="class in freemarker.template">Configuration</a> config</pre>
</li>
<li class="blockList">
<h4>wrapper</h4>
<pre><a href="freemarker/template/ObjectWrapper.html" title="interface in freemarker.template">ObjectWrapper</a> wrapper</pre>
</li>
<li class="blockList">
<h4>contentType</h4>
<pre>freemarker.ext.servlet.FreemarkerServlet.ContentType contentType</pre>
</li>
<li class="blockList">
<h4>overrideResponseContentType</h4>
<pre>freemarker.ext.servlet.FreemarkerServlet.OverrideResponseContentType overrideResponseContentType</pre>
</li>
<li class="blockList">
<h4>responseCharacterEncoding</h4>
<pre>freemarker.ext.servlet.FreemarkerServlet.ResponseCharacterEncoding responseCharacterEncoding</pre>
</li>
<li class="blockList">
<h4>forcedResponseCharacterEncoding</h4>
<pre>java.nio.charset.Charset forcedResponseCharacterEncoding</pre>
</li>
<li class="blockList">
<h4>overrideResponseLocale</h4>
<pre>freemarker.ext.servlet.FreemarkerServlet.OverrideResponseLocale overrideResponseLocale</pre>
</li>
<li class="blockList">
<h4>metaInfTldSources</h4>
<pre>java.util.List&lt;E&gt; metaInfTldSources</pre>
</li>
<li class="blockList">
<h4>classpathTlds</h4>
<pre>java.util.List&lt;E&gt; classpathTlds</pre>
</li>
<li class="blockList">
<h4>lazyInitFieldsLock</h4>
<pre>java.lang.Object lazyInitFieldsLock</pre>
</li>
<li class="blockList">
<h4>servletContextModel</h4>
<pre><a href="freemarker/ext/servlet/ServletContextHashModel.html" title="class in freemarker.ext.servlet">ServletContextHashModel</a> servletContextModel</pre>
</li>
<li class="blockList">
<h4>taglibFactory</h4>
<pre><a href="freemarker/ext/jsp/TaglibFactory.html" title="class in freemarker.ext.jsp">TaglibFactory</a> taglibFactory</pre>
</li>
<li class="blockListLast">
<h4>objectWrapperMismatchWarnLogged</h4>
<pre>boolean objectWrapperMismatchWarnLogged</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.ext.servlet.HttpSessionHashModel">
<!--   -->
</a>
<h3>Class <a href="freemarker/ext/servlet/HttpSessionHashModel.html" title="class in freemarker.ext.servlet">freemarker.ext.servlet.HttpSessionHashModel</a> extends java.lang.Object implements Serializable</h3>
<dl class="nameValue">
<dt>serialVersionUID:</dt>
<dd>1L</dd>
</dl>
</li>
</ul>
</li>
<li class="blockList">
<h2 title="Package">Package&nbsp;freemarker.ext.util</h2>
<ul class="blockList">
<li class="blockList"><a name="freemarker.ext.util.IdentityHashMap">
<!--   -->
</a>
<h3>Class <a href="freemarker/ext/util/IdentityHashMap.html" title="class in freemarker.ext.util">freemarker.ext.util.IdentityHashMap</a> extends java.util.AbstractMap implements Serializable</h3>
<dl class="nameValue">
<dt>serialVersionUID:</dt>
<dd>362498820763181265L</dd>
</dl>
<ul class="blockList">
<li class="blockList">
<h3>Serialization Methods</h3>
<ul class="blockList">
<li class="blockList">
<h4>readObject</h4>
<pre>private&nbsp;void&nbsp;readObject(java.io.ObjectInputStream&nbsp;s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Reconstitute the <tt>IdentityHashMap</tt> instance from a stream (i.e.,
 deserialize it).</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>java.io.IOException</code></dd>
<dd><code>java.lang.ClassNotFoundException</code></dd>
</dl>
</li>
<li class="blockListLast">
<h4>writeObject</h4>
<pre>private&nbsp;void&nbsp;writeObject(java.io.ObjectOutputStream&nbsp;s)
                  throws java.io.IOException</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Save the state of the <tt>IdentityHashMap</tt> instance to a stream (i.e.,
 serialize it).</div>
<dl>
<dt><span class="simpleTagLabel">Serial Data:</span></dt>
<dd>The <i>capacity</i> of the IdentityHashMap (the length of the
                   bucket array) is emitted (int), followed  by the
                   <i>size</i> of the IdentityHashMap (the number of key-value
                   mappings), followed by the key (Object) and value (Object)
                   for each key-value mapping represented by the IdentityHashMap
 The key-value mappings are emitted in no particular order.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>java.io.IOException</code></dd>
</dl>
</li>
</ul>
</li>
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>threshold</h4>
<pre>int threshold</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">The table is rehashed when its size exceeds this threshold.  (The
 value of this field is (int)(capacity * loadFactor).)</div>
</li>
<li class="blockListLast">
<h4>loadFactor</h4>
<pre>float loadFactor</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">The load factor for the hashtable.</div>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList">
<h2 title="Package">Package&nbsp;freemarker.template</h2>
<ul class="blockList">
<li class="blockList"><a name="freemarker.template.DefaultArrayAdapter">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/DefaultArrayAdapter.html" title="class in freemarker.template">freemarker.template.DefaultArrayAdapter</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.template.DefaultEnumerationAdapter">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/DefaultEnumerationAdapter.html" title="class in freemarker.template">freemarker.template.DefaultEnumerationAdapter</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>enumeration</h4>
<pre>java.util.Enumeration&lt;E&gt; enumeration</pre>
</li>
<li class="blockListLast">
<h4>enumerationOwnedBySomeone</h4>
<pre>boolean enumerationOwnedBySomeone</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.DefaultIterableAdapter">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/DefaultIterableAdapter.html" title="class in freemarker.template">freemarker.template.DefaultIterableAdapter</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>iterable</h4>
<pre>java.lang.Iterable&lt;T&gt; iterable</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.DefaultIteratorAdapter">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/DefaultIteratorAdapter.html" title="class in freemarker.template">freemarker.template.DefaultIteratorAdapter</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>iterator</h4>
<pre>java.util.Iterator&lt;E&gt; iterator</pre>
</li>
<li class="blockListLast">
<h4>iteratorOwnedBySomeone</h4>
<pre>boolean iteratorOwnedBySomeone</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.DefaultListAdapter">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/DefaultListAdapter.html" title="class in freemarker.template">freemarker.template.DefaultListAdapter</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>list</h4>
<pre>java.util.List&lt;E&gt; list</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.DefaultMapAdapter">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/DefaultMapAdapter.html" title="class in freemarker.template">freemarker.template.DefaultMapAdapter</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>map</h4>
<pre>java.util.Map&lt;K,V&gt; map</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.DefaultNonListCollectionAdapter">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/DefaultNonListCollectionAdapter.html" title="class in freemarker.template">freemarker.template.DefaultNonListCollectionAdapter</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>collection</h4>
<pre>java.util.Collection&lt;E&gt; collection</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.MalformedTemplateNameException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/MalformedTemplateNameException.html" title="class in freemarker.template">freemarker.template.MalformedTemplateNameException</a> extends java.io.IOException implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>templateName</h4>
<pre>java.lang.String templateName</pre>
</li>
<li class="blockListLast">
<h4>malformednessDescription</h4>
<pre>java.lang.String malformednessDescription</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.SimpleCollection">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/SimpleCollection.html" title="class in freemarker.template">freemarker.template.SimpleCollection</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>iteratorOwned</h4>
<pre>boolean iteratorOwned</pre>
</li>
<li class="blockList">
<h4>iterator</h4>
<pre>java.util.Iterator&lt;E&gt; iterator</pre>
</li>
<li class="blockListLast">
<h4>iterable</h4>
<pre>java.lang.Iterable&lt;T&gt; iterable</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.SimpleHash">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/SimpleHash.html" title="class in freemarker.template">freemarker.template.SimpleHash</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>map</h4>
<pre>java.util.Map&lt;K,V&gt; map</pre>
</li>
<li class="blockList">
<h4>putFailed</h4>
<pre>boolean putFailed</pre>
</li>
<li class="blockListLast">
<h4>unwrappedMap</h4>
<pre>java.util.Map&lt;K,V&gt; unwrappedMap</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.SimpleList">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/SimpleList.html" title="class in freemarker.template">freemarker.template.SimpleList</a> extends <a href="freemarker/template/SimpleSequence.html" title="class in freemarker.template">SimpleSequence</a> implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.template.SimpleNumber">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/SimpleNumber.html" title="class in freemarker.template">freemarker.template.SimpleNumber</a> extends java.lang.Object implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>value</h4>
<pre>java.lang.Number value</pre>
<div class="block">the value of this <tt>SimpleNumber</tt></div>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.SimpleScalar">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/SimpleScalar.html" title="class in freemarker.template">freemarker.template.SimpleScalar</a> extends java.lang.Object implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>value</h4>
<pre>java.lang.String value</pre>
<div class="block">the value of this <tt>SimpleScalar</tt> if it wraps a
 <tt>String</tt>.</div>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.SimpleSequence">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/SimpleSequence.html" title="class in freemarker.template">freemarker.template.SimpleSequence</a> extends <a href="freemarker/template/WrappingTemplateModel.html" title="class in freemarker.template">WrappingTemplateModel</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>list</h4>
<pre>java.util.List&lt;E&gt; list</pre>
<div class="block">The <code>List</code> that stored the elements of this sequence. It migth contains both <a href="freemarker/template/TemplateModel.html" title="interface in freemarker.template"><code>TemplateModel</code></a> elements
 and non-<a href="freemarker/template/TemplateModel.html" title="interface in freemarker.template"><code>TemplateModel</code></a> elements.</div>
</li>
<li class="blockListLast">
<h4>unwrappedList</h4>
<pre>java.util.List&lt;E&gt; unwrappedList</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.Template.WrongEncodingException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/Template.WrongEncodingException.html" title="class in freemarker.template">freemarker.template.Template.WrongEncodingException</a> extends <a href="freemarker/core/ParseException.html" title="class in freemarker.core">ParseException</a> implements Serializable</h3>
<dl class="nameValue">
<dt>serialVersionUID:</dt>
<dd>1L</dd>
</dl>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>specifiedEncoding</h4>
<pre>java.lang.String specifiedEncoding</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">Use <a href="freemarker/template/Template.WrongEncodingException.html#getTemplateSpecifiedEncoding--"><code>Template.WrongEncodingException.getTemplateSpecifiedEncoding()</code></a> instead.</span></div>
</li>
<li class="blockListLast">
<h4>constructorSpecifiedEncoding</h4>
<pre>java.lang.String constructorSpecifiedEncoding</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.TemplateException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/TemplateException.html" title="class in freemarker.template">freemarker.template.TemplateException</a> extends java.lang.Exception implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialization Methods</h3>
<ul class="blockList">
<li class="blockList">
<h4>readObject</h4>
<pre>private&nbsp;void&nbsp;readObject(java.io.ObjectInputStream&nbsp;in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException</pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>java.io.IOException</code></dd>
<dd><code>java.lang.ClassNotFoundException</code></dd>
</dl>
</li>
<li class="blockListLast">
<h4>writeObject</h4>
<pre>private&nbsp;void&nbsp;writeObject(java.io.ObjectOutputStream&nbsp;out)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException</pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>java.io.IOException</code></dd>
<dd><code>java.lang.ClassNotFoundException</code></dd>
</dl>
</li>
</ul>
</li>
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>renderedFtlInstructionStackSnapshot</h4>
<pre>java.lang.String renderedFtlInstructionStackSnapshot</pre>
</li>
<li class="blockList">
<h4>renderedFtlInstructionStackSnapshotTop</h4>
<pre>java.lang.String renderedFtlInstructionStackSnapshotTop</pre>
</li>
<li class="blockList">
<h4>description</h4>
<pre>java.lang.String description</pre>
</li>
<li class="blockList">
<h4>blamedExpressionStringCalculated</h4>
<pre>boolean blamedExpressionStringCalculated</pre>
</li>
<li class="blockList">
<h4>blamedExpressionString</h4>
<pre>java.lang.String blamedExpressionString</pre>
</li>
<li class="blockList">
<h4>positionsCalculated</h4>
<pre>boolean positionsCalculated</pre>
</li>
<li class="blockList">
<h4>templateName</h4>
<pre>java.lang.String templateName</pre>
</li>
<li class="blockList">
<h4>templateSourceName</h4>
<pre>java.lang.String templateSourceName</pre>
</li>
<li class="blockList">
<h4>lineNumber</h4>
<pre>java.lang.Integer lineNumber</pre>
</li>
<li class="blockList">
<h4>columnNumber</h4>
<pre>java.lang.Integer columnNumber</pre>
</li>
<li class="blockList">
<h4>endLineNumber</h4>
<pre>java.lang.Integer endLineNumber</pre>
</li>
<li class="blockListLast">
<h4>endColumnNumber</h4>
<pre>java.lang.Integer endColumnNumber</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.TemplateModelException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/TemplateModelException.html" title="class in freemarker.template">freemarker.template.TemplateModelException</a> extends <a href="freemarker/template/TemplateException.html" title="class in freemarker.template">TemplateException</a> implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>replaceWithCause</h4>
<pre>boolean replaceWithCause</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.TemplateNotFoundException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/TemplateNotFoundException.html" title="class in freemarker.template">freemarker.template.TemplateNotFoundException</a> extends java.io.FileNotFoundException implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>templateName</h4>
<pre>java.lang.String templateName</pre>
</li>
<li class="blockListLast">
<h4>customLookupCondition</h4>
<pre>java.lang.Object customLookupCondition</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.Version">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/Version.html" title="class in freemarker.template">freemarker.template.Version</a> extends java.lang.Object implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockList">
<h4>major</h4>
<pre>int major</pre>
</li>
<li class="blockList">
<h4>minor</h4>
<pre>int minor</pre>
</li>
<li class="blockList">
<h4>micro</h4>
<pre>int micro</pre>
</li>
<li class="blockList">
<h4>extraInfo</h4>
<pre>java.lang.String extraInfo</pre>
</li>
<li class="blockList">
<h4>originalStringValue</h4>
<pre>java.lang.String originalStringValue</pre>
</li>
<li class="blockList">
<h4>gaeCompliant</h4>
<pre>java.lang.Boolean gaeCompliant</pre>
</li>
<li class="blockList">
<h4>buildDate</h4>
<pre>java.util.Date buildDate</pre>
</li>
<li class="blockList">
<h4>intValue</h4>
<pre>int intValue</pre>
</li>
<li class="blockList">
<h4>calculatedStringValue</h4>
<pre>java.lang.String calculatedStringValue</pre>
</li>
<li class="blockListLast">
<h4>hashCode</h4>
<pre>int hashCode</pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList">
<h2 title="Package">Package&nbsp;freemarker.template.utility</h2>
<ul class="blockList">
<li class="blockList"><a name="freemarker.template.utility.DateUtil.DateParseException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/utility/DateUtil.DateParseException.html" title="class in freemarker.template.utility">freemarker.template.utility.DateUtil.DateParseException</a> extends java.text.ParseException implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.template.utility.NullArgumentException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/utility/NullArgumentException.html" title="class in freemarker.template.utility">freemarker.template.utility.NullArgumentException</a> extends java.lang.IllegalArgumentException implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.template.utility.UndeclaredThrowableException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/utility/UndeclaredThrowableException.html" title="class in freemarker.template.utility">freemarker.template.utility.UndeclaredThrowableException</a> extends java.lang.RuntimeException implements Serializable</h3>
</li>
<li class="blockList"><a name="freemarker.template.utility.UnrecognizedTimeZoneException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/utility/UnrecognizedTimeZoneException.html" title="class in freemarker.template.utility">freemarker.template.utility.UnrecognizedTimeZoneException</a> extends java.lang.Exception implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>timeZoneName</h4>
<pre>java.lang.String timeZoneName</pre>
</li>
</ul>
</li>
</ul>
</li>
<li class="blockList"><a name="freemarker.template.utility.UnsupportedNumberClassException">
<!--   -->
</a>
<h3>Class <a href="freemarker/template/utility/UnsupportedNumberClassException.html" title="class in freemarker.template.utility">freemarker.template.utility.UnsupportedNumberClassException</a> extends java.lang.RuntimeException implements Serializable</h3>
<ul class="blockList">
<li class="blockList">
<h3>Serialized Fields</h3>
<ul class="blockList">
<li class="blockListLast">
<h4>fClass</h4>
<pre>java.lang.Class&lt;T&gt; fClass</pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="overview-summary.html">Overview</a></li>
<li>Package</li>
<li>Class</li>
<li>Use</li>
<li><a href="overview-tree.html">Tree</a></li>
<li><a href="deprecated-list.html">Deprecated</a></li>
<li><a href="index-all.html">Index</a></li>
<li><a href="help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="index.html?serialized-form.html" target="_top">Frames</a></li>
<li><a href="serialized-form.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</body>
</html>
