<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--NewPage-->
<HTML>
<HEAD>
<!-- Generated by javadoc (build 1.5.0_08) on Mon Oct 02 11:45:19 GMT+09:00 2006 -->
<TITLE>
Index (Apache MINA API Documentation)
</TITLE>


<LINK REL ="stylesheet" TYPE="text/css" HREF="./stylesheet.css" TITLE="Style">

<SCRIPT type="text/javascript">
function windowTitle()
{
    parent.document.title="Index (Apache MINA API Documentation)";
}
</SCRIPT>
<NOSCRIPT>
</NOSCRIPT>

</HEAD>

<BODY BGCOLOR="white" onload="windowTitle();">


<!-- ========= START OF TOP NAVBAR ======= -->
<A NAME="navbar_top"><!-- --></A>
<A HREF="#skip-navbar_top" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_top_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
  <TR ALIGN="center" VALIGN="top">
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Package</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Class</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Use</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Index</B></FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A>&nbsp;</TD>
  </TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>

<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
&nbsp;PREV&nbsp;
&nbsp;NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
  <A HREF="./index.html?index-all.html" target="_top"><B>FRAMES</B></A>  &nbsp;
&nbsp;<A HREF="index-all.html" target="_top"><B>NO FRAMES</B></A>  &nbsp;
&nbsp;<SCRIPT type="text/javascript">
  <!--
  if(window==top) {
    document.writeln('<A HREF="./allclasses-noframe.html"><B>All Classes</B></A>');
  }
  //-->
</SCRIPT>
<NOSCRIPT>
  <A HREF="./allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>


</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_top"></A>
<!-- ========= END OF TOP NAVBAR ========= -->

<A HREF="#_A_">A</A> <A HREF="#_B_">B</A> <A HREF="#_C_">C</A> <A HREF="#_D_">D</A> <A HREF="#_E_">E</A> <A HREF="#_F_">F</A> <A HREF="#_G_">G</A> <A HREF="#_H_">H</A> <A HREF="#_I_">I</A> <A HREF="#_J_">J</A> <A HREF="#_K_">K</A> <A HREF="#_L_">L</A> <A HREF="#_M_">M</A> <A HREF="#_N_">N</A> <A HREF="#_O_">O</A> <A HREF="#_P_">P</A> <A HREF="#_Q_">Q</A> <A HREF="#_R_">R</A> <A HREF="#_S_">S</A> <A HREF="#_T_">T</A> <A HREF="#_U_">U</A> <A HREF="#_V_">V</A> <A HREF="#_W_">W</A> <A HREF="#_X_">X</A> <HR>
<A NAME="_A_"><!-- --></A><H2>
<B>A</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#acquire()"><B>acquire()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Increases the internal reference count of this buffer to defer
 automatic release.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#acquire()"><B>acquire()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ByteBufferUtil.html#acquireIfPossible(java.lang.Object)"><B>acquireIfPossible(Object)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ByteBufferUtil.html" title="class in org.apache.mina.util">ByteBufferUtil</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#add(int, java.lang.Object)"><B>add(int, Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#add(java.lang.Object)"><B>add(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/IdentityHashSet.html#add(java.lang.Object)"><B>add(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/IdentityHashSet.html" title="class in org.apache.mina.util">IdentityHashSet</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#add(java.lang.Object)"><B>add(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#add(int, java.lang.Object)"><B>add(int, Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#addAfter(java.lang.String, java.lang.String, org.apache.mina.common.IoFilter)"><B>addAfter(String, String, IoFilter)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#addAfter(java.lang.String, java.lang.String, org.apache.mina.common.IoFilter)"><B>addAfter(String, String, IoFilter)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Adds the specified filter with the specified name just after the filter whose name is
 <code>baseName</code> in this chain.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#addAfter(java.lang.String, java.lang.String, org.apache.mina.handler.chain.IoHandlerCommand)"><B>addAfter(String, String, IoHandlerCommand)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#addAll(int, java.util.Collection)"><B>addAll(int, Collection)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#addAll(java.util.Collection)"><B>addAll(Collection)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#addBefore(java.lang.String, java.lang.String, org.apache.mina.common.IoFilter)"><B>addBefore(String, String, IoFilter)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#addBefore(java.lang.String, java.lang.String, org.apache.mina.common.IoFilter)"><B>addBefore(String, String, IoFilter)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Adds the specified filter with the specified name just before the filter whose name is
 <code>baseName</code> in this chain.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#addBefore(java.lang.String, java.lang.String, org.apache.mina.handler.chain.IoHandlerCommand)"><B>addBefore(String, String, IoHandlerCommand)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#addExpirationListener(org.apache.mina.util.ExpirationListener)"><B>addExpirationListener(ExpirationListener)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#addFirst(java.lang.String, org.apache.mina.common.IoFilter)"><B>addFirst(String, IoFilter)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#addFirst(java.lang.String, org.apache.mina.common.IoFilter)"><B>addFirst(String, IoFilter)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Adds the specified filter with the specified name at the beginning of this chain.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#addFirst(java.lang.String, org.apache.mina.handler.chain.IoHandlerCommand)"><B>addFirst(String, IoHandlerCommand)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#addFirstLoggingFilter()"><B>addFirstLoggingFilter()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#addFirstLoggingFilter()"><B>addFirstLoggingFilter()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>add a logging filter at begining of the chain
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#addLast(java.lang.String, org.apache.mina.common.IoFilter)"><B>addLast(String, IoFilter)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#addLast(java.lang.String, org.apache.mina.common.IoFilter)"><B>addLast(String, IoFilter)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Adds the specified filter with the specified name at the end of this chain.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#addLast(java.lang.String, org.apache.mina.handler.chain.IoHandlerCommand)"><B>addLast(String, IoHandlerCommand)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#addLastLoggingFilter()"><B>addLastLoggingFilter()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#addLastLoggingFilter()"><B>addLastLoggingFilter()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>add a logging filter at end of the chain
<DT><A HREF="./org/apache/mina/common/IoFuture.html#addListener(org.apache.mina.common.IoFutureListener)"><B>addListener(IoFutureListener)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common">IoFuture</A>
<DD>Adds an event <tt>listener</tt> which is notified when
 the state of this future changes.
<DT><A HREF="./org/apache/mina/common/IoService.html#addListener(org.apache.mina.common.IoServiceListener)"><B>addListener(IoServiceListener)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common">IoService</A>
<DD>Adds an <A HREF="./org/apache/mina/common/IoServiceListener.html" title="interface in org.apache.mina.common"><CODE>IoServiceListener</CODE></A> that listens any events related with
 this service.
<DT><A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html#addMessageHandler(java.lang.Class, org.apache.mina.handler.demux.MessageHandler)"><B>addMessageHandler(Class, MessageHandler)</B></A> - 
Method in class org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html" title="class in org.apache.mina.handler.demux">DemuxingIoHandler</A>
<DD>Registers a <A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><CODE>MessageHandler</CODE></A> that receives the messages of
 the specified <code>type</code>.
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#afterPropertiesSet()"><B>afterPropertiesSet()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html#afterPropertiesSet()"><B>afterPropertiesSet()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html" title="class in org.apache.mina.integration.spring">ExecutorThreadModelFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html#afterPropertiesSet()"><B>afterPropertiesSet()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html" title="class in org.apache.mina.integration.spring">IoAcceptorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html#afterPropertiesSet()"><B>afterPropertiesSet()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html" title="class in org.apache.mina.integration.spring">IoFilterMapping</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#ALL"><B>ALL</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>This mask resumes both reads and writes if any of them were suspended.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#allocate(int)"><B>allocate(int)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns the direct or heap buffer which is capable of the specified
 size.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#allocate(int, boolean)"><B>allocate(int, boolean)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns the buffer which is capable of the specified size.
<DT><A HREF="./org/apache/mina/common/ByteBufferAllocator.html#allocate(int, boolean)"><B>allocate(int, boolean)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferAllocator.html" title="interface in org.apache.mina.common">ByteBufferAllocator</A>
<DD>Returns the buffer which is capable of the specified size.
<DT><A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html#allocate(int, boolean)"><B>allocate(int, boolean)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html" title="class in org.apache.mina.common">PooledByteBufferAllocator</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SimpleByteBufferAllocator.html#allocate(int, boolean)"><B>allocate(int, boolean)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/SimpleByteBufferAllocator.html" title="class in org.apache.mina.common">SimpleByteBufferAllocator</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#and(org.apache.mina.common.TrafficMask)"><B>and(TrafficMask)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>Peforms an <tt>AND</tt> operation on this mask with the specified
 <tt>mask</tt> and returns the result.
<DT><A HREF="./org/apache/mina/util/AnonymousSocketAddress.html" title="class in org.apache.mina.util"><B>AnonymousSocketAddress</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/net/SocketAddress.html" title="class or interface in java.net"><CODE>SocketAddress</CODE></A> which represents anonymous address.<DT><A HREF="./org/apache/mina/util/AnonymousSocketAddress.html#AnonymousSocketAddress()"><B>AnonymousSocketAddress()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/AnonymousSocketAddress.html" title="class in org.apache.mina.util">AnonymousSocketAddress</A>
<DD>Creates a new instance with the specifid port number.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#array()"><B>array()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#array()"><B>array()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#arrayOffset()"><B>arrayOffset()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#arrayOffset()"><B>arrayOffset()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#asCharBuffer()"><B>asCharBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#asCharBuffer()"><B>asCharBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#asDoubleBuffer()"><B>asDoubleBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#asDoubleBuffer()"><B>asDoubleBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#asFloatBuffer()"><B>asFloatBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#asFloatBuffer()"><B>asFloatBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#asInputStream()"><B>asInputStream()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns an <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/InputStream.html" title="class or interface in java.io"><CODE>InputStream</CODE></A> that reads the data from this buffer.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#asInputStream()"><B>asInputStream()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#asIntBuffer()"><B>asIntBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#asIntBuffer()"><B>asIntBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#asLongBuffer()"><B>asLongBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#asLongBuffer()"><B>asLongBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#asOutputStream()"><B>asOutputStream()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns an <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/OutputStream.html" title="class or interface in java.io"><CODE>OutputStream</CODE></A> that appends the data into this buffer.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#asOutputStream()"><B>asOutputStream()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#asReadOnlyBuffer()"><B>asReadOnlyBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#asReadOnlyBuffer()"><B>asReadOnlyBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#asShortBuffer()"><B>asShortBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#asShortBuffer()"><B>asShortBuffer()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html#attach(org.apache.mina.common.IoFilterChain)"><B>attach(IoFilterChain)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html" title="class in org.apache.mina.filter">ReadThrottleFilterBuilder</A>
<DD>Attach this filter to the specified filter chain.
<DT><A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html#attach(org.apache.mina.common.DefaultIoFilterChainBuilder)"><B>attach(DefaultIoFilterChainBuilder)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html" title="class in org.apache.mina.filter">ReadThrottleFilterBuilder</A>
<DD>Attach this filter to the specified builder.
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#AUTO"><B>AUTO</B></A> - 
Static variable in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>A special line delimiter which is used for auto-detection of
 EOL in <A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline"><CODE>TextLineDecoder</CODE></A>.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#autoExpand(int)"><B>autoExpand(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>This method forwards the call to <A HREF="./org/apache/mina/common/ByteBuffer.html#expand(int)"><CODE>ByteBuffer.expand(int)</CODE></A> only when
 <tt>autoExpand</tt> property is <tt>true</tt>.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#autoExpand(int, int)"><B>autoExpand(int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>This method forwards the call to <A HREF="./org/apache/mina/common/ByteBuffer.html#expand(int)"><CODE>ByteBuffer.expand(int)</CODE></A> only when
 <tt>autoExpand</tt> property is <tt>true</tt>.
<DT><A HREF="./org/apache/mina/util/AvailablePortFinder.html#available(int)"><B>available(int)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AvailablePortFinder.html" title="class in org.apache.mina.util">AvailablePortFinder</A>
<DD>Checks to see if a specific port is available.
<DT><A HREF="./org/apache/mina/util/AvailablePortFinder.html" title="class in org.apache.mina.util"><B>AvailablePortFinder</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>Finds currently available server ports.</DL>
<HR>
<A NAME="_B_"><!-- --></A><H2>
<B>B</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/IoAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.common.IoHandler)"><B>bind(SocketAddress, IoHandler)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common">IoAcceptor</A>
<DD>Binds to the specified <code>address</code> and handles incoming
 connections with the specified <code>handler</code>.
<DT><A HREF="./org/apache/mina/common/IoAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>bind(SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common">IoAcceptor</A>
<DD>Binds to the specified <code>address</code> and handles incoming
 connections with the specified <code>handler</code>.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>bind(SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptor</A>
<DD>Binds to the specified <code>address</code> and handles incoming connections with the specified
 <code>handler</code>.
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>bind(SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring"><B>Binding</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/package-summary.html">org.apache.mina.integration.spring</A><DD>Defines an address to <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> binding.<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#Binding()"><B>Binding()</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>Creates a new empty instance.
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#Binding(java.net.SocketAddress, org.apache.mina.common.IoHandler)"><B>Binding(SocketAddress, IoHandler)</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>Creates a new instance using the specified values.
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#Binding(java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>Binding(SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>Creates a new instance using the specified values.
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter"><B>BlacklistFilter</B></A> - Class in <A HREF="./org/apache/mina/filter/package-summary.html">org.apache.mina.filter</A><DD>A <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A> which blocks connections from blacklisted remote
 address.<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#BlacklistFilter()"><B>BlacklistFilter()</B></A> - 
Constructor for class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#block(java.net.InetAddress, java.lang.String)"><B>block(InetAddress, String)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>Blocks the specified endpoint.
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#block(java.net.InetAddress)"><B>block(InetAddress)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>Blocks the specified endpoint.
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util"><B>BlockingQueue</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A synchronized version of <A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util"><CODE>Queue</CODE></A>.<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#BlockingQueue()"><B>BlockingQueue()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/BogusTrustManagerFactory.html" title="class in org.apache.mina.integration.spring.ssl"><B>BogusTrustManagerFactory</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/ssl/package-summary.html">org.apache.mina.integration.spring.ssl</A><DD>Bogus <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory</CODE></A> which creates 
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/X509TrustManager.html" title="class or interface in javax.net.ssl"><CODE>X509TrustManager</CODE></A> trusting everything.<DT><A HREF="./org/apache/mina/integration/spring/ssl/BogusTrustManagerFactory.html#BogusTrustManagerFactory()"><B>BogusTrustManagerFactory()</B></A> - 
Constructor for class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/BogusTrustManagerFactory.html" title="class in org.apache.mina.integration.spring.ssl">BogusTrustManagerFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IdleStatus.html#BOTH_IDLE"><B>BOTH_IDLE</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IdleStatus.html" title="class in org.apache.mina.common">IdleStatus</A>
<DD>Represents both <A HREF="./org/apache/mina/common/IdleStatus.html#READER_IDLE"><CODE>IdleStatus.READER_IDLE</CODE></A> and <A HREF="./org/apache/mina/common/IdleStatus.html#WRITER_IDLE"><CODE>IdleStatus.WRITER_IDLE</CODE></A>.
<DT><A HREF="./org/apache/mina/common/BroadcastIoSession.html" title="interface in org.apache.mina.common"><B>BroadcastIoSession</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>An <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> for broadcast transports.<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#buf()"><B>buf()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns the underlying NIO buffer instance.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#buf"><B>buf</B></A> - 
Variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>The buffer proxied by this proxy.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#buf()"><B>buf()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BufferDataException.html" title="class in org.apache.mina.common"><B>BufferDataException</B></A> - Exception in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang"><CODE>RuntimeException</CODE></A> which is thrown when the data the <A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common"><CODE>ByteBuffer</CODE></A>
 contains is corrupt.<DT><A HREF="./org/apache/mina/common/BufferDataException.html#BufferDataException()"><B>BufferDataException()</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/BufferDataException.html" title="class in org.apache.mina.common">BufferDataException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BufferDataException.html#BufferDataException(java.lang.String)"><B>BufferDataException(String)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/BufferDataException.html" title="class in org.apache.mina.common">BufferDataException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BufferDataException.html#BufferDataException(java.lang.String, java.lang.Throwable)"><B>BufferDataException(String, Throwable)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/BufferDataException.html" title="class in org.apache.mina.common">BufferDataException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BufferDataException.html#BufferDataException(java.lang.Throwable)"><B>BufferDataException(Throwable)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/BufferDataException.html" title="class in org.apache.mina.common">BufferDataException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#buildFilterChain(org.apache.mina.common.IoFilterChain)"><B>buildFilterChain(IoFilterChain)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExecutorThreadModel.html#buildFilterChain(org.apache.mina.common.IoFilterChain)"><B>buildFilterChain(IoFilterChain)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExecutorThreadModel.html" title="class in org.apache.mina.common">ExecutorThreadModel</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChainBuilder.html#buildFilterChain(org.apache.mina.common.IoFilterChain)"><B>buildFilterChain(IoFilterChain)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChainBuilder.html" title="interface in org.apache.mina.common">IoFilterChainBuilder</A>
<DD>Modifies the specified <tt>chain</tt>.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common"><B>ByteBuffer</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A byte buffer used by MINA applications.<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#ByteBuffer()"><B>ByteBuffer()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferAllocator.html" title="interface in org.apache.mina.common"><B>ByteBufferAllocator</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Allocates <A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common"><CODE>ByteBuffer</CODE></A>s and manages them.<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common"><B>ByteBufferProxy</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A <A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common"><CODE>ByteBuffer</CODE></A> that wraps a buffer and proxies any operations to it.<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#ByteBufferProxy(org.apache.mina.common.ByteBuffer)"><B>ByteBufferProxy(ByteBuffer)</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>Create a new instance.
<DT><A HREF="./org/apache/mina/util/ByteBufferUtil.html" title="class in org.apache.mina.util"><B>ByteBufferUtil</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>ByteBuffer utility.<DT><A HREF="./org/apache/mina/util/Queue.html#byteSize()"><B>byteSize()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Returns the sum of the '<tt>remaining</tt>' of all <A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common"><CODE>ByteBuffer</CODE></A>s
 in this queue.
</DL>
<HR>
<A NAME="_C_"><!-- --></A><H2>
<B>C</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#capacity()"><B>capacity()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#capacity(int)"><B>capacity(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Changes the capacity of this buffer.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#capacity()"><B>capacity()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#capacity(int)"><B>capacity(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#capacity()"><B>capacity()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#capacity()"><B>capacity()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Returns the capacity of this queue.
<DT><A HREF="./org/apache/mina/handler/chain/ChainedIoHandler.html" title="class in org.apache.mina.handler.chain"><B>ChainedIoHandler</B></A> - Class in <A HREF="./org/apache/mina/handler/chain/package-summary.html">org.apache.mina.handler.chain</A><DD>An <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> which executes an <A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain"><CODE>IoHandlerChain</CODE></A>
 on a <tt>messageReceived</tt> event.<DT><A HREF="./org/apache/mina/handler/chain/ChainedIoHandler.html#ChainedIoHandler()"><B>ChainedIoHandler()</B></A> - 
Constructor for class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/ChainedIoHandler.html" title="class in org.apache.mina.handler.chain">ChainedIoHandler</A>
<DD>Creates a new instance which contains an empty <A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain"><CODE>IoHandlerChain</CODE></A>.
<DT><A HREF="./org/apache/mina/handler/chain/ChainedIoHandler.html#ChainedIoHandler(org.apache.mina.handler.chain.IoHandlerChain)"><B>ChainedIoHandler(IoHandlerChain)</B></A> - 
Constructor for class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/ChainedIoHandler.html" title="class in org.apache.mina.handler.chain">ChainedIoHandler</A>
<DD>Creates a new instance which executes the specified
 <A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain"><CODE>IoHandlerChain</CODE></A> on a <tt>messageReceived</tt> event.
<DT><A HREF="./org/apache/mina/util/CharsetUtil.html" title="class in org.apache.mina.util"><B>CharsetUtil</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>Utilities for dealing with Charsets.<DT><A HREF="./org/apache/mina/util/CharsetUtil.html#CharsetUtil()"><B>CharsetUtil()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/CharsetUtil.html" title="class in org.apache.mina.util">CharsetUtil</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#clear()"><B>clear()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Removes all filters added to this chain.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>Clears this stack.
<DT><A HREF="./org/apache/mina/util/IdentityHashSet.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/IdentityHashSet.html" title="class in org.apache.mina.util">IdentityHashSet</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Clears this queue.
<DT><A HREF="./org/apache/mina/util/Stack.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util">Stack</A>
<DD>Clears this stack.
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#clone()"><B>clone()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoServiceConfig.html#clone()"><B>clone()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common">IoServiceConfig</A>
<DD>Returns a deep clone of this configuration.
<DT><A HREF="./org/apache/mina/common/IoSessionConfig.html#clone()"><B>clone()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSessionConfig.html" title="interface in org.apache.mina.common">IoSessionConfig</A>
<DD>Returns a deep clone of this configuration.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html#clone()"><B>clone()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramAcceptorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html#clone()"><B>clone()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramConnectorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFutureListener.html#CLOSE"><B>CLOSE</B></A> - 
Static variable in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFutureListener.html" title="interface in org.apache.mina.common">IoFutureListener</A>
<DD>An <A HREF="./org/apache/mina/common/IoFutureListener.html" title="interface in org.apache.mina.common"><CODE>IoFutureListener</CODE></A> that closes the <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> which is
 associated with the specified <A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common"><CODE>IoFuture</CODE></A>.
<DT><A HREF="./org/apache/mina/common/IoSession.html#close()"><B>close()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Closes this session immediately.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#close()"><B>close()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#close()"><B>close()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#close()"><B>close()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>close the session
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#closeAllSessions()"><B>closeAllSessions()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#closeAllSessions()"><B>closeAllSessions()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>close all the managed sessions
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html#CLOSED"><B>CLOSED</B></A> - 
Static variable in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/CloseFuture.html" title="interface in org.apache.mina.common"><B>CloseFuture</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>An <A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common"><CODE>IoFuture</CODE></A> for asynchronous close requests.<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#compact()"><B>compact()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#compact()"><B>compact()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#compareTo(java.lang.Object)"><B>compareTo(Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#compareTo(java.lang.Object)"><B>compareTo(Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html#compareTo(java.lang.Object)"><B>compareTo(Object)</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/AnonymousSocketAddress.html#compareTo(java.lang.Object)"><B>compareTo(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AnonymousSocketAddress.html" title="class in org.apache.mina.util">AnonymousSocketAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#COMPRESSION_DEFAULT"><B>COMPRESSION_DEFAULT</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>The default compression level used.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#COMPRESSION_MAX"><B>COMPRESSION_MAX</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>Max compression level.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#COMPRESSION_MIN"><B>COMPRESSION_MIN</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>Provides the best speed at the price of a low compression ratio.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#COMPRESSION_NONE"><B>COMPRESSION_NONE</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>No compression done on the data.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter"><B>CompressionFilter</B></A> - Class in <A HREF="./org/apache/mina/filter/package-summary.html">org.apache.mina.filter</A><DD>An <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A> which compresses all data using
 <a href="http://www.jcraft.com/jzlib/">JZlib</a>.<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#CompressionFilter()"><B>CompressionFilter()</B></A> - 
Constructor for class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>Creates a new instance which compresses outboud data and decompresses
 inbound data with default compression level.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#CompressionFilter(int)"><B>CompressionFilter(int)</B></A> - 
Constructor for class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>Creates a new instance which compresses outboud data and decompresses
 inbound data with the specified <tt>compressionLevel</tt>.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#CompressionFilter(boolean, boolean, int)"><B>CompressionFilter(boolean, boolean, int)</B></A> - 
Constructor for class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/common/IoConnector.html#connect(java.net.SocketAddress, org.apache.mina.common.IoHandler)"><B>connect(SocketAddress, IoHandler)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoConnector.html" title="interface in org.apache.mina.common">IoConnector</A>
<DD>Connects to the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/common/IoConnector.html#connect(java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>connect(SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoConnector.html" title="interface in org.apache.mina.common">IoConnector</A>
<DD>Connects to the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/common/IoConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.common.IoHandler)"><B>connect(SocketAddress, SocketAddress, IoHandler)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoConnector.html" title="interface in org.apache.mina.common">IoConnector</A>
<DD>Connects to the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/common/IoConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>connect(SocketAddress, SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoConnector.html" title="interface in org.apache.mina.common">IoConnector</A>
<DD>Connects to the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html#connect(java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>connect(SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio">SocketConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>connect(SocketAddress, SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio">SocketConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeConnector.html#connect(java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>connect(SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.transport.vmpipe">VmPipeConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>connect(SocketAddress, SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.transport.vmpipe">VmPipeConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ConnectFuture.html" title="interface in org.apache.mina.common"><B>ConnectFuture</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>An <A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common"><CODE>IoFuture</CODE></A> for asynchronous connect requests.<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#contains(java.lang.String)"><B>contains(String)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#contains(org.apache.mina.common.IoFilter)"><B>contains(IoFilter)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#contains(java.lang.Class)"><B>contains(Class)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#contains(java.lang.String)"><B>contains(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Returns <tt>true</tt> if this chain contains an <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A> with the
 specified <tt>name</tt>.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#contains(org.apache.mina.common.IoFilter)"><B>contains(IoFilter)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Returns <tt>true</tt> if this chain contains the specified <tt>filter</tt>.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#contains(java.lang.Class)"><B>contains(Class)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Returns <tt>true</tt> if this chain contains an <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A> of the
 specified <tt>filterType</tt>.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#contains(java.lang.String)"><B>contains(String)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#contains(org.apache.mina.handler.chain.IoHandlerCommand)"><B>contains(IoHandlerCommand)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#contains(java.lang.Class)"><B>contains(Class)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#contains(java.lang.Object)"><B>contains(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/IdentityHashSet.html#contains(java.lang.Object)"><B>contains(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/IdentityHashSet.html" title="class in org.apache.mina.util">IdentityHashSet</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#containsAll(java.util.Collection)"><B>containsAll(Collection)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#containsAttribute(java.lang.String)"><B>containsAttribute(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns <tt>true</tt> if this session contains the attribute with
 the specified <tt>key</tt>.
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#containsKey(java.lang.Object)"><B>containsKey(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#containsValue(java.lang.Object)"><B>containsValue(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html#COUNTER"><B>COUNTER</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html" title="class in org.apache.mina.filter">ReadThrottleFilterBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html#createInstance()"><B>createInstance()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html" title="class in org.apache.mina.integration.spring">DefaultIoFilterChainBuilderFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html#createInstance()"><B>createInstance()</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">KeyStoreFactoryBean</A>
<DD>Creates a new <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/security/KeyStore.html" title="class or interface in java.security"><CODE>KeyStore</CODE></A>.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#createInstance()"><B>createInstance()</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#createInstance()"><B>createInstance()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html" title="class in org.apache.mina.filter.codec"><B>CumulativeProtocolDecoder</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>A <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> that cumulates the content of received
 buffers to a <em>cumulative buffer</em> to help users implement decoders.<DT><A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html#CumulativeProtocolDecoder()"><B>CumulativeProtocolDecoder()</B></A> - 
Constructor for class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html" title="class in org.apache.mina.filter.codec">CumulativeProtocolDecoder</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html#CURRENT_STREAM"><B>CURRENT_STREAM</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter">StreamWriteFilter</A>
<DD>The attribute name used when binding the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/InputStream.html" title="class or interface in java.io"><CODE>InputStream</CODE></A> to the session.
</DL>
<HR>
<A NAME="_D_"><!-- --></A><H2>
<B>D</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/TransportType.html#DATAGRAM"><B>DATAGRAM</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>Transport type: UDP/IP (Registry name: <tt>"DATAGRAM"</tt> or <tt>"UDP"</tt>)
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptor.html" title="class in org.apache.mina.transport.socket.nio"><B>DatagramAcceptor</B></A> - Class in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD><A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common"><CODE>IoAcceptor</CODE></A> for datagram transport (UDP/IP).<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptor.html#DatagramAcceptor()"><B>DatagramAcceptor()</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptor.html" title="class in org.apache.mina.transport.socket.nio">DatagramAcceptor</A>
<DD>Creates a new instance using a NewThreadExecutor
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptor.html#DatagramAcceptor(Executor)"><B>DatagramAcceptor(Executor)</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptor.html" title="class in org.apache.mina.transport.socket.nio">DatagramAcceptor</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio"><B>DatagramAcceptorConfig</B></A> - Class in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD>An <A HREF="./org/apache/mina/common/IoAcceptorConfig.html" title="interface in org.apache.mina.common"><CODE>IoAcceptorConfig</CODE></A> for <A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptor.html" title="class in org.apache.mina.transport.socket.nio"><CODE>DatagramAcceptor</CODE></A>.<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html#DatagramAcceptorConfig()"><B>DatagramAcceptorConfig()</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramAcceptorConfig</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnector.html" title="class in org.apache.mina.transport.socket.nio"><B>DatagramConnector</B></A> - Class in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD><A HREF="./org/apache/mina/common/IoConnector.html" title="interface in org.apache.mina.common"><CODE>IoConnector</CODE></A> for datagram transport (UDP/IP).<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnector.html#DatagramConnector()"><B>DatagramConnector()</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramConnector.html" title="class in org.apache.mina.transport.socket.nio">DatagramConnector</A>
<DD>Creates a new instance using a NewThreadExecutor
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnector.html#DatagramConnector(Executor)"><B>DatagramConnector(Executor)</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramConnector.html" title="class in org.apache.mina.transport.socket.nio">DatagramConnector</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html" title="class in org.apache.mina.transport.socket.nio"><B>DatagramConnectorConfig</B></A> - Class in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD>An <A HREF="./org/apache/mina/common/IoConnectorConfig.html" title="interface in org.apache.mina.common"><CODE>IoConnectorConfig</CODE></A> for <A HREF="./org/apache/mina/transport/socket/nio/DatagramConnector.html" title="class in org.apache.mina.transport.socket.nio"><CODE>DatagramConnector</CODE></A>.<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html#DatagramConnectorConfig()"><B>DatagramConnectorConfig()</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramConnectorConfig</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramServiceConfig.html" title="interface in org.apache.mina.transport.socket.nio"><B>DatagramServiceConfig</B></A> - Interface in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD>An <A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common"><CODE>IoServiceConfig</CODE></A> for <A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptor.html" title="class in org.apache.mina.transport.socket.nio"><CODE>DatagramAcceptor</CODE></A> and <A HREF="./org/apache/mina/transport/socket/nio/DatagramConnector.html" title="class in org.apache.mina.transport.socket.nio"><CODE>DatagramConnector</CODE></A>.<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio"><B>DatagramSessionConfig</B></A> - Interface in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD>An <A HREF="./org/apache/mina/common/IoSessionConfig.html" title="interface in org.apache.mina.common"><CODE>IoSessionConfig</CODE></A> for datagram transport type.<DT><A HREF="./org/apache/mina/util/SessionLog.html#debug(org.apache.mina.common.IoSession, java.lang.String)"><B>debug(IoSession, String)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/SessionLog.html#debug(org.apache.mina.common.IoSession, java.lang.String, java.lang.Throwable)"><B>debug(IoSession, String, Throwable)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decodable(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer)"><B>decodable(IoSession, ByteBuffer)</B></A> - 
Method in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux">MessageDecoder</A>
<DD>Checks the specified buffer is decodable by this decoder.
<DT><A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html" title="class in org.apache.mina.filter.codec">CumulativeProtocolDecoder</A>
<DD>Cumulates content of <tt>in</tt> into internal buffer and forwards
 decoding request to <A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html#doDecode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><CODE>CumulativeProtocolDecoder.doDecode(IoSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux">MessageDecoder</A>
<DD>Decodes binary or protocol-specific content into higher-level message objects.
<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.netty.<A HREF="./org/apache/mina/filter/codec/netty/NettyDecoder.html" title="class in org.apache.mina.filter.codec.netty">NettyDecoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec">ProtocolDecoder</A>
<DD>Decodes binary or protocol-specific content into higher-level message objects.
<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html" title="class in org.apache.mina.filter.codec">SynchronizedProtocolDecoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineDecoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#DECODER"><B>DECODER</B></A> - 
Static variable in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#DEFAULT"><B>DEFAULT</B></A> - 
Static variable in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>the line delimiter constant of the current O/S.
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#DEFAULT_EXPIRATION_INTERVAL"><B>DEFAULT_EXPIRATION_INTERVAL</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html#DEFAULT_STREAM_BUFFER_SIZE"><B>DEFAULT_STREAM_BUFFER_SIZE</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter">StreamWriteFilter</A>
<DD>The default buffer size this filter uses for writing.
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#DEFAULT_TIME_TO_LIVE"><B>DEFAULT_TIME_TO_LIVE</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common"><B>DefaultIoFilterChainBuilder</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>The default implementation of <A HREF="./org/apache/mina/common/IoFilterChainBuilder.html" title="interface in org.apache.mina.common"><CODE>IoFilterChainBuilder</CODE></A> which is useful
 in most cases.<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#DefaultIoFilterChainBuilder()"><B>DefaultIoFilterChainBuilder()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>Creates a new instance with an empty filter list.
<DT><A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html" title="class in org.apache.mina.integration.spring"><B>DefaultIoFilterChainBuilderFactoryBean</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/package-summary.html">org.apache.mina.integration.spring</A><DD>Spring <A HREF="http://static.springframework.org/spring/docs/1.2.x/api/org/springframework/beans/factory/FactoryBean.html" title="class or interface in org.springframework.beans.factory"><CODE>FactoryBean</CODE></A>
 which creates <A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common"><CODE>DefaultIoFilterChainBuilder</CODE></A> instances.<DT><A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html#DefaultIoFilterChainBuilderFactoryBean()"><B>DefaultIoFilterChainBuilderFactoryBean()</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html" title="class in org.apache.mina.integration.spring">DefaultIoFilterChainBuilderFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html" title="class in org.apache.mina.handler.demux"><B>DemuxingIoHandler</B></A> - Class in <A HREF="./org/apache/mina/handler/demux/package-summary.html">org.apache.mina.handler.demux</A><DD>A <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> that demuxes <code>messageReceived</code> events
 to the appropriate <A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><CODE>MessageHandler</CODE></A>.<DT><A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html#DemuxingIoHandler()"><B>DemuxingIoHandler()</B></A> - 
Constructor for class org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html" title="class in org.apache.mina.handler.demux">DemuxingIoHandler</A>
<DD>Creates a new instance with no registered <A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><CODE>MessageHandler</CODE></A>s.
<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux"><B>DemuxingProtocolCodecFactory</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/demux/package-summary.html">org.apache.mina.filter.codec.demux</A><DD>A composite <A HREF="./org/apache/mina/filter/codec/ProtocolCodecFactory.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolCodecFactory</CODE></A> that consists of multiple
 <A HREF="./org/apache/mina/filter/codec/demux/MessageEncoder.html" title="interface in org.apache.mina.filter.codec.demux"><CODE>MessageEncoder</CODE></A>s and <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux"><CODE>MessageDecoder</CODE></A>s.<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html#DemuxingProtocolCodecFactory()"><B>DemuxingProtocolCodecFactory()</B></A> - 
Constructor for class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.html#destroy()"><B>destroy()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Invoked by <A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter"><CODE>ReferenceCountingIoFilter</CODE></A> when this filter
 is not used by any <A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain</CODE></A> anymore, so you can destroy
 shared resources.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#destroy()"><B>destroy()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#destroy()"><B>destroy()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html#destroy()"><B>destroy()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html" title="class in org.apache.mina.integration.spring">IoAcceptorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#destroyInstance(java.lang.Object)"><B>destroyInstance(Object)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#DISABLE_COMPRESSION_ONCE"><B>DISABLE_COMPRESSION_ONCE</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>A flag that allows you to disable compression once.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#DISABLE_ENCRYPTION_ONCE"><B>DISABLE_ENCRYPTION_ONCE</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>A session attribute key that makes next one write request bypass
 this filter (not encrypting the data).
<DT><A HREF="./org/apache/mina/common/ByteBufferAllocator.html#dispose()"><B>dispose()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferAllocator.html" title="interface in org.apache.mina.common">ByteBufferAllocator</A>
<DD>Dispose of this allocator.
<DT><A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html#dispose()"><B>dispose()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html" title="class in org.apache.mina.common">PooledByteBufferAllocator</A>
<DD>Stops the thread which releases unused buffers and make this allocator unusable from now on.
<DT><A HREF="./org/apache/mina/common/SimpleByteBufferAllocator.html#dispose()"><B>dispose()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/SimpleByteBufferAllocator.html" title="class in org.apache.mina.common">SimpleByteBufferAllocator</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html#dispose(org.apache.mina.common.IoSession)"><B>dispose(IoSession)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html" title="class in org.apache.mina.filter.codec">CumulativeProtocolDecoder</A>
<DD>Releases the cumulative buffer used by the specified <tt>session</tt>.
<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyEncoder.html#dispose(org.apache.mina.common.IoSession)"><B>dispose(IoSession)</B></A> - 
Method in class org.apache.mina.filter.codec.netty.<A HREF="./org/apache/mina/filter/codec/netty/NettyEncoder.html" title="class in org.apache.mina.filter.codec.netty">NettyEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html#dispose(org.apache.mina.common.IoSession)"><B>dispose(IoSession)</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec">ProtocolDecoder</A>
<DD>Releases all resources related with this decoder.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderAdapter.html#dispose(org.apache.mina.common.IoSession)"><B>dispose(IoSession)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderAdapter.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderAdapter</A>
<DD>Override this method to dispose all resources related with this decoder.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html#dispose(org.apache.mina.common.IoSession)"><B>dispose(IoSession)</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec">ProtocolEncoder</A>
<DD>Releases all resources related with this encoder.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderAdapter.html#dispose(org.apache.mina.common.IoSession)"><B>dispose(IoSession)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoderAdapter.html" title="class in org.apache.mina.filter.codec">ProtocolEncoderAdapter</A>
<DD>Override this method dispose all resources related with this encoder.
<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html#dispose(org.apache.mina.common.IoSession)"><B>dispose(IoSession)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html" title="class in org.apache.mina.filter.codec">SynchronizedProtocolDecoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolEncoder.html#dispose(org.apache.mina.common.IoSession)"><B>dispose(IoSession)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolEncoder.html" title="class in org.apache.mina.filter.codec">SynchronizedProtocolEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html#dispose(org.apache.mina.common.IoSession)"><B>dispose(IoSession)</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineDecoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html#dispose()"><B>dispose()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html#disposeCodecResources(org.apache.mina.common.IoSession)"><B>disposeCodecResources(IoSession)</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux">DemuxingProtocolCodecFactory</A>
<DD>Implement this method to release all resources acquired to perform
 encoding and decoding messages for the specified <tt>session</tt>.
<DT><A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html#doDecode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>doDecode(IoSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/CumulativeProtocolDecoder.html" title="class in org.apache.mina.filter.codec">CumulativeProtocolDecoder</A>
<DD>Implement this method to consume the specified cumulative buffer and
 decode its content into message(s).
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html#doDecode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>doDecode(IoSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationDecoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#duplicate()"><B>duplicate()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#duplicate()"><B>duplicate()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_E_"><!-- --></A><H2>
<B>E</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#element()"><B>element()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#element()"><B>element()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageEncoder.html#encode(org.apache.mina.common.IoSession, java.lang.Object, org.apache.mina.filter.codec.ProtocolEncoderOutput)"><B>encode(IoSession, Object, ProtocolEncoderOutput)</B></A> - 
Method in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageEncoder.html" title="interface in org.apache.mina.filter.codec.demux">MessageEncoder</A>
<DD>Encodes higher-level message objects into binary or protocol-specific data.
<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyEncoder.html#encode(org.apache.mina.common.IoSession, java.lang.Object, org.apache.mina.filter.codec.ProtocolEncoderOutput)"><B>encode(IoSession, Object, ProtocolEncoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.netty.<A HREF="./org/apache/mina/filter/codec/netty/NettyEncoder.html" title="class in org.apache.mina.filter.codec.netty">NettyEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html#encode(org.apache.mina.common.IoSession, java.lang.Object, org.apache.mina.filter.codec.ProtocolEncoderOutput)"><B>encode(IoSession, Object, ProtocolEncoderOutput)</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec">ProtocolEncoder</A>
<DD>Encodes higher-level message objects into binary or protocol-specific data.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html#encode(org.apache.mina.common.IoSession, java.lang.Object, org.apache.mina.filter.codec.ProtocolEncoderOutput)"><B>encode(IoSession, Object, ProtocolEncoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolEncoder.html#encode(org.apache.mina.common.IoSession, java.lang.Object, org.apache.mina.filter.codec.ProtocolEncoderOutput)"><B>encode(IoSession, Object, ProtocolEncoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolEncoder.html" title="class in org.apache.mina.filter.codec">SynchronizedProtocolEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html#encode(org.apache.mina.common.IoSession, java.lang.Object, org.apache.mina.filter.codec.ProtocolEncoderOutput)"><B>encode(IoSession, Object, ProtocolEncoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#ENCODER"><B>ENCODER</B></A> - 
Static variable in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#entrySet()"><B>entrySet()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/AnonymousSocketAddress.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AnonymousSocketAddress.html" title="class in org.apache.mina.util">AnonymousSocketAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/SessionLog.html#error(org.apache.mina.common.IoSession, java.lang.String)"><B>error(IoSession, String)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/SessionLog.html#error(org.apache.mina.common.IoSession, java.lang.String, java.lang.Throwable)"><B>error(IoSession, String, Throwable)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html#EXCEPTION"><B>EXCEPTION</B></A> - 
Static variable in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExceptionMonitor.html#exceptionCaught(java.lang.Throwable)"><B>exceptionCaught(Throwable)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExceptionMonitor.html" title="class in org.apache.mina.common">ExceptionMonitor</A>
<DD>Invoked when there are any uncaught exceptions.
<DT><A HREF="./org/apache/mina/common/IoFilter.html#exceptionCaught(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/common/IoHandler.html#exceptionCaught(org.apache.mina.common.IoSession, java.lang.Throwable)"><CODE>IoHandler.exceptionCaught(IoSession,Throwable)</CODE></A>
 event.
<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html#exceptionCaught(org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common">IoFilter.NextFilter</A>
<DD>Forwards <tt>exceptionCaught</tt> event to next filter.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#exceptionCaught(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoHandler.html#exceptionCaught(org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common">IoHandler</A>
<DD>Invoked when any exception is thrown by user <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A>
 implementation or by MINA.
<DT><A HREF="./org/apache/mina/common/IoHandlerAdapter.html#exceptionCaught(org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandlerAdapter.html" title="class in org.apache.mina.common">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#exceptionCaught(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#exceptionCaught(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#exceptionCaught(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#exceptionCaught(java.lang.Throwable)"><B>exceptionCaught(Throwable)</B></A> - 
Method in interface org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton">SingleSessionIoHandler</A>
<DD>Invoked when any exception is thrown by user <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A>
 implementation or by MINA.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html#exceptionCaught(java.lang.Throwable)"><B>exceptionCaught(Throwable)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html#exceptionCaught(org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerDelegate</A>
<DD>Delegates the method call to the
 <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#exceptionCaught(java.lang.Throwable)"><CODE>SingleSessionIoHandler.exceptionCaught(Throwable)</CODE></A> method of the
 handler assigned to this session.
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#exceptionCaught(org.apache.mina.common.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>Forwards caught exceptions to input stream.
<DT><A HREF="./org/apache/mina/common/ExceptionMonitor.html" title="class in org.apache.mina.common"><B>ExceptionMonitor</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Monitors uncaught exceptions.<DT><A HREF="./org/apache/mina/common/ExceptionMonitor.html#ExceptionMonitor()"><B>ExceptionMonitor()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExceptionMonitor.html" title="class in org.apache.mina.common">ExceptionMonitor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorExecutor.html#execute(java.lang.Runnable)"><B>execute(Runnable)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorExecutor.html" title="class in org.apache.mina.filter.executor">ExecutorExecutor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#execute(org.apache.mina.handler.chain.IoHandlerCommand.NextCommand, org.apache.mina.common.IoSession, java.lang.Object)"><B>execute(IoHandlerCommand.NextCommand, IoSession, Object)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html#execute(org.apache.mina.handler.chain.IoHandlerCommand.NextCommand, org.apache.mina.common.IoSession, java.lang.Object)"><B>execute(IoHandlerCommand.NextCommand, IoSession, Object)</B></A> - 
Method in interface org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html" title="interface in org.apache.mina.handler.chain">IoHandlerCommand</A>
<DD>Execute a unit of processing work to be performed.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.NextCommand.html#execute(org.apache.mina.common.IoSession, java.lang.Object)"><B>execute(IoSession, Object)</B></A> - 
Method in interface org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.NextCommand.html" title="interface in org.apache.mina.handler.chain">IoHandlerCommand.NextCommand</A>
<DD>Forwards the request to the next <A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html" title="interface in org.apache.mina.handler.chain"><CODE>IoHandlerCommand</CODE></A> in the
 <A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain"><CODE>IoHandlerChain</CODE></A>.
<DT><A HREF="./org/apache/mina/util/NewThreadExecutor.html#execute(java.lang.Runnable)"><B>execute(Runnable)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/NewThreadExecutor.html" title="class in org.apache.mina.util">NewThreadExecutor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorExecutor.html" title="class in org.apache.mina.filter.executor"><B>ExecutorExecutor</B></A> - Class in <A HREF="./org/apache/mina/filter/executor/package-summary.html">org.apache.mina.filter.executor</A><DD>A <a href="http://dcl.mathcs.emory.edu/util/backport-util-concurrent/">backport-util-concurrent</a>
 <CODE>Executor</CODE> which adapts Java 5 <tt>java.util.concurrent.</tt><A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/Executor.html" title="class or interface in java.util.concurrent"><CODE>Executor</CODE></A>.<DT><A HREF="./org/apache/mina/filter/executor/ExecutorExecutor.html#ExecutorExecutor(java.util.concurrent.Executor)"><B>ExecutorExecutor(Executor)</B></A> - 
Constructor for class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorExecutor.html" title="class in org.apache.mina.filter.executor">ExecutorExecutor</A>
<DD>Creates a new instance with the specified <tt>executor</tt>.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor"><B>ExecutorFilter</B></A> - Class in <A HREF="./org/apache/mina/filter/executor/package-summary.html">org.apache.mina.filter.executor</A><DD>A filter that forward events to <CODE>Executor</CODE> in
 <a href="http://dcl.mathcs.emory.edu/util/backport-util-concurrent/">backport-util-concurrent</a>.<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#ExecutorFilter()"><B>ExecutorFilter()</B></A> - 
Constructor for class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>Creates a new instace with the default thread pool implementation
 (<tt>new ThreadPoolExecutor(16, 16, 60, TimeUnit.SECONDS, new LinkedBlockingQueue() )</tt>).
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#ExecutorFilter(Executor)"><B>ExecutorFilter(Executor)</B></A> - 
Constructor for class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>Creates a new instance with the specified <tt>executor</tt>.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.Event.html" title="class in org.apache.mina.filter.executor"><B>ExecutorFilter.Event</B></A> - Class in <A HREF="./org/apache/mina/filter/executor/package-summary.html">org.apache.mina.filter.executor</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor"><B>ExecutorFilter.EventType</B></A> - Class in <A HREF="./org/apache/mina/filter/executor/package-summary.html">org.apache.mina.filter.executor</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html" title="interface in org.apache.mina.filter.executor"><B>ExecutorFilterMBean</B></A> - Interface in <A HREF="./org/apache/mina/filter/executor/package-summary.html">org.apache.mina.filter.executor</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/common/ExecutorThreadModel.html" title="class in org.apache.mina.common"><B>ExecutorThreadModel</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A <A HREF="./org/apache/mina/common/ThreadModel.html" title="interface in org.apache.mina.common"><CODE>ThreadModel</CODE></A> which represents a thread model with an <CODE>Executor</CODE>
 (from <a href="http://dcl.mathcs.emory.edu/util/backport-util-concurrent/">backport-util-concurrent</a>)
 per service.<DT><A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html" title="class in org.apache.mina.integration.spring"><B>ExecutorThreadModelFactoryBean</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/package-summary.html">org.apache.mina.integration.spring</A><DD>Spring <CODE>FactoryBean</CODE> which makes it possible to set up a MINA
 <A HREF="./org/apache/mina/common/ExecutorThreadModel.html" title="class in org.apache.mina.common"><CODE>ExecutorThreadModel</CODE></A> using Spring.<DT><A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html#ExecutorThreadModelFactoryBean()"><B>ExecutorThreadModelFactoryBean()</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html" title="class in org.apache.mina.integration.spring">ExecutorThreadModelFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#expand(int)"><B>expand(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Changes the capacity and limit of this buffer so this buffer get
 the specified <tt>expectedRemaining</tt> room from the current position.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#expand(int, int)"><B>expand(int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Changes the capacity and limit of this buffer so this buffer get
 the specified <tt>expectedRemaining</tt> room from the specified
 <tt>pos</tt>.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#expand(int, int)"><B>expand(int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#expand(int)"><B>expand(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpirationListener.html" title="interface in org.apache.mina.util"><B>ExpirationListener</B></A> - Interface in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A listener for expired object events.<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#expireBefore(long)"><B>expireBefore(long)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpirationListener.html#expired(java.lang.Object)"><B>expired(Object)</B></A> - 
Method in interface org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpirationListener.html" title="interface in org.apache.mina.util">ExpirationListener</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util"><B>ExpiringMap</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A map with expiration.<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#ExpiringMap()"><B>ExpiringMap()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#ExpiringMap(int)"><B>ExpiringMap(int)</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#ExpiringMap(int, int)"><B>ExpiringMap(int, int)</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util"><B>ExpiringMap.Expirer</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#ExpiringMap.Expirer()"><B>ExpiringMap.Expirer()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common"><B>ExpiringSessionRecycler</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>An <A HREF="./org/apache/mina/common/IoSessionRecycler.html" title="interface in org.apache.mina.common"><CODE>IoSessionRecycler</CODE></A> with sessions that time out on inactivity.<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#ExpiringSessionRecycler()"><B>ExpiringSessionRecycler()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#ExpiringSessionRecycler(int)"><B>ExpiringSessionRecycler(int)</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#ExpiringSessionRecycler(int, int)"><B>ExpiringSessionRecycler(int, int)</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util"><B>ExpiringStack</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A unbounded stack with expiration.<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#ExpiringStack()"><B>ExpiringStack()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>Construct a new, empty stack.
</DL>
<HR>
<A NAME="_F_"><!-- --></A><H2>
<B>F</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#fill(byte, int)"><B>fill(byte, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Fills this buffer with the specified value.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#fill(int)"><B>fill(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Fills this buffer with <code>NUL (0x00)</code>.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#fill(byte, int)"><B>fill(byte, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#fill(int)"><B>fill(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#fillAndReset(byte, int)"><B>fillAndReset(byte, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Fills this buffer with the specified value.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#fillAndReset(int)"><B>fillAndReset(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Fills this buffer with <code>NUL (0x00)</code>.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#fillAndReset(byte, int)"><B>fillAndReset(byte, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#fillAndReset(int)"><B>fillAndReset(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.html#filterClose(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>filterClose(IoFilter.NextFilter, IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/common/IoSession.html#close()"><CODE>IoSession.close()</CODE></A> method invocation.
<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html#filterClose(org.apache.mina.common.IoSession)"><B>filterClose(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common">IoFilter.NextFilter</A>
<DD>Forwards <tt>filterClose</tt> event to next filter.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#filterClose(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>filterClose(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#filterClose(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>filterClose(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#filterClose(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>filterClose(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#filterClose(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>filterClose(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#filterClose(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>filterClose(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.html#filterWrite(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoFilter.NextFilter, IoSession, IoFilter.WriteRequest)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/common/IoSession.html#write(java.lang.Object)"><CODE>IoSession.write(Object)</CODE></A> method invocation.
<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html#filterWrite(org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoSession, IoFilter.WriteRequest)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common">IoFilter.NextFilter</A>
<DD>Forwards <tt>filterWrite</tt> event to next filter.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#filterWrite(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoFilter.NextFilter, IoSession, IoFilter.WriteRequest)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#filterWrite(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoFilter.NextFilter, IoSession, IoFilter.WriteRequest)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#filterWrite(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoFilter.NextFilter, IoSession, IoFilter.WriteRequest)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#filterWrite(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoFilter.NextFilter, IoSession, IoFilter.WriteRequest)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#filterWrite(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoFilter.NextFilter, IoSession, IoFilter.WriteRequest)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#filterWrite(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoFilter.NextFilter, IoSession, IoFilter.WriteRequest)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#filterWrite(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoFilter.NextFilter, IoSession, IoFilter.WriteRequest)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html#filterWrite(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>filterWrite(IoFilter.NextFilter, IoSession, IoFilter.WriteRequest)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter">StreamWriteFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#finishDecode(org.apache.mina.common.IoSession, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>finishDecode(IoSession, ProtocolDecoderOutput)</B></A> - 
Method in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux">MessageDecoder</A>
<DD>Invoked when the specified <tt>session</tt> is closed while this decoder was
 parsing the data.
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderAdapter.html#finishDecode(org.apache.mina.common.IoSession, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>finishDecode(IoSession, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderAdapter.html" title="class in org.apache.mina.filter.codec.demux">MessageDecoderAdapter</A>
<DD>Override this method to deal with the closed connection.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html#finishDecode(org.apache.mina.common.IoSession, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>finishDecode(IoSession, ProtocolDecoderOutput)</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec">ProtocolDecoder</A>
<DD>Invoked when the specified <tt>session</tt> is closed.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderAdapter.html#finishDecode(org.apache.mina.common.IoSession, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>finishDecode(IoSession, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderAdapter.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderAdapter</A>
<DD>Override this method to deal with the closed connection.
<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html#finishDecode(org.apache.mina.common.IoSession, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>finishDecode(IoSession, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html" title="class in org.apache.mina.filter.codec">SynchronizedProtocolDecoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html#finishDecode(org.apache.mina.common.IoSession, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><B>finishDecode(IoSession, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineDecoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#fireExceptionCaught(org.apache.mina.common.IoSession, java.lang.Throwable)"><B>fireExceptionCaught(IoSession, Throwable)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Fires a <A HREF="./org/apache/mina/common/IoHandler.html#exceptionCaught(org.apache.mina.common.IoSession, java.lang.Throwable)"><CODE>IoHandler.exceptionCaught(IoSession, Throwable)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#fireFilterClose(org.apache.mina.common.IoSession)"><B>fireFilterClose(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Fires a <A HREF="./org/apache/mina/common/IoSession.html#close()"><CODE>IoSession.close()</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#fireFilterWrite(org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>fireFilterWrite(IoSession, IoFilter.WriteRequest)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Fires a <A HREF="./org/apache/mina/common/IoSession.html#write(java.lang.Object)"><CODE>IoSession.write(Object)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#fireMessageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><B>fireMessageReceived(IoSession, Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Fires a <A HREF="./org/apache/mina/common/IoFilterChain.html#fireMessageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><CODE>IoFilterChain.fireMessageReceived(IoSession, Object)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#fireMessageSent(org.apache.mina.common.IoSession, org.apache.mina.common.IoFilter.WriteRequest)"><B>fireMessageSent(IoSession, IoFilter.WriteRequest)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Fires a <A HREF="./org/apache/mina/common/IoHandler.html#sessionOpened(org.apache.mina.common.IoSession)"><CODE>IoHandler.sessionOpened(IoSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#fireSessionClosed(org.apache.mina.common.IoSession)"><B>fireSessionClosed(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Fires a <A HREF="./org/apache/mina/common/IoHandler.html#sessionClosed(org.apache.mina.common.IoSession)"><CODE>IoHandler.sessionClosed(IoSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#fireSessionCreated(org.apache.mina.common.IoSession)"><B>fireSessionCreated(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Fires a <A HREF="./org/apache/mina/common/IoHandler.html#sessionCreated(org.apache.mina.common.IoSession)"><CODE>IoHandler.sessionCreated(IoSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#fireSessionIdle(org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>fireSessionIdle(IoSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Fires a <A HREF="./org/apache/mina/common/IoHandler.html#sessionIdle(org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><CODE>IoHandler.sessionIdle(IoSession, IdleStatus)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#fireSessionOpened(org.apache.mina.common.IoSession)"><B>fireSessionOpened(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Fires a <A HREF="./org/apache/mina/common/IoHandler.html#sessionOpened(org.apache.mina.common.IoSession)"><CODE>IoHandler.sessionOpened(IoSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#first()"><B>first()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#first()"><B>first()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>Returns the first element of the stack.
<DT><A HREF="./org/apache/mina/util/Queue.html#first()"><B>first()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Returns the first element of the queue.
<DT><A HREF="./org/apache/mina/util/Stack.html#first()"><B>first()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util">Stack</A>
<DD>Returns the first element of the stack.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#flip()"><B>flip()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#flip()"><B>flip()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderOutput.html#flush()"><B>flush()</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderOutput.html" title="interface in org.apache.mina.filter.codec">ProtocolDecoderOutput</A>
<DD>Flushes all messages you wrote via <A HREF="./org/apache/mina/filter/codec/ProtocolDecoderOutput.html#write(java.lang.Object)"><CODE>ProtocolDecoderOutput.write(Object)</CODE></A> to
 the next filter.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderOutput.html#flush()"><B>flush()</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoderOutput.html" title="interface in org.apache.mina.filter.codec">ProtocolEncoderOutput</A>
<DD>Flushes all buffers you wrote via <A HREF="./org/apache/mina/filter/codec/ProtocolEncoderOutput.html#write(org.apache.mina.common.ByteBuffer)"><CODE>ProtocolEncoderOutput.write(ByteBuffer)</CODE></A> to
 the session.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#flush()"><B>flush()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_G_"><!-- --></A><H2>
<B>G</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#get()"><B>get()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#get(int)"><B>get(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#get(byte[], int, int)"><B>get(byte[], int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#get(byte[])"><B>get(byte[])</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#get()"><B>get()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#get(int)"><B>get(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#get(byte[], int, int)"><B>get(byte[], int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#get(byte[])"><B>get(byte[])</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#get(java.lang.String)"><B>get(String)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#get(java.lang.String)"><B>get(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A> with the specified <tt>name</tt> in this chain.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#get(java.lang.String)"><B>get(String)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#get(int)"><B>get(int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#get(java.lang.Object)"><B>get(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#get(int)"><B>get(int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#getAddress()"><B>getAddress()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>Returns the address the handler of this object will be bound to.
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#getAll()"><B>getAll()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#getAll()"><B>getAll()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Returns the list of all <A HREF="./org/apache/mina/common/IoFilterChain.Entry.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain.Entry</CODE></A>s this chain contains.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#getAll()"><B>getAll()</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getAllocator()"><B>getAllocator()</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns the current allocator which manages the allocated buffers.
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#getAllReversed()"><B>getAllReversed()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#getAllReversed()"><B>getAllReversed()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Returns the reversed list of all <A HREF="./org/apache/mina/common/IoFilterChain.Entry.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain.Entry</CODE></A>s this chain contains.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#getAllReversed()"><B>getAllReversed()</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#getAttachment()"><B>getAttachment()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns an attachment of this session.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getAttribute(java.lang.String)"><B>getAttribute(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the value of user-defined attribute of this session.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getAttributeKeys()"><B>getAttributeKeys()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the set of keys of all user-defined attributes.
<DT><A HREF="./org/apache/mina/util/AvailablePortFinder.html#getAvailablePorts()"><B>getAvailablePorts()</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AvailablePortFinder.html" title="class in org.apache.mina.util">AvailablePortFinder</A>
<DD>Returns the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Set.html" title="class or interface in java.util"><CODE>Set</CODE></A> of currently available port numbers
 (<A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Integer.html" title="class or interface in java.lang"><CODE>Integer</CODE></A>).
<DT><A HREF="./org/apache/mina/util/AvailablePortFinder.html#getAvailablePorts(int, int)"><B>getAvailablePorts(int, int)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AvailablePortFinder.html" title="class in org.apache.mina.util">AvailablePortFinder</A>
<DD>Returns the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Set.html" title="class or interface in java.util"><CODE>Set</CODE></A> of currently avaliable port numbers (<A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Integer.html" title="class or interface in java.lang"><CODE>Integer</CODE></A>)
 between the specified port range.
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#getAverageByteReadThroughput()"><B>getAverageByteReadThroughput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#getAverageByteReadThroughput()"><B>getAverageByteReadThroughput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>average bytes read per seconds for all the managed sessions
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#getAverageByteWrittenThroughput()"><B>getAverageByteWrittenThroughput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#getAverageByteWrittenThroughput()"><B>getAverageByteWrittenThroughput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>average bytes written per seconds for all the managed sessions
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#getAverageMessageReadThroughput()"><B>getAverageMessageReadThroughput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#getAverageMessageReadThroughput()"><B>getAverageMessageReadThroughput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>average messages read per seconds for all the managed sessions
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#getAverageMessageWrittenThroughput()"><B>getAverageMessageWrittenThroughput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#getAverageMessageWrittenThroughput()"><B>getAverageMessageWrittenThroughput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>average messages written per seconds for all the managed sessions
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html#getBacklog()"><B>getBacklog()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getBothIdleTime()"><B>getBothIdleTime()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getBothIdleTime()"><B>getBothIdleTime()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>read and write IDLE time
<DT><A HREF="./org/apache/mina/management/IoSessionStat.html#getByteReadThroughput()"><B>getByteReadThroughput()</B></A> - 
Method in class org.apache.mina.management.<A HREF="./org/apache/mina/management/IoSessionStat.html" title="class in org.apache.mina.management">IoSessionStat</A>
<DD>Bytes read per second
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getByteReadThroughtput()"><B>getByteReadThroughtput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getByteReadThroughtput()"><B>getByteReadThroughtput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>get the read bytes per second throughput
 works only if a stat collector is inspecting this session,
<DT><A HREF="./org/apache/mina/management/IoSessionStat.html#getByteWrittenThroughput()"><B>getByteWrittenThroughput()</B></A> - 
Method in class org.apache.mina.management.<A HREF="./org/apache/mina/management/IoSessionStat.html" title="class in org.apache.mina.management">IoSessionStat</A>
<DD>Bytes written per second
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getByteWrittenThroughtput()"><B>getByteWrittenThroughtput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getByteWrittenThroughtput()"><B>getByteWrittenThroughtput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>get the written bytes per second throughput
 works only if a stat collector is inspecting this session,
<DT><A HREF="./org/apache/mina/handler/chain/ChainedIoHandler.html#getChain()"><B>getChain()</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/ChainedIoHandler.html" title="class in org.apache.mina.handler.chain">ChainedIoHandler</A>
<DD>Returns the <A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html" title="interface in org.apache.mina.handler.chain"><CODE>IoHandlerCommand</CODE></A> this handler will use to
 handle <tt>messageReceived</tt> events.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getChar()"><B>getChar()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getChar(int)"><B>getChar(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getChar()"><B>getChar()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getChar(int)"><B>getChar(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#getCloseFuture()"><B>getCloseFuture()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the <A HREF="./org/apache/mina/common/CloseFuture.html" title="interface in org.apache.mina.common"><CODE>CloseFuture</CODE></A> of this session.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.Entry.html#getCommand()"><B>getCommand()</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.Entry.html" title="class in org.apache.mina.handler.chain">IoHandlerChain.Entry</A>
<DD>Returns the command.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getConfig()"><B>getConfig()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the configuration of this session.
<DT><A HREF="./org/apache/mina/common/IoConnectorConfig.html#getConnectTimeout()"><B>getConnectTimeout()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoConnectorConfig.html" title="interface in org.apache.mina.common">IoConnectorConfig</A>
<DD>Returns the connect timeout in seconds.
<DT><A HREF="./org/apache/mina/common/IoConnectorConfig.html#getConnectTimeoutMillis()"><B>getConnectTimeoutMillis()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoConnectorConfig.html" title="interface in org.apache.mina.common">IoConnectorConfig</A>
<DD>Returns the connect timeout in milliseconds.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getCreationTime()"><B>getCreationTime()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the time in millis when this session is created.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getCreationTime()"><B>getCreationTime()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getCreationTime()"><B>getCreationTime()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>when the session was created
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.Event.html#getData()"><B>getData()</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.Event.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.Event</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html#getDecoder()"><B>getDecoder()</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderFactory.html#getDecoder()"><B>getDecoder()</B></A> - 
Method in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderFactory.html" title="interface in org.apache.mina.filter.codec.demux">MessageDecoderFactory</A>
<DD>Creates a new message decoder.
<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyCodecFactory.html#getDecoder()"><B>getDecoder()</B></A> - 
Method in class org.apache.mina.filter.codec.netty.<A HREF="./org/apache/mina/filter/codec/netty/NettyCodecFactory.html" title="class in org.apache.mina.filter.codec.netty">NettyCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFactory.html#getDecoder()"><B>getDecoder()</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFactory.html" title="interface in org.apache.mina.filter.codec">ProtocolCodecFactory</A>
<DD>Returns a new (or reusable) instance of <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> which
 decodes binary or protocol-specific data into message objects.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html#getDecoder()"><B>getDecoder()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html#getDecoder()"><B>getDecoder()</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html" title="class in org.apache.mina.filter.codec">SynchronizedProtocolDecoder</A>
<DD>Returns the decoder this decoder is decorating.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html#getDecoder()"><B>getDecoder()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html" title="class in org.apache.mina.filter.codec.textline">TextLineCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html#getDecoderMaxLineLength()"><B>getDecoderMaxLineLength()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html" title="class in org.apache.mina.filter.codec.textline">TextLineCodecFactory</A>
<DD>Returns the allowed maximum size of the line to be decoded.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html#getDecoderMaxObjectSize()"><B>getDecoderMaxObjectSize()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationCodecFactory</A>
<DD>Returns the allowed maximum size of the object to be decoded.
<DT><A HREF="./org/apache/mina/util/CharsetUtil.html#getDefaultCharset()"><B>getDefaultCharset()</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/CharsetUtil.html" title="class in org.apache.mina.util">CharsetUtil</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/CharsetUtil.html#getDefaultCharsetName()"><B>getDefaultCharsetName()</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/CharsetUtil.html" title="class in org.apache.mina.util">CharsetUtil</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoService.html#getDefaultConfig()"><B>getDefaultConfig()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common">IoService</A>
<DD>Returns the default configuration which is used when you didn't specify
 any configuration.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html#getDefaultConfig()"><B>getDefaultConfig()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html#getDefaultConfig()"><B>getDefaultConfig()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio">SocketConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html#getDefaultConfig()"><B>getDefaultConfig()</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeConnector.html#getDefaultConfig()"><B>getDefaultConfig()</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.transport.vmpipe">VmPipeConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html#getDestination()"><B>getDestination()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html" title="class in org.apache.mina.common">IoFilter.WriteRequest</A>
<DD>Returne the destination of this write request.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getDouble()"><B>getDouble()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getDouble(int)"><B>getDouble(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getDouble()"><B>getDouble()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getDouble(int)"><B>getDouble(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#getEnabledCipherSuites()"><B>getEnabledCipherSuites()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Returns the list of cipher suites to be enabled when <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLEngine.html" title="class or interface in javax.net.ssl"><CODE>SSLEngine</CODE></A>
 is initialized.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#getEnabledProtocols()"><B>getEnabledProtocols()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Returns the list of protocols to be enabled when <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLEngine.html" title="class or interface in javax.net.ssl"><CODE>SSLEngine</CODE></A>
 is initialized.
<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html#getEncoder()"><B>getEncoder()</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageEncoderFactory.html#getEncoder()"><B>getEncoder()</B></A> - 
Method in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageEncoderFactory.html" title="interface in org.apache.mina.filter.codec.demux">MessageEncoderFactory</A>
<DD>Creates a new message encoder.
<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyCodecFactory.html#getEncoder()"><B>getEncoder()</B></A> - 
Method in class org.apache.mina.filter.codec.netty.<A HREF="./org/apache/mina/filter/codec/netty/NettyCodecFactory.html" title="class in org.apache.mina.filter.codec.netty">NettyCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFactory.html#getEncoder()"><B>getEncoder()</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFactory.html" title="interface in org.apache.mina.filter.codec">ProtocolCodecFactory</A>
<DD>Returns a new (or reusable) instance of <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A> which
 encodes message objects into binary or protocol-specific data.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html#getEncoder()"><B>getEncoder()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolEncoder.html#getEncoder()"><B>getEncoder()</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolEncoder.html" title="class in org.apache.mina.filter.codec">SynchronizedProtocolEncoder</A>
<DD>Returns the encoder this encoder is decorating.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html#getEncoder()"><B>getEncoder()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html" title="class in org.apache.mina.filter.codec.textline">TextLineCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html#getEncoderMaxLineLength()"><B>getEncoderMaxLineLength()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html" title="class in org.apache.mina.filter.codec.textline">TextLineCodecFactory</A>
<DD>Returns the allowed maximum size of the encoded line.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html#getEncoderMaxObjectSize()"><B>getEncoderMaxObjectSize()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationCodecFactory</A>
<DD>Returns the allowed maximum size of the encoded object.
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#getEntry(java.lang.String)"><B>getEntry(String)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#getEntry(java.lang.String)"><B>getEntry(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoFilterChain.Entry.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain.Entry</CODE></A> with the specified <tt>name</tt> in this chain.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#getEntry(java.lang.String)"><B>getEntry(String)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TransportType.html#getEnvelopeType()"><B>getEnvelopeType()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExecutorThreadModel.html#getExecutor()"><B>getExecutor()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExecutorThreadModel.html" title="class in org.apache.mina.common">ExecutorThreadModel</A>
<DD>Returns the underlying <CODE>Executor</CODE> of this model.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorExecutor.html#getExecutor()"><B>getExecutor()</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorExecutor.html" title="class in org.apache.mina.filter.executor">ExecutorExecutor</A>
<DD>Returns the underlying executor this thread pool wraps.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#getExecutor()"><B>getExecutor()</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>Returns the underlying <CODE>Executor</CODE> instance this filter uses.
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#getExpirationInterval()"><B>getExpirationInterval()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#getExpirationInterval()"><B>getExpirationInterval()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#getExpirationInterval()"><B>getExpirationInterval()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#getExpirer()"><B>getExpirer()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.Entry.html#getFilter()"><B>getFilter()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.Entry.html" title="interface in org.apache.mina.common">IoFilterChain.Entry</A>
<DD>Returns the filter.
<DT><A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html#getFilter()"><B>getFilter()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html" title="class in org.apache.mina.integration.spring">IoFilterMapping</A>
<DD>Returns the filter of this mapping.
<DT><A HREF="./org/apache/mina/common/IoService.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common">IoService</A>
<DD>A shortcut for <tt>( ( DefaultIoFilterChainBuilder ) </tt><A HREF="./org/apache/mina/common/IoService.html#getFilterChainBuilder()"><CODE>IoService.getFilterChainBuilder()</CODE></A><tt> )</tt>.
<DT><A HREF="./org/apache/mina/common/IoServiceConfig.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common">IoServiceConfig</A>
<DD>A shortcut for <tt>( ( DefaultIoFilterChainBuilder ) </tt><A HREF="./org/apache/mina/common/IoServiceConfig.html#getFilterChainBuilder()"><CODE>IoServiceConfig.getFilterChainBuilder()</CODE></A><tt> )</tt>.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the filter chain that only affects this session.
<DT><A HREF="./org/apache/mina/common/IoService.html#getFilterChainBuilder()"><B>getFilterChainBuilder()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common">IoService</A>
<DD>Returns the global <A HREF="./org/apache/mina/common/IoFilterChainBuilder.html" title="interface in org.apache.mina.common"><CODE>IoFilterChainBuilder</CODE></A> which will modify the
 <A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain</CODE></A> of all <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>s which is managed
 by this service.
<DT><A HREF="./org/apache/mina/common/IoServiceConfig.html#getFilterChainBuilder()"><B>getFilterChainBuilder()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common">IoServiceConfig</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoFilterChainBuilder.html" title="interface in org.apache.mina.common"><CODE>IoFilterChainBuilder</CODE></A> which will modify the
 <A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain</CODE></A> of all <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>s which is created
 with this configuration.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getFloat()"><B>getFloat()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getFloat(int)"><B>getFloat(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getFloat()"><B>getFloat()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getFloat(int)"><B>getFloat(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html#getFuture()"><B>getFuture()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html" title="class in org.apache.mina.common">IoFilter.WriteRequest</A>
<DD>Returns <A HREF="./org/apache/mina/common/WriteFuture.html" title="interface in org.apache.mina.common"><CODE>WriteFuture</CODE></A> that is associated with this write request.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getHandler()"><B>getHandler()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> which handles this session.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerFactory.html#getHandler(org.apache.mina.common.IoSession)"><B>getHandler(IoSession)</B></A> - 
Method in interface org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerFactory.html" title="interface in org.apache.mina.handler.multiton">SingleSessionIoHandlerFactory</A>
<DD>Returns a <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton"><CODE>SingleSessionIoHandler</CODE></A> for the given session.
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#getHandler()"><B>getHandler()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>Returns the handler of this binding object.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getHexDump()"><B>getHexDump()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns hexdump of this buffer.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getHexDump()"><B>getHexDump()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html#getHexdump()"><B>getHexdump()</B></A> - 
Method in exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderException</A>
<DD>Returns the hexdump of the unknown message part.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getIdleCount(org.apache.mina.common.IdleStatus)"><B>getIdleCount(IdleStatus)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the number of the fired continuous <tt>sessionIdle</tt> events
 for the specified <A HREF="./org/apache/mina/common/IdleStatus.html" title="class in org.apache.mina.common"><CODE>IdleStatus</CODE></A>.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getIdleTime(org.apache.mina.common.IdleStatus)"><B>getIdleTime(IdleStatus)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns idle time for the specified type of idleness in seconds.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getIdleTimeInMillis(org.apache.mina.common.IdleStatus)"><B>getIdleTimeInMillis(IdleStatus)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns idle time for the specified type of idleness in milliseconds.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getInstalledFilters()"><B>getInstalledFilters()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getInstalledFilters()"><B>getInstalledFilters()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>get the list of filters installed in the filter chain
<DT><A HREF="./org/apache/mina/common/ExceptionMonitor.html#getInstance()"><B>getInstance()</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExceptionMonitor.html" title="class in org.apache.mina.common">ExceptionMonitor</A>
<DD>Returns the current exception monitor.
<DT><A HREF="./org/apache/mina/common/ExecutorThreadModel.html#getInstance(java.lang.String)"><B>getInstance(String)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExecutorThreadModel.html" title="class in org.apache.mina.common">ExecutorThreadModel</A>
<DD>Returns a <A HREF="./org/apache/mina/common/ExecutorThreadModel.html" title="class in org.apache.mina.common"><CODE>ExecutorThreadModel</CODE></A> instance for the specified <tt>serviceName</tt>.
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#getInstance(int)"><B>getInstance(int)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>Returns an appropriate <A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common"><CODE>TrafficMask</CODE></A> instance from the
 specified <tt>interestOps</tt>.
<DT><A HREF="./org/apache/mina/common/TransportType.html#getInstance(java.lang.String)"><B>getInstance(String)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>Returns the transport type of the specified name.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getInt()"><B>getInt()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getInt(int)"><B>getInt(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getInt()"><B>getInt()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getInt(int)"><B>getInt(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#getInterestOps()"><B>getInterestOps()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>Returns an interestOps of <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/channels/SelectionKey.html" title="class or interface in java.nio.channels"><CODE>SelectionKey</CODE></A> for this mask.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html#getKeepAliveTime()"><B>getKeepAliveTime()</B></A> - 
Method in interface org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html" title="interface in org.apache.mina.filter.executor">ExecutorFilterMBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#getLastIdleTime(org.apache.mina.common.IdleStatus)"><B>getLastIdleTime(IdleStatus)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the time in millis when the last <tt>sessionIdle</tt> event
 is fired for the specified <A HREF="./org/apache/mina/common/IdleStatus.html" title="class in org.apache.mina.common"><CODE>IdleStatus</CODE></A>.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getLastIoTime()"><B>getLastIoTime()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the time in millis when I/O occurred lastly.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getLastIoTime()"><B>getLastIoTime()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getLastIoTime()"><B>getLastIoTime()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>last time the session processed an IO
<DT><A HREF="./org/apache/mina/common/IoSession.html#getLastReadTime()"><B>getLastReadTime()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the time in millis when read operation occurred lastly.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getLastReadTime()"><B>getLastReadTime()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getLastReadTime()"><B>getLastReadTime()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>last time the session processed an read
<DT><A HREF="./org/apache/mina/common/IoSession.html#getLastWriteTime()"><B>getLastWriteTime()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the time in millis when write operation occurred lastly.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getLastWriteTime()"><B>getLastWriteTime()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getLastWriteTime()"><B>getLastWriteTime()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>last time the session processed a write
<DT><A HREF="./org/apache/mina/common/IoSession.html#getLocalAddress()"><B>getLocalAddress()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the socket address of local machine which is associated with this
 session.
<DT><A HREF="./org/apache/mina/common/IoFuture.html#getLock()"><B>getLock()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common">IoFuture</A>
<DD>Returns the lock object this future acquires.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getLong()"><B>getLong()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getLong(int)"><B>getLong(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getLong()"><B>getLong()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getLong(int)"><B>getLong(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoService.html#getManagedServiceAddresses()"><B>getManagedServiceAddresses()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common">IoService</A>
<DD>Returns all <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/net/SocketAddress.html" title="class or interface in java.net"><CODE>SocketAddress</CODE></A>es this service is managing.
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#getManagedSessionCount()"><B>getManagedSessionCount()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#getManagedSessionCount()"><B>getManagedSessionCount()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>amount of session currently managed
<DT><A HREF="./org/apache/mina/common/IoService.html#getManagedSessions(java.net.SocketAddress)"><B>getManagedSessions(SocketAddress)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common">IoService</A>
<DD>Returns all sessions with the specified remote or local address,
 which are currently managed by this service.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html#getMaximumPoolSize()"><B>getMaximumPoolSize()</B></A> - 
Method in interface org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html" title="interface in org.apache.mina.filter.executor">ExecutorFilterMBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html#getMaxLineLength()"><B>getMaxLineLength()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineDecoder</A>
<DD>Returns the allowed maximum size of the line to be decoded.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html#getMaxLineLength()"><B>getMaxLineLength()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineEncoder</A>
<DD>Returns the allowed maximum size of the encoded line.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html#getMaxObjectSize()"><B>getMaxObjectSize()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationDecoder</A>
<DD>Returns the allowed maximum size of the object to be decoded.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html#getMaxObjectSize()"><B>getMaxObjectSize()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationEncoder</A>
<DD>Returns the allowed maximum size of the encoded object.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#getMaxObjectSize()"><B>getMaxObjectSize()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>Returns the allowed maximum size of the object to be decoded.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#getMaxObjectSize()"><B>getMaxObjectSize()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>Returns the allowed maximum size of the encoded object.
<DT><A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html#getMessage()"><B>getMessage()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html" title="class in org.apache.mina.common">IoFilter.WriteRequest</A>
<DD>Returns a message object to be written.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html#getMessage()"><B>getMessage()</B></A> - 
Method in exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderException</A>
<DD>Returns the message and the hexdump of the unknown part.
<DT><A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html#getMessageHandler(java.lang.Class)"><B>getMessageHandler(Class)</B></A> - 
Method in class org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html" title="class in org.apache.mina.handler.demux">DemuxingIoHandler</A>
<DD>Returns the <A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><CODE>MessageHandler</CODE></A> which is registered to process
 the specified <code>type</code>.
<DT><A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html#getMessageHandlerMap()"><B>getMessageHandlerMap()</B></A> - 
Method in class org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html" title="class in org.apache.mina.handler.demux">DemuxingIoHandler</A>
<DD>Returns the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Map.html" title="class or interface in java.util"><CODE>Map</CODE></A> which contains all messageType-<A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><CODE>MessageHandler</CODE></A>
 pairs registered to this handler.
<DT><A HREF="./org/apache/mina/management/IoSessionStat.html#getMessageReadThroughput()"><B>getMessageReadThroughput()</B></A> - 
Method in class org.apache.mina.management.<A HREF="./org/apache/mina/management/IoSessionStat.html" title="class in org.apache.mina.management">IoSessionStat</A>
<DD>Messages read per second
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getMessageReadThroughtput()"><B>getMessageReadThroughtput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getMessageReadThroughtput()"><B>getMessageReadThroughtput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>get the read messages per second throughput
 works only if a stat collector is inspecting this session, and only if a ProtocolDecoderFilter is used
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageEncoder.html#getMessageTypes()"><B>getMessageTypes()</B></A> - 
Method in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageEncoder.html" title="interface in org.apache.mina.filter.codec.demux">MessageEncoder</A>
<DD>Returns the set of message classes this encoder can encode.
<DT><A HREF="./org/apache/mina/management/IoSessionStat.html#getMessageWrittenThroughput()"><B>getMessageWrittenThroughput()</B></A> - 
Method in class org.apache.mina.management.<A HREF="./org/apache/mina/management/IoSessionStat.html" title="class in org.apache.mina.management">IoSessionStat</A>
<DD>Messages written per second
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getMessageWrittenThroughtput()"><B>getMessageWrittenThroughtput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getMessageWrittenThroughtput()"><B>getMessageWrittenThroughtput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>get the written messages per second throughput
 works only if a stat collector is inspecting this session, and only if a ProtocolDecoderFilter is used
<DT><A HREF="./org/apache/mina/common/IoFilterChain.Entry.html#getName()"><B>getName()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.Entry.html" title="interface in org.apache.mina.common">IoFilterChain.Entry</A>
<DD>Returns the name of the filter.
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#getName()"><B>getName()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>Returns the name of this mask.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.Entry.html#getName()"><B>getName()</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.Entry.html" title="class in org.apache.mina.handler.chain">IoHandlerChain.Entry</A>
<DD>Returns the name of the command.
<DT><A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html#getName()"><B>getName()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html" title="class in org.apache.mina.integration.spring">IoFilterMapping</A>
<DD>Returns the name associated with the filter.
<DT><A HREF="./org/apache/mina/common/TransportType.html#getNames()"><B>getNames()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>Returns the known names of this transport type.
<DT><A HREF="./org/apache/mina/util/AvailablePortFinder.html#getNextAvailable()"><B>getNextAvailable()</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AvailablePortFinder.html" title="class in org.apache.mina.util">AvailablePortFinder</A>
<DD>Gets the next available port starting at the lowest port number.
<DT><A HREF="./org/apache/mina/util/AvailablePortFinder.html#getNextAvailable(int)"><B>getNextAvailable(int)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AvailablePortFinder.html" title="class in org.apache.mina.util">AvailablePortFinder</A>
<DD>Gets the next available port starting at a port.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.Entry.html#getNextCommand()"><B>getNextCommand()</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.Entry.html" title="class in org.apache.mina.handler.chain">IoHandlerChain.Entry</A>
<DD>Returns the <A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.NextCommand.html" title="interface in org.apache.mina.handler.chain"><CODE>IoHandlerCommand.NextCommand</CODE></A> of the command.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#getNextCommand(java.lang.String)"><B>getNextCommand(String)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.Entry.html#getNextFilter()"><B>getNextFilter()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.Entry.html" title="interface in org.apache.mina.common">IoFilterChain.Entry</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter.NextFilter</CODE></A> of the filter.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#getNextFilter(java.lang.String)"><B>getNextFilter(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter.NextFilter</CODE></A> of the <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A> with the
 specified <tt>name</tt> in this chain.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.Event.html#getNextFilter()"><B>getNextFilter()</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.Event.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.Event</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getObject()"><B>getObject()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads a Java object from the buffer using the context <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ClassLoader.html" title="class or interface in java.lang"><CODE>ClassLoader</CODE></A>
 of the current thread.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getObject(java.lang.ClassLoader)"><B>getObject(ClassLoader)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads a Java object from the buffer using the specified <tt>classLoader</tt>.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getObject()"><B>getObject()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getObject(java.lang.ClassLoader)"><B>getObject(ClassLoader)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html#getObject()"><B>getObject()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html" title="class in org.apache.mina.integration.spring">ExecutorThreadModelFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html#getObject()"><B>getObject()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html" title="class in org.apache.mina.integration.spring">IoAcceptorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html#getObjectType()"><B>getObjectType()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html" title="class in org.apache.mina.integration.spring">DefaultIoFilterChainBuilderFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html#getObjectType()"><B>getObjectType()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html" title="class in org.apache.mina.integration.spring">ExecutorThreadModelFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html#getObjectType()"><B>getObjectType()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html" title="class in org.apache.mina.integration.spring">IoAcceptorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html#getObjectType()"><B>getObjectType()</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">KeyStoreFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#getObjectType()"><B>getObjectType()</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#getObjectType()"><B>getObjectType()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html#getPoolSize()"><B>getPoolSize()</B></A> - 
Method in interface org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html" title="interface in org.apache.mina.filter.executor">ExecutorFilterMBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html#getPort()"><B>getPort()</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAddress</A>
<DD>Returns the port number.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getPrefixedString(java.nio.charset.CharsetDecoder)"><B>getPrefixedString(CharsetDecoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads a string which has a 16-bit length field before the actual
 encoded string, using the specified <code>decoder</code> and returns it.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getPrefixedString(int, java.nio.charset.CharsetDecoder)"><B>getPrefixedString(int, CharsetDecoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads a string which has a length field before the actual
 encoded string, using the specified <code>decoder</code> and returns it.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getPrefixedString(java.nio.charset.CharsetDecoder)"><B>getPrefixedString(CharsetDecoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getPrefixedString(int, java.nio.charset.CharsetDecoder)"><B>getPrefixedString(int, CharsetDecoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#getReadBytes()"><B>getReadBytes()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the total number of bytes which were read from this session.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getReadBytes()"><B>getReadBytes()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getReadBytes()"><B>getReadBytes()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>bytes read from the beginning
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getReadIdleTime()"><B>getReadIdleTime()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getReadIdleTime()"><B>getReadIdleTime()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>read IDLE time
<DT><A HREF="./org/apache/mina/common/IoSession.html#getReadMessages()"><B>getReadMessages()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the total number of messages which were read and decoded from this session.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getReadMessages()"><B>getReadMessages()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getReadMessages()"><B>getReadMessages()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>PDU decoded from the beginning.
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#getReadTimeout()"><B>getReadTimeout()</B></A> - 
Method in class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>Returns read timeout in seconds.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#getReceiveBufferSize()"><B>getReceiveBufferSize()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#getReceiveBufferSize()"><B>getReceiveBufferSize()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#getReceiveBufferSize()"><B>getReceiveBufferSize()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#getRemoteAddress()"><B>getRemoteAddress()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the socket address of remote peer.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getScheduledWriteBytes()"><B>getScheduledWriteBytes()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the number of bytes which are scheduled to be written to this
 session.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getScheduledWriteRequests()"><B>getScheduledWriteRequests()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the number of write requests which are scheduled to be written
 to this session.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#getSendBufferSize()"><B>getSendBufferSize()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#getSendBufferSize()"><B>getSendBufferSize()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#getSendBufferSize()"><B>getSendBufferSize()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#getService()"><B>getService()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A> which provides I/O service to this session.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getServiceAddress()"><B>getServiceAddress()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the socket address of the <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A> listens to to manage
 this session.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getServiceConfig()"><B>getServiceConfig()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common"><CODE>IoServiceConfig</CODE></A> of this session.
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#getServiceConfig()"><B>getServiceConfig()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ConnectFuture.html#getSession()"><B>getSession()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/ConnectFuture.html" title="interface in org.apache.mina.common">ConnectFuture</A>
<DD>Returns <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> which is the result of connect operation.
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#getSession()"><B>getSession()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Returns the parent <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> of this chain.
<DT><A HREF="./org/apache/mina/common/IoFuture.html#getSession()"><B>getSession()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common">IoFuture</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> which is associated with this future.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html#getSession()"><B>getSession()</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerAdapter</A>
<DD>Retrieves the session to which this handler is assigned.
<DT><A HREF="./org/apache/mina/common/IoServiceConfig.html#getSessionConfig()"><B>getSessionConfig()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common">IoServiceConfig</A>
<DD>Resturns the default configuration of the new <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>s.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html#getSessionConfig()"><B>getSessionConfig()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramAcceptorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html#getSessionConfig()"><B>getSessionConfig()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramConnectorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html#getSessionConfig()"><B>getSessionConfig()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnectorConfig.html#getSessionConfig()"><B>getSessionConfig()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnectorConfig.html" title="class in org.apache.mina.transport.socket.nio">SocketConnectorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html#getSessionRecycler()"><B>getSessionRecycler()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramAcceptorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html#getSessionRecycler()"><B>getSessionRecycler()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramConnectorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramServiceConfig.html#getSessionRecycler()"><B>getSessionRecycler()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramServiceConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramServiceConfig</A>
<DD>Returns the <A HREF="./org/apache/mina/common/IoSessionRecycler.html" title="interface in org.apache.mina.common"><CODE>IoSessionRecycler</CODE></A> for this service.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getShort()"><B>getShort()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getShort(int)"><B>getShort(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getShort()"><B>getShort()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getShort(int)"><B>getShort(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#getSoLinger()"><B>getSoLinger()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#getSoLinger()"><B>getSoLinger()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#getSSLSession(org.apache.mina.common.IoSession)"><B>getSSLSession(IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Returns the underlying <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLSession.html" title="class or interface in javax.net.ssl"><CODE>SSLSession</CODE></A> for the specified session.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getString(java.nio.charset.CharsetDecoder)"><B>getString(CharsetDecoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads a <code>NUL</code>-terminated string from this buffer using the
 specified <code>decoder</code> and returns it.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getString(int, java.nio.charset.CharsetDecoder)"><B>getString(int, CharsetDecoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads a <code>NUL</code>-terminated string from this buffer using the
 specified <code>decoder</code> and returns it.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getString(int, java.nio.charset.CharsetDecoder)"><B>getString(int, CharsetDecoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getString(java.nio.charset.CharsetDecoder)"><B>getString(CharsetDecoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoServiceConfig.html#getThreadModel()"><B>getThreadModel()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common">IoServiceConfig</A>
<DD>Returns the default <A HREF="./org/apache/mina/common/ThreadModel.html" title="interface in org.apache.mina.common"><CODE>ThreadModel</CODE></A> of the <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html#getThreadNamePrefix()"><B>getThreadNamePrefix()</B></A> - 
Method in interface org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html" title="interface in org.apache.mina.filter.executor">ExecutorFilterMBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html#getTimeout()"><B>getTimeout()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html" title="class in org.apache.mina.common">PooledByteBufferAllocator</A>
<DD>Returns the timeout value of this allocator in seconds.
<DT><A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html#getTimeoutMillis()"><B>getTimeoutMillis()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html" title="class in org.apache.mina.common">PooledByteBufferAllocator</A>
<DD>Returns the timeout value of this allocator in milliseconds.
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#getTimeToLive()"><B>getTimeToLive()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#getTimeToLive()"><B>getTimeToLive()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#getTimeToLive()"><B>getTimeToLive()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#getTotalByteReadThroughput()"><B>getTotalByteReadThroughput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#getTotalByteReadThroughput()"><B>getTotalByteReadThroughput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>bytes read per seconds sum of all the managed sessions
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#getTotalByteWrittenThroughput()"><B>getTotalByteWrittenThroughput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#getTotalByteWrittenThroughput()"><B>getTotalByteWrittenThroughput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>bytes written per seconds sum for all the managed sessions
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#getTotalMessageReadThroughput()"><B>getTotalMessageReadThroughput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#getTotalMessageReadThroughput()"><B>getTotalMessageReadThroughput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>messages read per seconds sum of all the managed sessions
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#getTotalMessageWrittenThroughput()"><B>getTotalMessageWrittenThroughput()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#getTotalMessageWrittenThroughput()"><B>getTotalMessageWrittenThroughput()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>messages written per seconds sum for all the managed sessions
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#getTrafficClass()"><B>getTrafficClass()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#getTrafficClass()"><B>getTrafficClass()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#getTrafficClass()"><B>getTrafficClass()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#getTrafficMask()"><B>getTrafficMask()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the current <A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common"><CODE>TrafficMask</CODE></A> of this session.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getTransportType()"><B>getTransportType()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns transport type of this session.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.Event.html#getType()"><B>getType()</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.Event.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.Event</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getUnsigned()"><B>getUnsigned()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads one unsigned byte as a short integer.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getUnsigned(int)"><B>getUnsigned(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads one byte as an unsigned short integer.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getUnsigned()"><B>getUnsigned()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getUnsigned(int)"><B>getUnsigned(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getUnsignedInt()"><B>getUnsignedInt()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads four bytes unsigned integer.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getUnsignedInt(int)"><B>getUnsignedInt(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads four bytes unsigned integer.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getUnsignedInt()"><B>getUnsignedInt()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getUnsignedInt(int)"><B>getUnsignedInt(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getUnsignedShort()"><B>getUnsignedShort()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads two bytes unsigned integer.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#getUnsignedShort(int)"><B>getUnsignedShort(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Reads two bytes unsigned integer.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getUnsignedShort()"><B>getUnsignedShort()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#getUnsignedShort(int)"><B>getUnsignedShort(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#getValue()"><B>getValue()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>Return the delimiter string.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html#getWorkerTimeout()"><B>getWorkerTimeout()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio">SocketConnector</A>
<DD>How many seconds to keep the connection thread alive between connection requests
<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html#getWriteBufferSize()"><B>getWriteBufferSize()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter">StreamWriteFilter</A>
<DD>Returns the size of the write buffer in bytes.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getWriteIdleTime()"><B>getWriteIdleTime()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getWriteIdleTime()"><B>getWriteIdleTime()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>write IDLE time
<DT><A HREF="./org/apache/mina/common/IoSession.html#getWriteTimeout()"><B>getWriteTimeout()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns write timeout in seconds.
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#getWriteTimeout()"><B>getWriteTimeout()</B></A> - 
Method in class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>Returns write timeout in seconds.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getWriteTimeoutInMillis()"><B>getWriteTimeoutInMillis()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns write timeout in milliseconds.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getWrittenBytes()"><B>getWrittenBytes()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the total number of bytes which were written to this session.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getWrittenBytes()"><B>getWrittenBytes()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getWrittenBytes()"><B>getWrittenBytes()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>bytes written from the beginning
<DT><A HREF="./org/apache/mina/common/IoSession.html#getWrittenMessages()"><B>getWrittenMessages()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the total number of messages which were written and encoded by this session.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#getWrittenMessages()"><B>getWrittenMessages()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#getWrittenMessages()"><B>getWrittenMessages()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>PDU encoded from the beginning.
<DT><A HREF="./org/apache/mina/common/IoSession.html#getWrittenWriteRequests()"><B>getWrittenWriteRequests()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns the total number of write requests which were written to this session.
</DL>
<HR>
<A NAME="_H_"><!-- --></A><H2>
<B>H</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html#HANDLER"><B>HANDLER</B></A> - 
Static variable in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerDelegate</A>
<DD>The key used to store the <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton"><CODE>SingleSessionIoHandler</CODE></A> as a session
 attribute.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#hashCode()"><B>hashCode()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#hashCode()"><B>hashCode()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#hashCode()"><B>hashCode()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html#hashCode()"><B>hashCode()</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/AnonymousSocketAddress.html#hashCode()"><B>hashCode()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AnonymousSocketAddress.html" title="class in org.apache.mina.util">AnonymousSocketAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#hashCode()"><B>hashCode()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#hashCode()"><B>hashCode()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#hasRemaining()"><B>hasRemaining()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#hasRemaining()"><B>hasRemaining()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_I_"><!-- --></A><H2>
<B>I</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/IdentityHashSet.html" title="class in org.apache.mina.util"><B>IdentityHashSet</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>An <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/IdentityHashMap.html" title="class or interface in java.util"><CODE>IdentityHashMap</CODE></A>-backed <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Set.html" title="class or interface in java.util"><CODE>Set</CODE></A>.<DT><A HREF="./org/apache/mina/util/IdentityHashSet.html#IdentityHashSet()"><B>IdentityHashSet()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/IdentityHashSet.html" title="class in org.apache.mina.util">IdentityHashSet</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/IdentityHashSet.html#IdentityHashSet(java.util.Collection)"><B>IdentityHashSet(Collection)</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/IdentityHashSet.html" title="class in org.apache.mina.util">IdentityHashSet</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html#IDLE"><B>IDLE</B></A> - 
Static variable in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IdleStatus.html" title="class in org.apache.mina.common"><B>IdleStatus</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Represents the type of idleness of <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> or
 <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>.<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#indexOf(java.lang.Object)"><B>indexOf(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/InetAddressEditor.html" title="class in org.apache.mina.integration.spring"><B>InetAddressEditor</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/package-summary.html">org.apache.mina.integration.spring</A><DD>Java Bean <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/beans/PropertyEditor.html" title="class or interface in java.beans"><CODE>PropertyEditor</CODE></A> which converts Strings into 
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/net/InetAddress.html" title="class or interface in java.net"><CODE>InetAddress</CODE></A> objects.<DT><A HREF="./org/apache/mina/integration/spring/InetAddressEditor.html#InetAddressEditor()"><B>InetAddressEditor()</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/InetAddressEditor.html" title="class in org.apache.mina.integration.spring">InetAddressEditor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/InetSocketAddressEditor.html" title="class in org.apache.mina.integration.spring"><B>InetSocketAddressEditor</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/package-summary.html">org.apache.mina.integration.spring</A><DD>Java Bean <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/beans/PropertyEditor.html" title="class or interface in java.beans"><CODE>PropertyEditor</CODE></A> which converts Strings into 
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/net/InetSocketAddress.html" title="class or interface in java.net"><CODE>InetSocketAddress</CODE></A> objects.<DT><A HREF="./org/apache/mina/integration/spring/InetSocketAddressEditor.html#InetSocketAddressEditor()"><B>InetSocketAddressEditor()</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/InetSocketAddressEditor.html" title="class in org.apache.mina.integration.spring">InetSocketAddressEditor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/SessionLog.html#info(org.apache.mina.common.IoSession, java.lang.String)"><B>info(IoSession, String)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/SessionLog.html#info(org.apache.mina.common.IoSession, java.lang.String, java.lang.Throwable)"><B>info(IoSession, String, Throwable)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.html#init()"><B>init()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Invoked by <A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter"><CODE>ReferenceCountingIoFilter</CODE></A> when this filter
 is added to a <A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain</CODE></A> at the first time, so you can
 initialize shared resources.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#init()"><B>init()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#init()"><B>init()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html#INITIAL_WRITE_FUTURE"><B>INITIAL_WRITE_FUTURE</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter">StreamWriteFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/SessionUtil.html#initialize(org.apache.mina.common.IoSession)"><B>initialize(IoSession)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionUtil.html" title="class in org.apache.mina.util">SessionUtil</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common"><B>IoAcceptor</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Accepts incoming connection, communicates with clients, and fires events to
 <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A>s.<DT><A HREF="./org/apache/mina/common/IoAcceptorConfig.html" title="interface in org.apache.mina.common"><B>IoAcceptorConfig</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A configuration which is used to configure <A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common"><CODE>IoAcceptor</CODE></A>.<DT><A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html" title="class in org.apache.mina.integration.spring"><B>IoAcceptorFactoryBean</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/package-summary.html">org.apache.mina.integration.spring</A><DD>Spring <CODE>FactoryBean</CODE> which enables the bindings of an <A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common"><CODE>IoAcceptor</CODE></A>
 to be configured using Spring.<DT><A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html#IoAcceptorFactoryBean()"><B>IoAcceptorFactoryBean()</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html" title="class in org.apache.mina.integration.spring">IoAcceptorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoConnector.html" title="interface in org.apache.mina.common"><B>IoConnector</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Connects to endpoint, communicates with the server, and fires events to
 <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A>s.<DT><A HREF="./org/apache/mina/common/IoConnectorConfig.html" title="interface in org.apache.mina.common"><B>IoConnectorConfig</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A configuration which is used to configure <A HREF="./org/apache/mina/common/IoConnector.html" title="interface in org.apache.mina.common"><CODE>IoConnector</CODE></A>.<DT><A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><B>IoFilter</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A filter which intercepts <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> events like Servlet
 filters.<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common"><B>IoFilter.NextFilter</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Represents the next <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A> in <A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain</CODE></A>.<DT><A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html" title="class in org.apache.mina.common"><B>IoFilter.WriteRequest</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Represents write request fired by <A HREF="./org/apache/mina/common/IoSession.html#write(java.lang.Object)"><CODE>IoSession.write(Object)</CODE></A>.<DT><A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html#IoFilter.WriteRequest(java.lang.Object)"><B>IoFilter.WriteRequest(Object)</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html" title="class in org.apache.mina.common">IoFilter.WriteRequest</A>
<DD>Creates a new instance without <A HREF="./org/apache/mina/common/WriteFuture.html" title="interface in org.apache.mina.common"><CODE>WriteFuture</CODE></A>.
<DT><A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html#IoFilter.WriteRequest(java.lang.Object, org.apache.mina.common.WriteFuture)"><B>IoFilter.WriteRequest(Object, WriteFuture)</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html" title="class in org.apache.mina.common">IoFilter.WriteRequest</A>
<DD>Creates a new instance with <A HREF="./org/apache/mina/common/WriteFuture.html" title="interface in org.apache.mina.common"><CODE>WriteFuture</CODE></A>.
<DT><A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html#IoFilter.WriteRequest(java.lang.Object, org.apache.mina.common.WriteFuture, java.net.SocketAddress)"><B>IoFilter.WriteRequest(Object, WriteFuture, SocketAddress)</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html" title="class in org.apache.mina.common">IoFilter.WriteRequest</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common"><B>IoFilterAdapter</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>An abstract adapter class for <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A>.<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#IoFilterAdapter()"><B>IoFilterAdapter()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><B>IoFilterChain</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A container of <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A>s that forwards <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> events
 to the consisting filters and terminal <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> sequentially.<DT><A HREF="./org/apache/mina/common/IoFilterChain.Entry.html" title="interface in org.apache.mina.common"><B>IoFilterChain.Entry</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Represents a name-filter pair that an <A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain</CODE></A> contains.<DT><A HREF="./org/apache/mina/common/IoFilterChainBuilder.html" title="interface in org.apache.mina.common"><B>IoFilterChainBuilder</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>An interface that builds <A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain</CODE></A> in predefined way
 when <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> is created.<DT><A HREF="./org/apache/mina/common/IoFilterLifeCycleException.html" title="class in org.apache.mina.common"><B>IoFilterLifeCycleException</B></A> - Exception in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang"><CODE>RuntimeException</CODE></A> which is thrown when <A HREF="./org/apache/mina/common/IoFilter.html#init()"><CODE>IoFilter.init()</CODE></A>
 or <A HREF="./org/apache/mina/common/IoFilter.html#onPostAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><CODE>IoFilter.onPostAdd(IoFilterChain, String, org.apache.mina.common.IoFilter.NextFilter)</CODE></A>
 failed.<DT><A HREF="./org/apache/mina/common/IoFilterLifeCycleException.html#IoFilterLifeCycleException()"><B>IoFilterLifeCycleException()</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterLifeCycleException.html" title="class in org.apache.mina.common">IoFilterLifeCycleException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterLifeCycleException.html#IoFilterLifeCycleException(java.lang.String)"><B>IoFilterLifeCycleException(String)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterLifeCycleException.html" title="class in org.apache.mina.common">IoFilterLifeCycleException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterLifeCycleException.html#IoFilterLifeCycleException(java.lang.String, java.lang.Throwable)"><B>IoFilterLifeCycleException(String, Throwable)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterLifeCycleException.html" title="class in org.apache.mina.common">IoFilterLifeCycleException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterLifeCycleException.html#IoFilterLifeCycleException(java.lang.Throwable)"><B>IoFilterLifeCycleException(Throwable)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterLifeCycleException.html" title="class in org.apache.mina.common">IoFilterLifeCycleException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html" title="class in org.apache.mina.integration.spring"><B>IoFilterMapping</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/package-summary.html">org.apache.mina.integration.spring</A><DD>Associates a name with an <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A>.<DT><A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html#IoFilterMapping()"><B>IoFilterMapping()</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html" title="class in org.apache.mina.integration.spring">IoFilterMapping</A>
<DD>Creates a new empty instance.
<DT><A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html#IoFilterMapping(java.lang.String, org.apache.mina.common.IoFilter)"><B>IoFilterMapping(String, IoFilter)</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html" title="class in org.apache.mina.integration.spring">IoFilterMapping</A>
<DD>Creates a new instance using the specified name and filter.
<DT><A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common"><B>IoFuture</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Represents the result of an ashynchronous I/O operation.<DT><A HREF="./org/apache/mina/common/IoFutureListener.html" title="interface in org.apache.mina.common"><B>IoFutureListener</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Something interested in being notified when the result
 of an <A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common"><CODE>IoFuture</CODE></A> becomes available.<DT><A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><B>IoHandler</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Handles all protocol events fired by MINA.<DT><A HREF="./org/apache/mina/common/IoHandlerAdapter.html" title="class in org.apache.mina.common"><B>IoHandlerAdapter</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>An abstract adapter class for <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A>.<DT><A HREF="./org/apache/mina/common/IoHandlerAdapter.html#IoHandlerAdapter()"><B>IoHandlerAdapter()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandlerAdapter.html" title="class in org.apache.mina.common">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain"><B>IoHandlerChain</B></A> - Class in <A HREF="./org/apache/mina/handler/chain/package-summary.html">org.apache.mina.handler.chain</A><DD>A chain of <A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html" title="interface in org.apache.mina.handler.chain"><CODE>IoHandlerCommand</CODE></A>s.<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#IoHandlerChain()"><B>IoHandlerChain()</B></A> - 
Constructor for class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>Creates a new, empty chain of <A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html" title="interface in org.apache.mina.handler.chain"><CODE>IoHandlerCommand</CODE></A>s.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.Entry.html" title="class in org.apache.mina.handler.chain"><B>IoHandlerChain.Entry</B></A> - Class in <A HREF="./org/apache/mina/handler/chain/package-summary.html">org.apache.mina.handler.chain</A><DD>Represents a name-command pair that an <A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain"><CODE>IoHandlerChain</CODE></A> contains.<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html" title="interface in org.apache.mina.handler.chain"><B>IoHandlerCommand</B></A> - Interface in <A HREF="./org/apache/mina/handler/chain/package-summary.html">org.apache.mina.handler.chain</A><DD>A <A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html" title="interface in org.apache.mina.handler.chain"><CODE>IoHandlerCommand</CODE></A> encapsulates a unit of processing work to be
 performed, whose purpose is to examine and/or modify the state of a
 transaction that is represented by custom attributes provided by 
 <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>.<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.NextCommand.html" title="interface in org.apache.mina.handler.chain"><B>IoHandlerCommand.NextCommand</B></A> - Interface in <A HREF="./org/apache/mina/handler/chain/package-summary.html">org.apache.mina.handler.chain</A><DD>Represents an indirect reference to the next <A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html" title="interface in org.apache.mina.handler.chain"><CODE>IoHandlerCommand</CODE></A> of
 the <A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain"><CODE>IoHandlerChain</CODE></A>.<DT><A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><B>IoService</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Base interface for all <A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common"><CODE>IoAcceptor</CODE></A>s and <A HREF="./org/apache/mina/common/IoConnector.html" title="interface in org.apache.mina.common"><CODE>IoConnector</CODE></A>s
 that provide I/O service and manage <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>s.<DT><A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common"><B>IoServiceConfig</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A configuration which is used to configure <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>.<DT><A HREF="./org/apache/mina/common/IoServiceListener.html" title="interface in org.apache.mina.common"><B>IoServiceListener</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Something interested in being notified when the result
 of an <A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common"><CODE>IoFuture</CODE></A> becomes available.<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx"><B>IoServiceManager</B></A> - Class in <A HREF="./org/apache/mina/integration/jmx/package-summary.html">org.apache.mina.integration.jmx</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#IoServiceManager(org.apache.mina.common.IoService)"><B>IoServiceManager(IoService)</B></A> - 
Constructor for class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx"><B>IoServiceManagerMBean</B></A> - Interface in <A HREF="./org/apache/mina/integration/jmx/package-summary.html">org.apache.mina.integration.jmx</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><B>IoSession</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A handle which represents connection between two endpoints regardless of 
 transport types.<DT><A HREF="./org/apache/mina/common/IoSessionConfig.html" title="interface in org.apache.mina.common"><B>IoSessionConfig</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>The configuration of <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>.<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx"><B>IoSessionManager</B></A> - Class in <A HREF="./org/apache/mina/integration/jmx/package-summary.html">org.apache.mina.integration.jmx</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#IoSessionManager(org.apache.mina.common.IoSession)"><B>IoSessionManager(IoSession)</B></A> - 
Constructor for class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>create the session manager
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx"><B>IoSessionManagerMBean</B></A> - Interface in <A HREF="./org/apache/mina/integration/jmx/package-summary.html">org.apache.mina.integration.jmx</A><DD>MBean interface for the session manager, it's used for instrumenting IoSession<DT><A HREF="./org/apache/mina/common/IoSessionRecycler.html" title="interface in org.apache.mina.common"><B>IoSessionRecycler</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A connectionless transport can recycle existing sessions by assigning an
 IoSessionRecyler to its <A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common"><CODE>IoServiceConfig</CODE></A>.<DT><A HREF="./org/apache/mina/management/IoSessionStat.html" title="class in org.apache.mina.management"><B>IoSessionStat</B></A> - Class in <A HREF="./org/apache/mina/management/package-summary.html">org.apache.mina.management</A><DD>The collected stats for a session.<DT><A HREF="./org/apache/mina/management/IoSessionStat.html#IoSessionStat()"><B>IoSessionStat()</B></A> - 
Constructor for class org.apache.mina.management.<A HREF="./org/apache/mina/management/IoSessionStat.html" title="class in org.apache.mina.management">IoSessionStat</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#isAutoExpand()"><B>isAutoExpand()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns <tt>true</tt> if and only if <tt>autoExpand</tt> is turned on.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#isAutoExpand()"><B>isAutoExpand()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#isBroadcast()"><B>isBroadcast()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/CloseFuture.html#isClosed()"><B>isClosed()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/CloseFuture.html" title="interface in org.apache.mina.common">CloseFuture</A>
<DD>Returns <tt>true</tt> if the close request is finished and the session is closed.
<DT><A HREF="./org/apache/mina/common/IoSession.html#isClosing()"><B>isClosing()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns <code>true</tt> if and only if this session is being closed
 (but not disconnected yet) or is closed.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#isCompressInbound()"><B>isCompressInbound()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>Returns <tt>true</tt> if incoming data is being compressed.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#isCompressOutbound()"><B>isCompressOutbound()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>Returns <tt>true</tt> if the filter is compressing data being written.
<DT><A HREF="./org/apache/mina/common/ConnectFuture.html#isConnected()"><B>isConnected()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/ConnectFuture.html" title="interface in org.apache.mina.common">ConnectFuture</A>
<DD>Returns <tt>true</tt> if the connect operation is finished successfully.
<DT><A HREF="./org/apache/mina/common/IoSession.html#isConnected()"><B>isConnected()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns <code>true</code> if this session is connected with remote peer.
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#isConnected()"><B>isConnected()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#isConnected()"><B>isConnected()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>is the session is connected
<DT><A HREF="./org/apache/mina/common/TransportType.html#isConnectionless()"><B>isConnectionless()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>Returns <code>true</code> if the session of this transport type is
 connectionless.
<DT><A HREF="./org/apache/mina/util/SessionLog.html#isDebugEnabled(org.apache.mina.common.IoSession)"><B>isDebugEnabled(IoSession)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#isDirect()"><B>isDirect()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#isDirect()"><B>isDirect()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoAcceptorConfig.html#isDisconnectOnUnbind()"><B>isDisconnectOnUnbind()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoAcceptorConfig.html" title="interface in org.apache.mina.common">IoAcceptorConfig</A>
<DD>Returns <tt>true</tt> if and only if all clients are disconnected
 when this acceptor unbinds the related local address.
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#isEmpty()"><B>isEmpty()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#isEmpty()"><B>isEmpty()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#isEmpty()"><B>isEmpty()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>Returns <code>true</code> if the stack is empty.
<DT><A HREF="./org/apache/mina/util/Queue.html#isEmpty()"><B>isEmpty()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Returns <code>true</code> if the queue is empty.
<DT><A HREF="./org/apache/mina/util/Stack.html#isEmpty()"><B>isEmpty()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util">Stack</A>
<DD>Returns <code>true</code> if the stack is empty.
<DT><A HREF="./org/apache/mina/util/SessionLog.html#isErrorEnabled(org.apache.mina.common.IoSession)"><B>isErrorEnabled(IoSession)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#isGetTrafficClassAvailable()"><B>isGetTrafficClassAvailable()</B></A> - 
Static method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#isIdle(org.apache.mina.common.IdleStatus)"><B>isIdle(IdleStatus)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Returns <code>true</code> if this session is idle for the specified 
 <A HREF="./org/apache/mina/common/IdleStatus.html" title="class in org.apache.mina.common"><CODE>IdleStatus</CODE></A>.
<DT><A HREF="./org/apache/mina/util/SessionLog.html#isInfoEnabled(org.apache.mina.common.IoSession)"><B>isInfoEnabled(IoSession)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#isKeepAlive()"><B>isKeepAlive()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#isKeepAlive()"><B>isKeepAlive()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoService.html#isManaged(java.net.SocketAddress)"><B>isManaged(SocketAddress)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common">IoService</A>
<DD>Returns <tt>true</tt> if this service is managing the specified <tt>serviceAddress</tt>.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#isNeedClientAuth()"><B>isNeedClientAuth()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Returns <tt>true</tt> if the engine will <em>require</em> client authentication.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#isOobInline()"><B>isOobInline()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#isOobInline()"><B>isOobInline()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#isPooled()"><B>isPooled()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns <tt>true</tt> if and only if this buffer is returned back
 to the buffer pool when released.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#isPooled()"><B>isPooled()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#isReadable()"><B>isReadable()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>Returns <tt>true</tt> if this mask allows a read operation.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#isReadOnly()"><B>isReadOnly()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#isReadOnly()"><B>isReadOnly()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFuture.html#isReady()"><B>isReady()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common">IoFuture</A>
<DD>Returns if the asynchronous operation is finished.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#isReuseAddress()"><B>isReuseAddress()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html#isReuseAddress()"><B>isReuseAddress()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#isReuseAddress()"><B>isReuseAddress()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#isReuseAddress()"><B>isReuseAddress()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/management/StatCollector.html#isRunning()"><B>isRunning()</B></A> - 
Method in class org.apache.mina.management.<A HREF="./org/apache/mina/management/StatCollector.html" title="class in org.apache.mina.management">StatCollector</A>
<DD>is the stat collector started and polling the <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> of the <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#isRunning()"><B>isRunning()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#isSetReceiveBufferSizeAvailable()"><B>isSetReceiveBufferSizeAvailable()</B></A> - 
Static method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#isSetSendBufferSizeAvailable()"><B>isSetSendBufferSizeAvailable()</B></A> - 
Static method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#isSetTrafficClassAvailable()"><B>isSetTrafficClassAvailable()</B></A> - 
Static method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html#isSingleton()"><B>isSingleton()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html" title="class in org.apache.mina.integration.spring">ExecutorThreadModelFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html#isSingleton()"><B>isSingleton()</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html" title="class in org.apache.mina.integration.spring">IoAcceptorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#isSSLStarted(org.apache.mina.common.IoSession)"><B>isSSLStarted(IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Returns <tt>true</tt> if and only if the specified <tt>session</tt> is
 encrypted/decrypted over SSL/TLS currently.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#isTcpNoDelay()"><B>isTcpNoDelay()</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#isTcpNoDelay()"><B>isTcpNoDelay()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#isUseClientMode()"><B>isUseClientMode()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Returns <tt>true</tt> if the engine is set to use client mode
 when handshaking.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#isUseDirectBuffers()"><B>isUseDirectBuffers()</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#isWantClientAuth()"><B>isWantClientAuth()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Returns <tt>true</tt> if the engine will <em>request</em> client authentication.
<DT><A HREF="./org/apache/mina/util/SessionLog.html#isWarnEnabled(org.apache.mina.common.IoSession)"><B>isWarnEnabled(IoSession)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#isWritable()"><B>isWritable()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>Returns <tt>true</tt> if this mask allows a write operation.
<DT><A HREF="./org/apache/mina/common/WriteFuture.html#isWritten()"><B>isWritten()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/WriteFuture.html" title="interface in org.apache.mina.common">WriteFuture</A>
<DD>Returns <tt>true</tt> if the write operation is finished successfully.
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#iterator()"><B>iterator()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/IdentityHashSet.html#iterator()"><B>iterator()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/IdentityHashSet.html" title="class in org.apache.mina.util">IdentityHashSet</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_J_"><!-- --></A><H2>
<B>J</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/IoFuture.html#join()"><B>join()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common">IoFuture</A>
<DD>Wait for the asynchronous operation to end.
<DT><A HREF="./org/apache/mina/common/IoFuture.html#join(long)"><B>join(long)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common">IoFuture</A>
<DD>Wait for the asynchronous operation to end with the specified timeout.
</DL>
<HR>
<A NAME="_K_"><!-- --></A><H2>
<B>K</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/management/StatCollector.html#KEY"><B>KEY</B></A> - 
Static variable in class org.apache.mina.management.<A HREF="./org/apache/mina/management/StatCollector.html" title="class in org.apache.mina.management">StatCollector</A>
<DD>The session attribute key for <A HREF="./org/apache/mina/management/IoSessionStat.html" title="class in org.apache.mina.management"><CODE>IoSessionStat</CODE></A>.
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#keySet()"><B>keySet()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl"><B>KeyStoreFactoryBean</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/ssl/package-summary.html">org.apache.mina.integration.spring.ssl</A><DD>Spring <A HREF="http://static.springframework.org/spring/docs/1.2.x/api/org/springframework/beans/factory/FactoryBean.html" title="class or interface in org.springframework.beans.factory"><CODE>FactoryBean</CODE></A> implementation 
 which makes it possible to configure <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/security/KeyStore.html" title="class or interface in java.security"><CODE>KeyStore</CODE></A> instances
 using Spring.<DT><A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html#KeyStoreFactoryBean()"><B>KeyStoreFactoryBean()</B></A> - 
Constructor for class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">KeyStoreFactoryBean</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_L_"><!-- --></A><H2>
<B>L</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#last()"><B>last()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#last()"><B>last()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#last()"><B>last()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Returns the last element of the queue.
<DT><A HREF="./org/apache/mina/util/Stack.html#last()"><B>last()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util">Stack</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#lastIndexOf(java.lang.Object)"><B>lastIndexOf(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#limit()"><B>limit()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#limit(int)"><B>limit(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#limit()"><B>limit()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#limit(int)"><B>limit(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline"><B>LineDelimiter</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/textline/package-summary.html">org.apache.mina.filter.codec.textline</A><DD>A delimiter which is appended to the end of a text line, such as
 <tt>CR/LF</tt>.<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#LineDelimiter(java.lang.String)"><B>LineDelimiter(String)</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>Creates a new line delimiter with the specified <tt>value</tt>.
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#listIterator()"><B>listIterator()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#listIterator(int)"><B>listIterator(int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#LOGGER"><B>LOGGER</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>Session attribute key: <CODE>Logger</CODE>
<DT><A HREF="./org/apache/mina/util/SessionLog.html#LOGGER"><B>LOGGER</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>Session attribute key: <CODE>Logger</CODE>
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter"><B>LoggingFilter</B></A> - Class in <A HREF="./org/apache/mina/filter/package-summary.html">org.apache.mina.filter</A><DD>Logs all MINA protocol events to <CODE>Logger</CODE>.<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#LoggingFilter()"><B>LoggingFilter()</B></A> - 
Constructor for class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>Creates a new instance.
</DL>
<HR>
<A NAME="_M_"><!-- --></A><H2>
<B>M</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#MAC"><B>MAC</B></A> - 
Static variable in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>The line delimiter constant of Mac OS (<tt>"\r"</tt>)
<DT><A HREF="./org/apache/mina/common/ThreadModel.html#MANUAL"><B>MANUAL</B></A> - 
Static variable in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/ThreadModel.html" title="interface in org.apache.mina.common">ThreadModel</A>
<DD>A <A HREF="./org/apache/mina/common/ThreadModel.html" title="interface in org.apache.mina.common"><CODE>ThreadModel</CODE></A> which make MINA not manage a thread model at all.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#mark()"><B>mark()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#mark()"><B>mark()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#markValue()"><B>markValue()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns the position of the current mark.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#markValue()"><B>markValue()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/AvailablePortFinder.html#MAX_PORT_NUMBER"><B>MAX_PORT_NUMBER</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AvailablePortFinder.html" title="class in org.apache.mina.util">AvailablePortFinder</A>
<DD>The maximum number of server port number.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderOutput.html#mergeAll()"><B>mergeAll()</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoderOutput.html" title="interface in org.apache.mina.filter.codec">ProtocolEncoderOutput</A>
<DD>Merges all buffers you wrote via <A HREF="./org/apache/mina/filter/codec/ProtocolEncoderOutput.html#write(org.apache.mina.common.ByteBuffer)"><CODE>ProtocolEncoderOutput.write(ByteBuffer)</CODE></A> into
 one <A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common"><CODE>ByteBuffer</CODE></A> and replaces the old fragmented ones with it.
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux"><B>MessageDecoder</B></A> - Interface in <A HREF="./org/apache/mina/filter/codec/demux/package-summary.html">org.apache.mina.filter.codec.demux</A><DD>Decodes specific messages.<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderAdapter.html" title="class in org.apache.mina.filter.codec.demux"><B>MessageDecoderAdapter</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/demux/package-summary.html">org.apache.mina.filter.codec.demux</A><DD>An abstract <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux"><CODE>MessageDecoder</CODE></A> implementation for those who don't need to
 implement <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#finishDecode(org.apache.mina.common.IoSession, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><CODE>MessageDecoder.finishDecode(IoSession, ProtocolDecoderOutput)</CODE></A>
 method.<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderAdapter.html#MessageDecoderAdapter()"><B>MessageDecoderAdapter()</B></A> - 
Constructor for class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderAdapter.html" title="class in org.apache.mina.filter.codec.demux">MessageDecoderAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderFactory.html" title="interface in org.apache.mina.filter.codec.demux"><B>MessageDecoderFactory</B></A> - Interface in <A HREF="./org/apache/mina/filter/codec/demux/package-summary.html">org.apache.mina.filter.codec.demux</A><DD>A factory that creates a new instance of <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux"><CODE>MessageDecoder</CODE></A>.<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderResult.html" title="class in org.apache.mina.filter.codec.demux"><B>MessageDecoderResult</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/demux/package-summary.html">org.apache.mina.filter.codec.demux</A><DD>Represents results from <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux"><CODE>MessageDecoder</CODE></A>.<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageEncoder.html" title="interface in org.apache.mina.filter.codec.demux"><B>MessageEncoder</B></A> - Interface in <A HREF="./org/apache/mina/filter/codec/demux/package-summary.html">org.apache.mina.filter.codec.demux</A><DD>Encodes messages of specific types specified by <A HREF="./org/apache/mina/filter/codec/demux/MessageEncoder.html#getMessageTypes()"><CODE>MessageEncoder.getMessageTypes()</CODE></A>.<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageEncoderFactory.html" title="interface in org.apache.mina.filter.codec.demux"><B>MessageEncoderFactory</B></A> - Interface in <A HREF="./org/apache/mina/filter/codec/demux/package-summary.html">org.apache.mina.filter.codec.demux</A><DD>A factory that creates a new instance of <A HREF="./org/apache/mina/filter/codec/demux/MessageEncoder.html" title="interface in org.apache.mina.filter.codec.demux"><CODE>MessageEncoder</CODE></A>.<DT><A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><B>MessageHandler</B></A> - Interface in <A HREF="./org/apache/mina/handler/demux/package-summary.html">org.apache.mina.handler.demux</A><DD>A handler interface that <A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html" title="class in org.apache.mina.handler.demux"><CODE>DemuxingIoHandler</CODE></A> forwards
 <code>messageReceived</code> events to.<DT><A HREF="./org/apache/mina/common/IoFilter.html#messageReceived(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/common/IoHandler.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><CODE>IoHandler.messageReceived(IoSession,Object)</CODE></A>
 event.
<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoSession, Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common">IoFilter.NextFilter</A>
<DD>Forwards <tt>messageReceived</tt> event to next filter.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#messageReceived(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoHandler.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoSession, Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common">IoHandler</A>
<DD>Invoked when protocol message is received.
<DT><A HREF="./org/apache/mina/common/IoHandlerAdapter.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoSession, Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandlerAdapter.html" title="class in org.apache.mina.common">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#messageReceived(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#messageReceived(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#messageReceived(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#messageReceived(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#messageReceived(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#messageReceived(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#messageReceived(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/chain/ChainedIoHandler.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoSession, Object)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/ChainedIoHandler.html" title="class in org.apache.mina.handler.chain">ChainedIoHandler</A>
<DD>Handles the specified <tt>messageReceived</tt> event with the
 <A HREF="./org/apache/mina/handler/chain/IoHandlerCommand.html" title="interface in org.apache.mina.handler.chain"><CODE>IoHandlerCommand</CODE></A> or <A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain"><CODE>IoHandlerChain</CODE></A> you specified
 in the constructor.
<DT><A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoSession, Object)</B></A> - 
Method in class org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html" title="class in org.apache.mina.handler.demux">DemuxingIoHandler</A>
<DD>Forwards the received events into the appropriate <A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><CODE>MessageHandler</CODE></A>
 which is registered by <A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html#addMessageHandler(java.lang.Class, org.apache.mina.handler.demux.MessageHandler)"><CODE>DemuxingIoHandler.addMessageHandler(Class, MessageHandler)</CODE></A>.
<DT><A HREF="./org/apache/mina/handler/demux/MessageHandler.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoSession, Object)</B></A> - 
Method in interface org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux">MessageHandler</A>
<DD>Invoked when the specific type of message is received from the
 specified <code>session</code>.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#messageReceived(java.lang.Object)"><B>messageReceived(Object)</B></A> - 
Method in interface org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton">SingleSessionIoHandler</A>
<DD>Invoked when protocol message is received.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html#messageReceived(java.lang.Object)"><B>messageReceived(Object)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoSession, Object)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerDelegate</A>
<DD>Delegates the method call to the
 <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#messageReceived(java.lang.Object)"><CODE>SingleSessionIoHandler.messageReceived(Object)</CODE></A> method of the
 handler assigned to this session.
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageReceived(IoSession, Object)</B></A> - 
Method in class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>Forwards read data to input stream.
<DT><A HREF="./org/apache/mina/common/IoFilter.html#messageSent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/common/IoHandler.html#messageSent(org.apache.mina.common.IoSession, java.lang.Object)"><CODE>IoHandler.messageSent(IoSession,Object)</CODE></A>
 event.
<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html#messageSent(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoSession, Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common">IoFilter.NextFilter</A>
<DD>Forwards <tt>messageSent</tt> event to next filter.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#messageSent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoHandler.html#messageSent(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoSession, Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common">IoHandler</A>
<DD>Invoked when protocol message that user requested by
 <A HREF="./org/apache/mina/common/IoSession.html#write(java.lang.Object)"><CODE>IoSession.write(Object)</CODE></A> is sent out actually.
<DT><A HREF="./org/apache/mina/common/IoHandlerAdapter.html#messageSent(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoSession, Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandlerAdapter.html" title="class in org.apache.mina.common">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#messageSent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#messageSent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#messageSent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#messageSent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#messageSent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#messageSent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html#messageSent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter">StreamWriteFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#messageSent(java.lang.Object)"><B>messageSent(Object)</B></A> - 
Method in interface org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton">SingleSessionIoHandler</A>
<DD>Invoked when protocol message that user requested by
 <A HREF="./org/apache/mina/common/IoSession.html#write(java.lang.Object)"><CODE>IoSession.write(Object)</CODE></A> is sent out actually.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html#messageSent(java.lang.Object)"><B>messageSent(Object)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html#messageSent(org.apache.mina.common.IoSession, java.lang.Object)"><B>messageSent(IoSession, Object)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerDelegate</A>
<DD>Delegates the method call to the
 <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#messageSent(java.lang.Object)"><CODE>SingleSessionIoHandler.messageSent(Object)</CODE></A> method of the handler
 assigned to this session.
<DT><A HREF="./org/apache/mina/util/AvailablePortFinder.html#MIN_PORT_NUMBER"><B>MIN_PORT_NUMBER</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AvailablePortFinder.html" title="class in org.apache.mina.util">AvailablePortFinder</A>
<DD>The minimum number of server port number.
</DL>
<HR>
<A NAME="_N_"><!-- --></A><H2>
<B>N</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/NamePreservingRunnable.html" title="class in org.apache.mina.util"><B>NamePreservingRunnable</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A Runnable wrapper that preserves the name of the thread after the runnable is complete (for Runnables
 that change the name of the Thread they use)<DT><A HREF="./org/apache/mina/util/NamePreservingRunnable.html#NamePreservingRunnable(java.lang.Runnable)"><B>NamePreservingRunnable(Runnable)</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/NamePreservingRunnable.html" title="class in org.apache.mina.util">NamePreservingRunnable</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#NEED_DATA"><B>NEED_DATA</B></A> - 
Static variable in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux">MessageDecoder</A>
<DD>Represents a result from <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decodable(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(IoSession, ByteBuffer)</CODE></A> and
 <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderResult.html#NEED_DATA"><B>NEED_DATA</B></A> - 
Static variable in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderResult.html" title="class in org.apache.mina.filter.codec.demux">MessageDecoderResult</A>
<DD>Represents a result from <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decodable(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(IoSession, ByteBuffer)</CODE></A>
 and <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyCodecFactory.html" title="class in org.apache.mina.filter.codec.netty"><B>NettyCodecFactory</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/netty/package-summary.html">org.apache.mina.filter.codec.netty</A><DD>A MINA <tt>ProtocolCodecFactory</tt> that provides encoder and decoder
 for Netty2 <CODE>Message</CODE>s and <CODE>MessageRecognizer</CODE>s.<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyCodecFactory.html#NettyCodecFactory(MessageRecognizer)"><B>NettyCodecFactory(MessageRecognizer)</B></A> - 
Constructor for class org.apache.mina.filter.codec.netty.<A HREF="./org/apache/mina/filter/codec/netty/NettyCodecFactory.html" title="class in org.apache.mina.filter.codec.netty">NettyCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyDecoder.html" title="class in org.apache.mina.filter.codec.netty"><B>NettyDecoder</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/netty/package-summary.html">org.apache.mina.filter.codec.netty</A><DD>A MINA <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> that decodes byte buffers into
 Netty2 <CODE>Message</CODE>s using specified <CODE>MessageRecognizer</CODE>s.<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyDecoder.html#NettyDecoder(MessageRecognizer)"><B>NettyDecoder(MessageRecognizer)</B></A> - 
Constructor for class org.apache.mina.filter.codec.netty.<A HREF="./org/apache/mina/filter/codec/netty/NettyDecoder.html" title="class in org.apache.mina.filter.codec.netty">NettyDecoder</A>
<DD>Creates a new instance with the specified <CODE>MessageRecognizer</CODE>.
<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyEncoder.html" title="class in org.apache.mina.filter.codec.netty"><B>NettyEncoder</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/netty/package-summary.html">org.apache.mina.filter.codec.netty</A><DD>A MINA <tt>ProtocolEncoder</tt> that encodes Netty2 <CODE>Message</CODE>s
 into byte buffers.<DT><A HREF="./org/apache/mina/filter/codec/netty/NettyEncoder.html#NettyEncoder()"><B>NettyEncoder()</B></A> - 
Constructor for class org.apache.mina.filter.codec.netty.<A HREF="./org/apache/mina/filter/codec/netty/NettyEncoder.html" title="class in org.apache.mina.filter.codec.netty">NettyEncoder</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/common/IoAcceptor.html#newSession(java.net.SocketAddress, java.net.SocketAddress)"><B>newSession(SocketAddress, SocketAddress)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common">IoAcceptor</A>
<DD>(Optional) Returns an <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> that is bound to the specified
 <tt>localAddress</tt> and <tt>remoteAddress</tt> which reuses
 the <tt>localAddress</tt> that is already bound by <A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common"><CODE>IoAcceptor</CODE></A>
 via <A HREF="./org/apache/mina/common/IoAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.common.IoHandler)"><CODE>IoAcceptor.bind(SocketAddress, IoHandler)</CODE></A>.
<DT><A HREF="./org/apache/mina/util/NewThreadExecutor.html" title="class in org.apache.mina.util"><B>NewThreadExecutor</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>An Executor that just launches in a new thread.<DT><A HREF="./org/apache/mina/util/NewThreadExecutor.html#NewThreadExecutor()"><B>NewThreadExecutor()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/NewThreadExecutor.html" title="class in org.apache.mina.util">NewThreadExecutor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#NONE"><B>NONE</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>This mask suspends both reads and writes.
<DT><A HREF="./org/apache/mina/common/IoFilterChainBuilder.html#NOOP"><B>NOOP</B></A> - 
Static variable in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChainBuilder.html" title="interface in org.apache.mina.common">IoFilterChainBuilder</A>
<DD>An implementation which does nothing.
<DT><A HREF="./org/apache/mina/common/IoSessionRecycler.html#NOOP"><B>NOOP</B></A> - 
Static variable in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSessionRecycler.html" title="interface in org.apache.mina.common">IoSessionRecycler</A>
<DD>A dummy recycler that doesn't recycle any sessions.
<DT><A HREF="./org/apache/mina/handler/demux/MessageHandler.html#NOOP"><B>NOOP</B></A> - 
Static variable in interface org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux">MessageHandler</A>
<DD>A <A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><CODE>MessageHandler</CODE></A> that does nothing.
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#not()"><B>not()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>Returns a negated mask of this one.
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#NOT_OK"><B>NOT_OK</B></A> - 
Static variable in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux">MessageDecoder</A>
<DD>Represents a result from <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decodable(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(IoSession, ByteBuffer)</CODE></A> and
 <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderResult.html#NOT_OK"><B>NOT_OK</B></A> - 
Static variable in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderResult.html" title="class in org.apache.mina.filter.codec.demux">MessageDecoderResult</A>
<DD>Represents a result from <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decodable(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(IoSession, ByteBuffer)</CODE></A>
 and <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
</DL>
<HR>
<A NAME="_O_"><!-- --></A><H2>
<B>O</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html" title="class in org.apache.mina.filter.codec.serialization"><B>ObjectSerializationCodecFactory</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/serialization/package-summary.html">org.apache.mina.filter.codec.serialization</A><DD>A <A HREF="./org/apache/mina/filter/codec/ProtocolCodecFactory.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolCodecFactory</CODE></A> that serializes and deserializes Java objects.<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html#ObjectSerializationCodecFactory()"><B>ObjectSerializationCodecFactory()</B></A> - 
Constructor for class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationCodecFactory</A>
<DD>Creates a new instance with the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ClassLoader.html" title="class or interface in java.lang"><CODE>ClassLoader</CODE></A> of
 the current thread.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html#ObjectSerializationCodecFactory(java.lang.ClassLoader)"><B>ObjectSerializationCodecFactory(ClassLoader)</B></A> - 
Constructor for class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationCodecFactory</A>
<DD>Creates a new instance with the specified <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ClassLoader.html" title="class or interface in java.lang"><CODE>ClassLoader</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html" title="class in org.apache.mina.filter.codec.serialization"><B>ObjectSerializationDecoder</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/serialization/package-summary.html">org.apache.mina.filter.codec.serialization</A><DD>A <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> which deserializes <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html" title="class or interface in java.io"><CODE>Serializable</CODE></A> Java
 objects using <A HREF="./org/apache/mina/common/ByteBuffer.html#getObject(java.lang.ClassLoader)"><CODE>ByteBuffer.getObject(ClassLoader)</CODE></A>.<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html#ObjectSerializationDecoder()"><B>ObjectSerializationDecoder()</B></A> - 
Constructor for class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationDecoder</A>
<DD>Creates a new instance with the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ClassLoader.html" title="class or interface in java.lang"><CODE>ClassLoader</CODE></A> of
 the current thread.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html#ObjectSerializationDecoder(java.lang.ClassLoader)"><B>ObjectSerializationDecoder(ClassLoader)</B></A> - 
Constructor for class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationDecoder</A>
<DD>Creates a new instance with the specified <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ClassLoader.html" title="class or interface in java.lang"><CODE>ClassLoader</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html" title="class in org.apache.mina.filter.codec.serialization"><B>ObjectSerializationEncoder</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/serialization/package-summary.html">org.apache.mina.filter.codec.serialization</A><DD>A <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A> which serializes <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html" title="class or interface in java.io"><CODE>Serializable</CODE></A> Java objects
 using <A HREF="./org/apache/mina/common/ByteBuffer.html#putObject(java.lang.Object)"><CODE>ByteBuffer.putObject(Object)</CODE></A>.<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html#ObjectSerializationEncoder()"><B>ObjectSerializationEncoder()</B></A> - 
Constructor for class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationEncoder</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization"><B>ObjectSerializationInputStream</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/serialization/package-summary.html">org.apache.mina.filter.codec.serialization</A><DD>An <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/ObjectInput.html" title="class or interface in java.io"><CODE>ObjectInput</CODE></A> and <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/InputStream.html" title="class or interface in java.io"><CODE>InputStream</CODE></A> that can read the objects encoded
 by <A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html" title="class in org.apache.mina.filter.codec.serialization"><CODE>ObjectSerializationEncoder</CODE></A>.<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#ObjectSerializationInputStream(java.io.InputStream)"><B>ObjectSerializationInputStream(InputStream)</B></A> - 
Constructor for class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#ObjectSerializationInputStream(java.io.InputStream, java.lang.ClassLoader)"><B>ObjectSerializationInputStream(InputStream, ClassLoader)</B></A> - 
Constructor for class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization"><B>ObjectSerializationOutputStream</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/serialization/package-summary.html">org.apache.mina.filter.codec.serialization</A><DD>An <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/ObjectOutput.html" title="class or interface in java.io"><CODE>ObjectOutput</CODE></A> and <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/OutputStream.html" title="class or interface in java.io"><CODE>OutputStream</CODE></A> that can write the objects as
 the serialized form that <A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html" title="class in org.apache.mina.filter.codec.serialization"><CODE>ObjectSerializationDecoder</CODE></A> can decode.<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#ObjectSerializationOutputStream(java.io.OutputStream)"><B>ObjectSerializationOutputStream(OutputStream)</B></A> - 
Constructor for class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#offer(java.lang.Object)"><B>offer(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#offer(java.lang.Object)"><B>offer(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#OK"><B>OK</B></A> - 
Static variable in interface org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html" title="interface in org.apache.mina.filter.codec.demux">MessageDecoder</A>
<DD>Represents a result from <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decodable(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(IoSession, ByteBuffer)</CODE></A> and
 <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderResult.html#OK"><B>OK</B></A> - 
Static variable in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderResult.html" title="class in org.apache.mina.filter.codec.demux">MessageDecoderResult</A>
<DD>Represents a result from <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decodable(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(IoSession, ByteBuffer)</CODE></A>
 and <A HREF="./org/apache/mina/filter/codec/demux/MessageDecoder.html#decode(org.apache.mina.common.IoSession, org.apache.mina.common.ByteBuffer, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(IoSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/common/IoFilter.html#onPostAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPostAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Invoked after this filter is added to the specified <tt>parent</tt>.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#onPostAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPostAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#onPostAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPostAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#onPostAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPostAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.html#onPostRemove(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPostRemove(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Invoked after this filter is removed from the specified <tt>parent</tt>.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#onPostRemove(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPostRemove(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#onPostRemove(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPostRemove(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#onPostRemove(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPostRemove(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.html#onPreAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Invoked before this filter is added to the specified <tt>parent</tt>.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#onPreAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#onPreAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#onPreAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#onPreAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#onPreAdd(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreAdd(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.html#onPreRemove(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreRemove(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Invoked before this filter is removed from the specified <tt>parent</tt>.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#onPreRemove(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreRemove(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#onPreRemove(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreRemove(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#onPreRemove(org.apache.mina.common.IoFilterChain, java.lang.String, org.apache.mina.common.IoFilter.NextFilter)"><B>onPreRemove(IoFilterChain, String, IoFilter.NextFilter)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html#OPENED"><B>OPENED</B></A> - 
Static variable in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFutureListener.html#operationComplete(org.apache.mina.common.IoFuture)"><B>operationComplete(IoFuture)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFutureListener.html" title="interface in org.apache.mina.common">IoFutureListener</A>
<DD>Invoked when the operation associated with the <A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common"><CODE>IoFuture</CODE></A>
 has been completed.
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#or(org.apache.mina.common.TrafficMask)"><B>or(TrafficMask)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>Peforms an <tt>OR</tt> operation on this mask with the specified
 <tt>mask</tt> and returns the result.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#order()"><B>order()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#order(java.nio.ByteOrder)"><B>order(ByteOrder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#order()"><B>order()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#order(java.nio.ByteOrder)"><B>order(ByteOrder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/package-summary.html"><B>org.apache.mina.common</B></A> - package org.apache.mina.common<DD>Common types required for users to use MINA.<DT><A HREF="./org/apache/mina/filter/package-summary.html"><B>org.apache.mina.filter</B></A> - package org.apache.mina.filter<DD>Useful <tt>IoFilter</tt> implementations.<DT><A HREF="./org/apache/mina/filter/codec/package-summary.html"><B>org.apache.mina.filter.codec</B></A> - package org.apache.mina.filter.codec<DD>Filter implementations that helps you to implement complex protocols
via 'codec' concept.<DT><A HREF="./org/apache/mina/filter/codec/demux/package-summary.html"><B>org.apache.mina.filter.codec.demux</B></A> - package org.apache.mina.filter.codec.demux<DD>Protocol codecs that helps you to implement even more complex protocols by
splitting a codec into multiple sub-codecs.<DT><A HREF="./org/apache/mina/filter/codec/netty/package-summary.html"><B>org.apache.mina.filter.codec.netty</B></A> - package org.apache.mina.filter.codec.netty<DD>Protocol codec which provides the integration with <a href="http://gleamynode.net/dev/tl-netty2/docs/">Netty2</a> messages.<DT><A HREF="./org/apache/mina/filter/codec/serialization/package-summary.html"><B>org.apache.mina.filter.codec.serialization</B></A> - package org.apache.mina.filter.codec.serialization<DD>Protocol codecs which uses Java object serilization and leads to rapid protocol
implementation.<DT><A HREF="./org/apache/mina/filter/codec/textline/package-summary.html"><B>org.apache.mina.filter.codec.textline</B></A> - package org.apache.mina.filter.codec.textline<DD>A protocol codec for text-based protocols.<DT><A HREF="./org/apache/mina/filter/executor/package-summary.html"><B>org.apache.mina.filter.executor</B></A> - package org.apache.mina.filter.executor<DD>An <tt>IoFilter</tt> that provides flexible thread models<DT><A HREF="./org/apache/mina/handler/package-summary.html"><B>org.apache.mina.handler</B></A> - package org.apache.mina.handler<DD>Useful <tt>IoHandler</tt> implementations.<DT><A HREF="./org/apache/mina/handler/chain/package-summary.html"><B>org.apache.mina.handler.chain</B></A> - package org.apache.mina.handler.chain<DD>A handler implementation that helps you implement sequentially layered protocols
using Chains of Responsibility pattern.<DT><A HREF="./org/apache/mina/handler/demux/package-summary.html"><B>org.apache.mina.handler.demux</B></A> - package org.apache.mina.handler.demux<DD>A handler implementation that helps you implement complex protocols
by splitting <tt>messageReceived</tt> handlers into multiple sub-handlers.<DT><A HREF="./org/apache/mina/handler/multiton/package-summary.html"><B>org.apache.mina.handler.multiton</B></A> - package org.apache.mina.handler.multiton<DD>Enables creating a handler per session instead of having one handler for many
sessions, using
<a href="http://en.wikipedia.org/wiki/Multiton_pattern">Multiton pattern</a>.<DT><A HREF="./org/apache/mina/integration/jmx/package-summary.html"><B>org.apache.mina.integration.jmx</B></A> - package org.apache.mina.integration.jmx<DD>JMX (Java Management eXtension) integration<DT><A HREF="./org/apache/mina/integration/spring/package-summary.html"><B>org.apache.mina.integration.spring</B></A> - package org.apache.mina.integration.spring<DD><a href="http://www.springframework.org/">SpringFramework</a>-specific classes
for integration<DT><A HREF="./org/apache/mina/integration/spring/ssl/package-summary.html"><B>org.apache.mina.integration.spring.ssl</B></A> - package org.apache.mina.integration.spring.ssl<DD><a href="http://www.springframework.org/">SpringFramework</a>-specific classes
for SSL integration<DT><A HREF="./org/apache/mina/management/package-summary.html"><B>org.apache.mina.management</B></A> - package org.apache.mina.management<DD>Utilities that manage and monitor a MINA application.<DT><A HREF="./org/apache/mina/transport/socket/nio/package-summary.html"><B>org.apache.mina.transport.socket.nio</B></A> - package org.apache.mina.transport.socket.nio<DD>Socket (TCP/IP) and Datagram (UDP/IP) support based on Java
<a href="http://java.sun.com/j2se/1.5.0/docs/guide/nio/">NIO (New I/O) API</a>.<DT><A HREF="./org/apache/mina/transport/vmpipe/package-summary.html"><B>org.apache.mina.transport.vmpipe</B></A> - package org.apache.mina.transport.vmpipe<DD>In-VM pipe support which removes the overhead of local loopback communication.<DT><A HREF="./org/apache/mina/util/package-summary.html"><B>org.apache.mina.util</B></A> - package org.apache.mina.util<DD>Miscellaneous utility classes</DL>
<HR>
<A NAME="_P_"><!-- --></A><H2>
<B>P</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#peek()"><B>peek()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#peek()"><B>peek()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#poll()"><B>poll()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#poll()"><B>poll()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html" title="class in org.apache.mina.common"><B>PooledByteBufferAllocator</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A <A HREF="./org/apache/mina/common/ByteBufferAllocator.html" title="interface in org.apache.mina.common"><CODE>ByteBufferAllocator</CODE></A> which pools allocated buffers.<DT><A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html#PooledByteBufferAllocator()"><B>PooledByteBufferAllocator()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html" title="class in org.apache.mina.common">PooledByteBufferAllocator</A>
<DD>Creates a new instance with the default timeout.
<DT><A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html#PooledByteBufferAllocator(int)"><B>PooledByteBufferAllocator(int)</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html" title="class in org.apache.mina.common">PooledByteBufferAllocator</A>
<DD>Creates a new instance with the specified <tt>timeout</tt>.
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#pop()"><B>pop()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#pop()"><B>pop()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>Pops from this stack.
<DT><A HREF="./org/apache/mina/util/Queue.html#pop()"><B>pop()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Dequeues from this queue.
<DT><A HREF="./org/apache/mina/util/Stack.html#pop()"><B>pop()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util">Stack</A>
<DD>Pops from this stack.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#position()"><B>position()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#position(int)"><B>position(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#position()"><B>position()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#position(int)"><B>position(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#PREFIX"><B>PREFIX</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>Session attribute key: prefix string
<DT><A HREF="./org/apache/mina/util/SessionLog.html#PREFIX"><B>PREFIX</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>Session attribute key: prefix string
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#prefixedDataAvailable(int)"><B>prefixedDataAvailable(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns <tt>true</tt> if this buffer contains a data which has a data
 length as a prefix and the buffer has remaining data as enough as
 specified in the data length field.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#prefixedDataAvailable(int, int)"><B>prefixedDataAvailable(int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Returns <tt>true</tt> if this buffer contains a data which has a data
 length as a prefix and the buffer has remaining data as enough as
 specified in the data length field.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#processEvent(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.filter.executor.ExecutorFilter.EventType, java.lang.Object)"><B>processEvent(IoFilter.NextFilter, IoSession, ExecutorFilter.EventType, Object)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#processStreamIo(org.apache.mina.common.IoSession, java.io.InputStream, java.io.OutputStream)"><B>processStreamIo(IoSession, InputStream, OutputStream)</B></A> - 
Method in class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>Implement this method to execute your stream I/O logic;
 <b>please note that you must forward the process request to other
 thread or thread pool.</b>
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecException.html" title="class in org.apache.mina.filter.codec"><B>ProtocolCodecException</B></A> - Exception in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>An exception that is thrown when <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A> or
 <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> cannot understand or failed to validate
 data to process.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecException.html#ProtocolCodecException()"><B>ProtocolCodecException()</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecException.html" title="class in org.apache.mina.filter.codec">ProtocolCodecException</A>
<DD>Constructs a new instance.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecException.html#ProtocolCodecException(java.lang.String)"><B>ProtocolCodecException(String)</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecException.html" title="class in org.apache.mina.filter.codec">ProtocolCodecException</A>
<DD>Constructs a new instance with the specified message.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecException.html#ProtocolCodecException(java.lang.Throwable)"><B>ProtocolCodecException(Throwable)</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecException.html" title="class in org.apache.mina.filter.codec">ProtocolCodecException</A>
<DD>Constructs a new instance with the specified cause.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecException.html#ProtocolCodecException(java.lang.String, java.lang.Throwable)"><B>ProtocolCodecException(String, Throwable)</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecException.html" title="class in org.apache.mina.filter.codec">ProtocolCodecException</A>
<DD>Constructs a new instance with the specified message and the specified
 cause.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFactory.html" title="interface in org.apache.mina.filter.codec"><B>ProtocolCodecFactory</B></A> - Interface in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>Provides <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A> and <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> which translates
 binary or protocol specific data into message object and vice versa.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec"><B>ProtocolCodecFilter</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>An <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A> which translates binary or protocol specific data into
 message object and vice versa using <A HREF="./org/apache/mina/filter/codec/ProtocolCodecFactory.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolCodecFactory</CODE></A>,
 <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A>, or <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A>.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#ProtocolCodecFilter(org.apache.mina.filter.codec.ProtocolCodecFactory)"><B>ProtocolCodecFilter(ProtocolCodecFactory)</B></A> - 
Constructor for class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#ProtocolCodecFilter(org.apache.mina.filter.codec.ProtocolEncoder, org.apache.mina.filter.codec.ProtocolDecoder)"><B>ProtocolCodecFilter(ProtocolEncoder, ProtocolDecoder)</B></A> - 
Constructor for class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#ProtocolCodecFilter(java.lang.Class, java.lang.Class)"><B>ProtocolCodecFilter(Class, Class)</B></A> - 
Constructor for class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><B>ProtocolDecoder</B></A> - Interface in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>Decodes binary or protocol-specific data into higher-level message objects.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderAdapter.html" title="class in org.apache.mina.filter.codec"><B>ProtocolDecoderAdapter</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>An abstract <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> implementation for those who don't need
 <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html#finishDecode(org.apache.mina.common.IoSession, org.apache.mina.filter.codec.ProtocolDecoderOutput)"><CODE>ProtocolDecoder.finishDecode(IoSession, ProtocolDecoderOutput)</CODE></A> nor
 <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html#dispose(org.apache.mina.common.IoSession)"><CODE>ProtocolDecoder.dispose(IoSession)</CODE></A> method.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderAdapter.html#ProtocolDecoderAdapter()"><B>ProtocolDecoderAdapter()</B></A> - 
Constructor for class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderAdapter.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html" title="class in org.apache.mina.filter.codec"><B>ProtocolDecoderException</B></A> - Exception in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>An exception that is thrown when <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A>
 cannot understand or failed to validate the specified <A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common"><CODE>ByteBuffer</CODE></A>
 content.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html#ProtocolDecoderException()"><B>ProtocolDecoderException()</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderException</A>
<DD>Constructs a new instance.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html#ProtocolDecoderException(java.lang.String)"><B>ProtocolDecoderException(String)</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderException</A>
<DD>Constructs a new instance with the specified message.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html#ProtocolDecoderException(java.lang.Throwable)"><B>ProtocolDecoderException(Throwable)</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderException</A>
<DD>Constructs a new instance with the specified cause.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html#ProtocolDecoderException(java.lang.String, java.lang.Throwable)"><B>ProtocolDecoderException(String, Throwable)</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderException</A>
<DD>Constructs a new instance with the specified message and the specified
 cause.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderOutput.html" title="interface in org.apache.mina.filter.codec"><B>ProtocolDecoderOutput</B></A> - Interface in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>Callback for <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> to generate decoded messages.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><B>ProtocolEncoder</B></A> - Interface in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>Encodes higher-level message objects into binary or protocol-specific data.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderAdapter.html" title="class in org.apache.mina.filter.codec"><B>ProtocolEncoderAdapter</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>An abstract <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A> implementation for those who don't have any
 resources to dispose.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderAdapter.html#ProtocolEncoderAdapter()"><B>ProtocolEncoderAdapter()</B></A> - 
Constructor for class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoderAdapter.html" title="class in org.apache.mina.filter.codec">ProtocolEncoderAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderException.html" title="class in org.apache.mina.filter.codec"><B>ProtocolEncoderException</B></A> - Exception in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>An exception that is thrown when <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A>
 cannot understand or failed to validate the specified message object.<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderException.html#ProtocolEncoderException()"><B>ProtocolEncoderException()</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoderException.html" title="class in org.apache.mina.filter.codec">ProtocolEncoderException</A>
<DD>Constructs a new instance.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderException.html#ProtocolEncoderException(java.lang.String)"><B>ProtocolEncoderException(String)</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoderException.html" title="class in org.apache.mina.filter.codec">ProtocolEncoderException</A>
<DD>Constructs a new instance with the specified message.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderException.html#ProtocolEncoderException(java.lang.Throwable)"><B>ProtocolEncoderException(Throwable)</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoderException.html" title="class in org.apache.mina.filter.codec">ProtocolEncoderException</A>
<DD>Constructs a new instance with the specified cause.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderException.html#ProtocolEncoderException(java.lang.String, java.lang.Throwable)"><B>ProtocolEncoderException(String, Throwable)</B></A> - 
Constructor for exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoderException.html" title="class in org.apache.mina.filter.codec">ProtocolEncoderException</A>
<DD>Constructs a new instance with the specified message and the specified
 cause.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderOutput.html" title="interface in org.apache.mina.filter.codec"><B>ProtocolEncoderOutput</B></A> - Interface in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>Callback for <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A> to generate encoded <A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common"><CODE>ByteBuffer</CODE></A>s.<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#push(java.lang.Object)"><B>push(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#push(java.lang.Object)"><B>push(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>Push into this stack.
<DT><A HREF="./org/apache/mina/util/Queue.html#push(java.lang.Object)"><B>push(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Enqueue into this queue.
<DT><A HREF="./org/apache/mina/util/Stack.html#push(java.lang.Object)"><B>push(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util">Stack</A>
<DD>Push into this stack.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#put(byte)"><B>put(byte)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#put(int, byte)"><B>put(int, byte)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#put(java.nio.ByteBuffer)"><B>put(ByteBuffer)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Writes the content of the specified <tt>src</tt> into this buffer.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#put(org.apache.mina.common.ByteBuffer)"><B>put(ByteBuffer)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Writes the content of the specified <tt>src</tt> into this buffer.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#put(byte[], int, int)"><B>put(byte[], int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#put(byte[])"><B>put(byte[])</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#put(byte)"><B>put(byte)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#put(int, byte)"><B>put(int, byte)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#put(org.apache.mina.common.ByteBuffer)"><B>put(ByteBuffer)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#put(java.nio.ByteBuffer)"><B>put(ByteBuffer)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#put(byte[], int, int)"><B>put(byte[], int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#put(byte[])"><B>put(byte[])</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#put(org.apache.mina.common.IoSession)"><B>put(IoSession)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSessionRecycler.html#put(org.apache.mina.common.IoSession)"><B>put(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSessionRecycler.html" title="interface in org.apache.mina.common">IoSessionRecycler</A>
<DD>Called when the underlying transport creates or writes a new <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>.
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#put(java.lang.Object, java.lang.Object)"><B>put(Object, Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#putAll(java.util.Map)"><B>putAll(Map)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putChar(char)"><B>putChar(char)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putChar(int, char)"><B>putChar(int, char)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putChar(char)"><B>putChar(char)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putChar(int, char)"><B>putChar(int, char)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putDouble(double)"><B>putDouble(double)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putDouble(int, double)"><B>putDouble(int, double)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putDouble(double)"><B>putDouble(double)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putDouble(int, double)"><B>putDouble(int, double)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putFloat(float)"><B>putFloat(float)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putFloat(int, float)"><B>putFloat(int, float)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putFloat(float)"><B>putFloat(float)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putFloat(int, float)"><B>putFloat(int, float)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putInt(int)"><B>putInt(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putInt(int, int)"><B>putInt(int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putInt(int)"><B>putInt(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putInt(int, int)"><B>putInt(int, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putLong(long)"><B>putLong(long)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putLong(int, long)"><B>putLong(int, long)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putLong(long)"><B>putLong(long)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putLong(int, long)"><B>putLong(int, long)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putObject(java.lang.Object)"><B>putObject(Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Writes the specified Java object to the buffer.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putObject(java.lang.Object)"><B>putObject(Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putPrefixedString(java.lang.CharSequence, java.nio.charset.CharsetEncoder)"><B>putPrefixedString(CharSequence, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Writes the content of <code>in</code> into this buffer as a
 string which has a 16-bit length field before the actual
 encoded string, using the specified <code>encoder</code>.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putPrefixedString(java.lang.CharSequence, int, java.nio.charset.CharsetEncoder)"><B>putPrefixedString(CharSequence, int, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Writes the content of <code>in</code> into this buffer as a
 string which has a 16-bit length field before the actual
 encoded string, using the specified <code>encoder</code>.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putPrefixedString(java.lang.CharSequence, int, int, java.nio.charset.CharsetEncoder)"><B>putPrefixedString(CharSequence, int, int, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Writes the content of <code>in</code> into this buffer as a
 string which has a 16-bit length field before the actual
 encoded string, using the specified <code>encoder</code>.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putPrefixedString(java.lang.CharSequence, int, int, byte, java.nio.charset.CharsetEncoder)"><B>putPrefixedString(CharSequence, int, int, byte, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Writes the content of <code>in</code> into this buffer as a
 string which has a 16-bit length field before the actual
 encoded string, using the specified <code>encoder</code>.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putPrefixedString(java.lang.CharSequence, java.nio.charset.CharsetEncoder)"><B>putPrefixedString(CharSequence, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putPrefixedString(java.lang.CharSequence, int, java.nio.charset.CharsetEncoder)"><B>putPrefixedString(CharSequence, int, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putPrefixedString(java.lang.CharSequence, int, int, java.nio.charset.CharsetEncoder)"><B>putPrefixedString(CharSequence, int, int, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putPrefixedString(java.lang.CharSequence, int, int, byte, java.nio.charset.CharsetEncoder)"><B>putPrefixedString(CharSequence, int, int, byte, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putShort(short)"><B>putShort(short)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putShort(int, short)"><B>putShort(int, short)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putShort(short)"><B>putShort(short)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putShort(int, short)"><B>putShort(int, short)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putString(java.lang.CharSequence, java.nio.charset.CharsetEncoder)"><B>putString(CharSequence, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Writes the content of <code>in</code> into this buffer using the
 specified <code>encoder</code>.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#putString(java.lang.CharSequence, int, java.nio.charset.CharsetEncoder)"><B>putString(CharSequence, int, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Writes the content of <code>in</code> into this buffer as a
 <code>NUL</code>-terminated string using the specified
 <code>encoder</code>.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putString(java.lang.CharSequence, int, java.nio.charset.CharsetEncoder)"><B>putString(CharSequence, int, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#putString(java.lang.CharSequence, java.nio.charset.CharsetEncoder)"><B>putString(CharSequence, CharsetEncoder)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_Q_"><!-- --></A><H2>
<B>Q</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util"><B>Queue</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A unbounded circular queue.<DT><A HREF="./org/apache/mina/util/Queue.html#Queue()"><B>Queue()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Construct a new, empty queue.
</DL>
<HR>
<A NAME="_R_"><!-- --></A><H2>
<B>R</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#READ"><B>READ</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>This mask suspends writes, and resumes reads if reads were suspended.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#read()"><B>read()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html#READ"><B>READ</B></A> - 
Static variable in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readBoolean()"><B>readBoolean()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readByte()"><B>readByte()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readChar()"><B>readChar()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readDouble()"><B>readDouble()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IdleStatus.html#READER_IDLE"><B>READER_IDLE</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IdleStatus.html" title="class in org.apache.mina.common">IdleStatus</A>
<DD>Represents the session status that no data is coming from the remote
 peer.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readFloat()"><B>readFloat()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readFully(byte[])"><B>readFully(byte[])</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readFully(byte[], int, int)"><B>readFully(byte[], int, int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readInt()"><B>readInt()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readLine()"><B>readLine()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD><B>Deprecated.</B>&nbsp;<I></I>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readLong()"><B>readLong()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readObject()"><B>readObject()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readShort()"><B>readShort()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html" title="class in org.apache.mina.filter"><B>ReadThrottleFilterBuilder</B></A> - Class in <A HREF="./org/apache/mina/filter/package-summary.html">org.apache.mina.filter</A><DD>This filter will automatically disable reads on an <code>IoSession</code> once the data
 batched for that session in the <A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor"><CODE>ExecutorFilter</CODE></A> reaches a defined threshold (the
 default is 1 megabytes).<DT><A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html#ReadThrottleFilterBuilder()"><B>ReadThrottleFilterBuilder()</B></A> - 
Constructor for class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html" title="class in org.apache.mina.filter">ReadThrottleFilterBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readUnsignedByte()"><B>readUnsignedByte()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readUnsignedShort()"><B>readUnsignedShort()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#readUTF()"><B>readUTF()</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html#RECEIVED"><B>RECEIVED</B></A> - 
Static variable in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#recycle(java.net.SocketAddress, java.net.SocketAddress)"><B>recycle(SocketAddress, SocketAddress)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSessionRecycler.html#recycle(java.net.SocketAddress, java.net.SocketAddress)"><B>recycle(SocketAddress, SocketAddress)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSessionRecycler.html" title="interface in org.apache.mina.common">IoSessionRecycler</A>
<DD>Attempts to retrieve a recycled <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter"><B>ReferenceCountingIoFilter</B></A> - Class in <A HREF="./org/apache/mina/filter/package-summary.html">org.apache.mina.filter</A><DD>An <A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common"><CODE>IoFilter</CODE></A>s wrapper that keeps track of the number of usages of this filter and will call init/destroy
 when the filter is not in use.<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#ReferenceCountingIoFilter(org.apache.mina.common.IoFilter)"><B>ReferenceCountingIoFilter(IoFilter)</B></A> - 
Constructor for class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html#register(java.lang.Class)"><B>register(Class)</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html#register(org.apache.mina.filter.codec.demux.MessageEncoder)"><B>register(MessageEncoder)</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html#register(org.apache.mina.filter.codec.demux.MessageEncoderFactory)"><B>register(MessageEncoderFactory)</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html#register(org.apache.mina.filter.codec.demux.MessageDecoder)"><B>register(MessageDecoder)</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html#register(org.apache.mina.filter.codec.demux.MessageDecoderFactory)"><B>register(MessageDecoderFactory)</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.filter.codec.demux">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#release()"><B>release()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Releases the specified buffer to buffer pool.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#release()"><B>release()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ByteBufferUtil.html#releaseIfPossible(java.lang.Object)"><B>releaseIfPossible(Object)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ByteBufferUtil.html" title="class in org.apache.mina.util">ByteBufferUtil</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#remaining()"><B>remaining()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#remaining()"><B>remaining()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#remove(java.lang.String)"><B>remove(String)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#remove(org.apache.mina.common.IoSession)"><B>remove(IoSession)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilterChain.html#remove(java.lang.String)"><B>remove(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common">IoFilterChain</A>
<DD>Removes the filter with the specified name from this chain.
<DT><A HREF="./org/apache/mina/common/IoSessionRecycler.html#remove(org.apache.mina.common.IoSession)"><B>remove(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSessionRecycler.html" title="interface in org.apache.mina.common">IoSessionRecycler</A>
<DD>Called when an <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> is explicitly closed.
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#remove(java.lang.String)"><B>remove(String)</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#remove(int)"><B>remove(int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#remove(java.lang.Object)"><B>remove(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#remove()"><B>remove()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#remove(java.lang.Object)"><B>remove(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#remove(java.lang.Object)"><B>remove(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/IdentityHashSet.html#remove(java.lang.Object)"><B>remove(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/IdentityHashSet.html" title="class in org.apache.mina.util">IdentityHashSet</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#remove(int)"><B>remove(int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#remove()"><B>remove()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Stack.html#remove(java.lang.Object)"><B>remove(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util">Stack</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#removeAll(java.util.Collection)"><B>removeAll(Collection)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#removeAttribute(java.lang.String)"><B>removeAttribute(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Removes a user-defined attribute with the specified key.
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#removeExpirationListener(org.apache.mina.util.ExpirationListener)"><B>removeExpirationListener(ExpirationListener)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#removeFirstLoggingFilter()"><B>removeFirstLoggingFilter()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#removeFirstLoggingFilter()"><B>removeFirstLoggingFilter()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>remove the logging filter at begining of the chain
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html#removeLastLoggingFilter()"><B>removeLastLoggingFilter()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManager.html" title="class in org.apache.mina.integration.jmx">IoSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html#removeLastLoggingFilter()"><B>removeLastLoggingFilter()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoSessionManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoSessionManagerMBean</A>
<DD>remove the logging filter at end of the chain
<DT><A HREF="./org/apache/mina/common/IoFuture.html#removeListener(org.apache.mina.common.IoFutureListener)"><B>removeListener(IoFutureListener)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common">IoFuture</A>
<DD>Removes an existing event <tt>listener</tt> which is notified when
 the state of this future changes.
<DT><A HREF="./org/apache/mina/common/IoService.html#removeListener(org.apache.mina.common.IoServiceListener)"><B>removeListener(IoServiceListener)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common">IoService</A>
<DD>Removed an existing <A HREF="./org/apache/mina/common/IoServiceListener.html" title="interface in org.apache.mina.common"><CODE>IoServiceListener</CODE></A> that listens any events
 related with this service.
<DT><A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html#removeMessageHandler(java.lang.Class)"><B>removeMessageHandler(Class)</B></A> - 
Method in class org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html" title="class in org.apache.mina.handler.demux">DemuxingIoHandler</A>
<DD>Deregisters a <A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><CODE>MessageHandler</CODE></A> that receives the messages of
 the specified <code>type</code>.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#reset()"><B>reset()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#reset()"><B>reset()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#resumeRead()"><B>resumeRead()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>A shortcut method for <A HREF="./org/apache/mina/common/IoSession.html#setTrafficMask(org.apache.mina.common.TrafficMask)"><CODE>IoSession.setTrafficMask(TrafficMask)</CODE></A> that
 resumes read operations for this session.
<DT><A HREF="./org/apache/mina/common/IoSession.html#resumeWrite()"><B>resumeWrite()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>A shortcut method for <A HREF="./org/apache/mina/common/IoSession.html#setTrafficMask(org.apache.mina.common.TrafficMask)"><CODE>IoSession.setTrafficMask(TrafficMask)</CODE></A> that
 resumes write operations for this session.
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#retainAll(java.util.Collection)"><B>retainAll(Collection)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#rewind()"><B>rewind()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#rewind()"><B>rewind()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#run()"><B>run()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/NamePreservingRunnable.html#run()"><B>run()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/NamePreservingRunnable.html" title="class in org.apache.mina.util">NamePreservingRunnable</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/RuntimeIOException.html" title="class in org.apache.mina.common"><B>RuntimeIOException</B></A> - Exception in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A unchecked version of <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/IOException.html" title="class or interface in java.io"><CODE>IOException</CODE></A>.<DT><A HREF="./org/apache/mina/common/RuntimeIOException.html#RuntimeIOException()"><B>RuntimeIOException()</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/RuntimeIOException.html" title="class in org.apache.mina.common">RuntimeIOException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/RuntimeIOException.html#RuntimeIOException(java.lang.String)"><B>RuntimeIOException(String)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/RuntimeIOException.html" title="class in org.apache.mina.common">RuntimeIOException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/RuntimeIOException.html#RuntimeIOException(java.lang.String, java.lang.Throwable)"><B>RuntimeIOException(String, Throwable)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/RuntimeIOException.html" title="class in org.apache.mina.common">RuntimeIOException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/RuntimeIOException.html#RuntimeIOException(java.lang.Throwable)"><B>RuntimeIOException(Throwable)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/RuntimeIOException.html" title="class in org.apache.mina.common">RuntimeIOException</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_S_"><!-- --></A><H2>
<B>S</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html#SENT"><B>SENT</B></A> - 
Static variable in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoServiceListener.html#serviceActivated(org.apache.mina.common.IoService, java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>serviceActivated(IoService, SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceListener.html" title="interface in org.apache.mina.common">IoServiceListener</A>
<DD>Invoked when a new service is activated by an <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>.
<DT><A HREF="./org/apache/mina/common/IoServiceListener.html#serviceDeactivated(org.apache.mina.common.IoService, java.net.SocketAddress, org.apache.mina.common.IoHandler, org.apache.mina.common.IoServiceConfig)"><B>serviceDeactivated(IoService, SocketAddress, IoHandler, IoServiceConfig)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceListener.html" title="interface in org.apache.mina.common">IoServiceListener</A>
<DD>Invoked when a service is deactivated by an <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#SESSION_SECURED"><B>SESSION_SECURED</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>A special message object which is emitted with a <A HREF="./org/apache/mina/common/IoHandler.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><CODE>IoHandler.messageReceived(IoSession, Object)</CODE></A>
 event when the session is secured and its <A HREF="./org/apache/mina/filter/SSLFilter.html#USE_NOTIFICATION"><CODE>SSLFilter.USE_NOTIFICATION</CODE></A>
 attribute is set.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#SESSION_UNSECURED"><B>SESSION_UNSECURED</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>A special message object which is emitted with a <A HREF="./org/apache/mina/common/IoHandler.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><CODE>IoHandler.messageReceived(IoSession, Object)</CODE></A>
 event when the session is not secure anymore and its <A HREF="./org/apache/mina/filter/SSLFilter.html#USE_NOTIFICATION"><CODE>SSLFilter.USE_NOTIFICATION</CODE></A>
 attribute is set.
<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html#sessionClosed(org.apache.mina.common.IoSession)"><B>sessionClosed(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common">IoFilter.NextFilter</A>
<DD>Forwards <tt>sessionClosed</tt> event to next filter.
<DT><A HREF="./org/apache/mina/common/IoFilter.html#sessionClosed(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/common/IoHandler.html#sessionClosed(org.apache.mina.common.IoSession)"><CODE>IoHandler.sessionClosed(IoSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#sessionClosed(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoHandler.html#sessionClosed(org.apache.mina.common.IoSession)"><B>sessionClosed(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common">IoHandler</A>
<DD>Invoked when the connection is closed.
<DT><A HREF="./org/apache/mina/common/IoHandlerAdapter.html#sessionClosed(org.apache.mina.common.IoSession)"><B>sessionClosed(IoSession)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandlerAdapter.html" title="class in org.apache.mina.common">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#sessionClosed(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html#sessionClosed(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolCodecFilter.html" title="class in org.apache.mina.filter.codec">ProtocolCodecFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#sessionClosed(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#sessionClosed(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#sessionClosed(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#sessionClosed(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#sessionClosed()"><B>sessionClosed()</B></A> - 
Method in interface org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton">SingleSessionIoHandler</A>
<DD>Invoked when the connection is closed.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html#sessionClosed()"><B>sessionClosed()</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html#sessionClosed(org.apache.mina.common.IoSession)"><B>sessionClosed(IoSession)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerDelegate</A>
<DD>Delegates the method call to the
 <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#sessionClosed()"><CODE>SingleSessionIoHandler.sessionClosed()</CODE></A> method of the handler
 assigned to this session.
<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html#sessionCreated(org.apache.mina.common.IoSession)"><B>sessionCreated(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common">IoFilter.NextFilter</A>
<DD>Forwards <tt>sessionCreated</tt> event to next filter.
<DT><A HREF="./org/apache/mina/common/IoFilter.html#sessionCreated(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionCreated(IoFilter.NextFilter, IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/common/IoHandler.html#sessionCreated(org.apache.mina.common.IoSession)"><CODE>IoHandler.sessionCreated(IoSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#sessionCreated(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionCreated(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoHandler.html#sessionCreated(org.apache.mina.common.IoSession)"><B>sessionCreated(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common">IoHandler</A>
<DD>Invoked when the session is created.
<DT><A HREF="./org/apache/mina/common/IoHandlerAdapter.html#sessionCreated(org.apache.mina.common.IoSession)"><B>sessionCreated(IoSession)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandlerAdapter.html" title="class in org.apache.mina.common">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoServiceListener.html#sessionCreated(org.apache.mina.common.IoSession)"><B>sessionCreated(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceListener.html" title="interface in org.apache.mina.common">IoServiceListener</A>
<DD>Invoked when a new session is created by an <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#sessionCreated(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionCreated(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#sessionCreated(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionCreated(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#sessionCreated(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionCreated(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#sessionCreated(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionCreated(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#sessionCreated()"><B>sessionCreated()</B></A> - 
Method in interface org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton">SingleSessionIoHandler</A>
<DD>Invoked when the session is created.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html#sessionCreated()"><B>sessionCreated()</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html#sessionCreated(org.apache.mina.common.IoSession)"><B>sessionCreated(IoSession)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerDelegate</A>
<DD>Creates a new instance with the factory passed to the constructor of
 this class.
<DT><A HREF="./org/apache/mina/common/IoServiceListener.html#sessionDestroyed(org.apache.mina.common.IoSession)"><B>sessionDestroyed(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceListener.html" title="interface in org.apache.mina.common">IoServiceListener</A>
<DD>Invoked when a session is being destroyed by an <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>.
<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html#sessionIdle(org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common">IoFilter.NextFilter</A>
<DD>Forwards <tt>sessionIdle</tt> event to next filter.
<DT><A HREF="./org/apache/mina/common/IoFilter.html#sessionIdle(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/common/IoHandler.html#sessionIdle(org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><CODE>IoHandler.sessionIdle(IoSession,IdleStatus)</CODE></A>
 event.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#sessionIdle(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoHandler.html#sessionIdle(org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common">IoHandler</A>
<DD>Invoked when the connection is idle.
<DT><A HREF="./org/apache/mina/common/IoHandlerAdapter.html#sessionIdle(org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandlerAdapter.html" title="class in org.apache.mina.common">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#sessionIdle(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#sessionIdle(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#sessionIdle(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#sessionIdle(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#sessionIdle(org.apache.mina.common.IdleStatus)"><B>sessionIdle(IdleStatus)</B></A> - 
Method in interface org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton">SingleSessionIoHandler</A>
<DD>Invoked when the connection is idle.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html#sessionIdle(org.apache.mina.common.IdleStatus)"><B>sessionIdle(IdleStatus)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html#sessionIdle(org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerDelegate</A>
<DD>Delegates the method call to the
 <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#sessionIdle(org.apache.mina.common.IdleStatus)"><CODE>SingleSessionIoHandler.sessionIdle(IdleStatus)</CODE></A> method of the
 handler assigned to this session.
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#sessionIdle(org.apache.mina.common.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>Handles read timeout.
<DT><A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util"><B>SessionLog</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>Provides utility methods to log protocol-specific messages.<DT><A HREF="./org/apache/mina/util/SessionLog.html#SessionLog()"><B>SessionLog()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoFilter.NextFilter.html#sessionOpened(org.apache.mina.common.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.NextFilter.html" title="interface in org.apache.mina.common">IoFilter.NextFilter</A>
<DD>Forwards <tt>sessionOpened</tt> event to next filter.
<DT><A HREF="./org/apache/mina/common/IoFilter.html#sessionOpened(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.html" title="interface in org.apache.mina.common">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/common/IoHandler.html#sessionOpened(org.apache.mina.common.IoSession)"><CODE>IoHandler.sessionOpened(IoSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/common/IoFilterAdapter.html#sessionOpened(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilterAdapter.html" title="class in org.apache.mina.common">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoHandler.html#sessionOpened(org.apache.mina.common.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common">IoHandler</A>
<DD>Invoked when the connection is opened.
<DT><A HREF="./org/apache/mina/common/IoHandlerAdapter.html#sessionOpened(org.apache.mina.common.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoHandlerAdapter.html" title="class in org.apache.mina.common">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#sessionOpened(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html#sessionOpened(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.html" title="class in org.apache.mina.filter.executor">ExecutorFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/LoggingFilter.html#sessionOpened(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/LoggingFilter.html" title="class in org.apache.mina.filter">LoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html#sessionOpened(org.apache.mina.common.IoFilter.NextFilter, org.apache.mina.common.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReferenceCountingIoFilter.html" title="class in org.apache.mina.filter">ReferenceCountingIoFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#sessionOpened()"><B>sessionOpened()</B></A> - 
Method in interface org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton">SingleSessionIoHandler</A>
<DD>Invoked when the connection is opened.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html#sessionOpened()"><B>sessionOpened()</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html#sessionOpened(org.apache.mina.common.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerDelegate</A>
<DD>Delegates the method call to the
 <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html#sessionOpened()"><CODE>SingleSessionIoHandler.sessionOpened()</CODE></A> method of the handler
 assigned to this session.
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#sessionOpened(org.apache.mina.common.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>Initializes streams and timeout settings.
<DT><A HREF="./org/apache/mina/util/SessionUtil.html" title="class in org.apache.mina.util"><B>SessionUtil</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A session utility<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#set(int, java.lang.Object)"><B>set(int, Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#set(int, java.lang.Object)"><B>set(int, Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#setAddress(java.net.SocketAddress)"><B>setAddress(SocketAddress)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>Sets the address the handler of this object will be bound to.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#setAllocator(org.apache.mina.common.ByteBufferAllocator)"><B>setAllocator(ByteBufferAllocator)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Changes the current allocator with the specified one to manage
 the allocated buffers from now.
<DT><A HREF="./org/apache/mina/integration/spring/InetAddressEditor.html#setAsText(java.lang.String)"><B>setAsText(String)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/InetAddressEditor.html" title="class in org.apache.mina.integration.spring">InetAddressEditor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/InetSocketAddressEditor.html#setAsText(java.lang.String)"><B>setAsText(String)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/InetSocketAddressEditor.html" title="class in org.apache.mina.integration.spring">InetSocketAddressEditor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/VmPipeAddressEditor.html#setAsText(java.lang.String)"><B>setAsText(String)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/VmPipeAddressEditor.html" title="class in org.apache.mina.integration.spring">VmPipeAddressEditor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#setAttachment(java.lang.Object)"><B>setAttachment(Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Sets an attachment of this session.
<DT><A HREF="./org/apache/mina/common/IoSession.html#setAttribute(java.lang.String, java.lang.Object)"><B>setAttribute(String, Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Sets a user-defined attribute.
<DT><A HREF="./org/apache/mina/common/IoSession.html#setAttribute(java.lang.String)"><B>setAttribute(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Sets a user defined attribute without a value.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#setAutoExpand(boolean)"><B>setAutoExpand(boolean)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Turns on or off <tt>autoExpand</tt>.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#setAutoExpand(boolean)"><B>setAutoExpand(boolean)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html#setBacklog(int)"><B>setBacklog(int)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html#setBindings(org.apache.mina.integration.spring.Binding[])"><B>setBindings(Binding[])</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html" title="class in org.apache.mina.integration.spring">IoAcceptorFactoryBean</A>
<DD>Sets the bindings to be used by the <A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common"><CODE>IoAcceptor</CODE></A> configured by this 
 factory bean.
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#setBlacklist(java.net.InetAddress[])"><B>setBlacklist(InetAddress[])</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>Sets the addresses to be blacklisted.
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#setBlacklist(java.util.Collection)"><B>setBlacklist(Collection)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>Sets the addresses to be blacklisted.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#setBroadcast(boolean)"><B>setBroadcast(boolean)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/CloseFuture.html#setClosed()"><B>setClosed()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/CloseFuture.html" title="interface in org.apache.mina.common">CloseFuture</A>
<DD>Marks this future as closed and notifies all threads waiting for this
 future.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#setCompressInbound(boolean)"><B>setCompressInbound(boolean)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>Sets if incoming data has to be compressed.
<DT><A HREF="./org/apache/mina/filter/CompressionFilter.html#setCompressOutbound(boolean)"><B>setCompressOutbound(boolean)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/CompressionFilter.html" title="class in org.apache.mina.filter">CompressionFilter</A>
<DD>Set if outgoing data has to be compressed.
<DT><A HREF="./org/apache/mina/common/IoConnectorConfig.html#setConnectTimeout(int)"><B>setConnectTimeout(int)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoConnectorConfig.html" title="interface in org.apache.mina.common">IoConnectorConfig</A>
<DD>Sets the connect timeout in seconds.
<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#setCorePoolSize(int)"><B>setCorePoolSize(int)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>Set the ThreadPoolExecutor's core pool size.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html#setDecoderMaxLineLength(int)"><B>setDecoderMaxLineLength(int)</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html" title="class in org.apache.mina.filter.codec.textline">TextLineCodecFactory</A>
<DD>Sets the allowed maximum size of the line to be decoded.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html#setDecoderMaxObjectSize(int)"><B>setDecoderMaxObjectSize(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationCodecFactory</A>
<DD>Sets the allowed maximum size of the object to be decoded.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptor.html#setDefaultConfig(org.apache.mina.transport.socket.nio.DatagramAcceptorConfig)"><B>setDefaultConfig(DatagramAcceptorConfig)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptor.html" title="class in org.apache.mina.transport.socket.nio">DatagramAcceptor</A>
<DD>Sets the config this acceptor will use by default.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnector.html#setDefaultConfig(org.apache.mina.transport.socket.nio.DatagramConnectorConfig)"><B>setDefaultConfig(DatagramConnectorConfig)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramConnector.html" title="class in org.apache.mina.transport.socket.nio">DatagramConnector</A>
<DD>Sets the default config this connector should use.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html#setDefaultConfig(org.apache.mina.transport.socket.nio.SocketAcceptorConfig)"><B>setDefaultConfig(SocketAcceptorConfig)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptor</A>
<DD>Sets the config this acceptor will use by default.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html#setDefaultConfig(org.apache.mina.transport.socket.nio.SocketConnectorConfig)"><B>setDefaultConfig(SocketConnectorConfig)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio">SocketConnector</A>
<DD>Sets the config this connector will use by default.
<DT><A HREF="./org/apache/mina/common/IoAcceptorConfig.html#setDisconnectOnUnbind(boolean)"><B>setDisconnectOnUnbind(boolean)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoAcceptorConfig.html" title="interface in org.apache.mina.common">IoAcceptorConfig</A>
<DD>Sets whether all clients are disconnected when this acceptor unbinds the
 related local address.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#setEnabledCipherSuites(java.lang.String[])"><B>setEnabledCipherSuites(String[])</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Sets the list of cipher suites to be enabled when <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLEngine.html" title="class or interface in javax.net.ssl"><CODE>SSLEngine</CODE></A>
 is initialized.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#setEnabledProtocols(java.lang.String[])"><B>setEnabledProtocols(String[])</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Sets the list of protocols to be enabled when <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLEngine.html" title="class or interface in javax.net.ssl"><CODE>SSLEngine</CODE></A>
 is initialized.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html#setEncoderMaxLineLength(int)"><B>setEncoderMaxLineLength(int)</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html" title="class in org.apache.mina.filter.codec.textline">TextLineCodecFactory</A>
<DD>Sets the allowed maximum size of the encoded line.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html#setEncoderMaxObjectSize(int)"><B>setEncoderMaxObjectSize(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationCodecFactory.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationCodecFactory</A>
<DD>Sets the allowed maximum size of the encoded object.
<DT><A HREF="./org/apache/mina/common/ConnectFuture.html#setException(java.lang.Throwable)"><B>setException(Throwable)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/ConnectFuture.html" title="interface in org.apache.mina.common">ConnectFuture</A>
<DD>Sets the exception caught due to connection failure and notifies all
 threads waiting for this future.
<DT><A HREF="./org/apache/mina/common/ExecutorThreadModel.html#setExecutor(Executor)"><B>setExecutor(Executor)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExecutorThreadModel.html" title="class in org.apache.mina.common">ExecutorThreadModel</A>
<DD>Changes the underlying <CODE>Executor</CODE> of this model.
<DT><A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html#setExecutor(Executor)"><B>setExecutor(Executor)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html" title="class in org.apache.mina.integration.spring">ExecutorThreadModelFactoryBean</A>
<DD>Sets the <CODE>Executor</CODE> to use.
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#setExpirationInterval(int)"><B>setExpirationInterval(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#setExpirationInterval(long)"><B>setExpirationInterval(long)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#setExpirationInterval(int)"><B>setExpirationInterval(int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html#setFile(java.io.File)"><B>setFile(File)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">KeyStoreFactoryBean</A>
<DD>Sets the file which contains the key store.
<DT><A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html#setFilter(org.apache.mina.common.IoFilter)"><B>setFilter(IoFilter)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html" title="class in org.apache.mina.integration.spring">IoFilterMapping</A>
<DD>Sets the filter of this mapping.
<DT><A HREF="./org/apache/mina/common/IoService.html#setFilterChainBuilder(org.apache.mina.common.IoFilterChainBuilder)"><B>setFilterChainBuilder(IoFilterChainBuilder)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common">IoService</A>
<DD>Sets the global <A HREF="./org/apache/mina/common/IoFilterChainBuilder.html" title="interface in org.apache.mina.common"><CODE>IoFilterChainBuilder</CODE></A> which will modify the
 <A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain</CODE></A> of all <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>s which is managed
 by this service.
<DT><A HREF="./org/apache/mina/common/IoServiceConfig.html#setFilterChainBuilder(org.apache.mina.common.IoFilterChainBuilder)"><B>setFilterChainBuilder(IoFilterChainBuilder)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common">IoServiceConfig</A>
<DD>Sets the <A HREF="./org/apache/mina/common/IoFilterChainBuilder.html" title="interface in org.apache.mina.common"><CODE>IoFilterChainBuilder</CODE></A> which will modify the
 <A HREF="./org/apache/mina/common/IoFilterChain.html" title="interface in org.apache.mina.common"><CODE>IoFilterChain</CODE></A> of all <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>s which is created
 with this configuration.
<DT><A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html#setFilterNamePrefix(java.lang.String)"><B>setFilterNamePrefix(String)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html" title="class in org.apache.mina.integration.spring">DefaultIoFilterChainBuilderFactoryBean</A>
<DD>Sets the prefix used to create the names for automatically named filters
 added using <CODE>#setFilters(IoFilter[])</CODE>.
<DT><A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html#setFilters(java.util.List)"><B>setFilters(List)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/DefaultIoFilterChainBuilderFactoryBean.html" title="class in org.apache.mina.integration.spring">DefaultIoFilterChainBuilderFactoryBean</A>
<DD>Sets a number of filters which will be added to the filter
 chain created by this factory bean.
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#setHandler(org.apache.mina.common.IoHandler)"><B>setHandler(IoHandler)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>Sets the handler of this binding object.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html#setHexdump(java.lang.String)"><B>setHexdump(String)</B></A> - 
Method in exception org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderException.html" title="class in org.apache.mina.filter.codec">ProtocolDecoderException</A>
<DD>Sets the hexdump of the unknown message part.
<DT><A HREF="./org/apache/mina/common/IoSession.html#setIdleTime(org.apache.mina.common.IdleStatus, int)"><B>setIdleTime(IdleStatus, int)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Sets idle time for the specified type of idleness in seconds.
<DT><A HREF="./org/apache/mina/common/ExceptionMonitor.html#setInstance(org.apache.mina.common.ExceptionMonitor)"><B>setInstance(ExceptionMonitor)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExceptionMonitor.html" title="class in org.apache.mina.common">ExceptionMonitor</A>
<DD>Sets the uncaught exception monitor.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#setKeepAlive(boolean)"><B>setKeepAlive(boolean)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#setKeepAlive(boolean)"><B>setKeepAlive(boolean)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#setKeepAliveSeconds(int)"><B>setKeepAliveSeconds(int)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>Set the ThreadPoolExecutor's keep alive seconds.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html#setKeepAliveTime(int)"><B>setKeepAliveTime(int)</B></A> - 
Method in interface org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html" title="interface in org.apache.mina.filter.executor">ExecutorFilterMBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setKeyManagerFactory(javax.net.ssl.KeyManagerFactory)"><B>setKeyManagerFactory(KeyManagerFactory)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory</CODE></A> to use.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setKeyManagerFactoryAlgorithm(java.lang.String)"><B>setKeyManagerFactoryAlgorithm(String)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the algorithm to use when creating the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory</CODE></A> 
 using <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html#getInstance(java.lang.String)" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory.getInstance(java.lang.String)</CODE></A> or
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html#getInstance(java.lang.String, java.lang.String)" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory.getInstance(java.lang.String, java.lang.String)</CODE></A>.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setKeyManagerFactoryAlgorithmUseDefault(boolean)"><B>setKeyManagerFactoryAlgorithmUseDefault(boolean)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>If this is set to <code>true</code> while no <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory</CODE></A>
 has been set using <A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setKeyManagerFactory(javax.net.ssl.KeyManagerFactory)"><CODE>SSLContextFactoryBean.setKeyManagerFactory(KeyManagerFactory)</CODE></A> and
 no algorithm has been set using 
 <A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setKeyManagerFactoryAlgorithm(java.lang.String)"><CODE>SSLContextFactoryBean.setKeyManagerFactoryAlgorithm(String)</CODE></A> the default algorithm
 return by <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html#getDefaultAlgorithm()" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory.getDefaultAlgorithm()</CODE></A> will be used.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setKeyManagerFactoryKeyStore(java.security.KeyStore)"><B>setKeyManagerFactoryKeyStore(KeyStore)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/security/KeyStore.html" title="class or interface in java.security"><CODE>KeyStore</CODE></A> which will be used in the call to 
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html#init(java.security.KeyStore, char[])" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory.init(java.security.KeyStore, char[])</CODE></A> when
 the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLContext.html" title="class or interface in javax.net.ssl"><CODE>SSLContext</CODE></A> is created.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setKeyManagerFactoryKeyStorePassword(java.lang.String)"><B>setKeyManagerFactoryKeyStorePassword(String)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the password which will be used in the call to 
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html#init(java.security.KeyStore, char[])" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory.init(java.security.KeyStore, char[])</CODE></A> when
 the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLContext.html" title="class or interface in javax.net.ssl"><CODE>SSLContext</CODE></A> is created.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setKeyManagerFactoryProvider(java.lang.String)"><B>setKeyManagerFactoryProvider(String)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the provider to use when creating the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory</CODE></A> 
 using 
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/KeyManagerFactory.html#getInstance(java.lang.String, java.lang.String)" title="class or interface in javax.net.ssl"><CODE>KeyManagerFactory.getInstance(java.lang.String, java.lang.String)</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html#setMaximumConnectionBufferSize(int)"><B>setMaximumConnectionBufferSize(int)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html" title="class in org.apache.mina.filter">ReadThrottleFilterBuilder</A>
<DD>Set the maximum amount of data to buffer in the ThreadPoolFilter prior to disabling
 reads.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html#setMaximumPoolSize(int)"><B>setMaximumPoolSize(int)</B></A> - 
Method in interface org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html" title="interface in org.apache.mina.filter.executor">ExecutorFilterMBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html#setMaxLineLength(int)"><B>setMaxLineLength(int)</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineDecoder</A>
<DD>Sets the allowed maximum size of the line to be decoded.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html#setMaxLineLength(int)"><B>setMaxLineLength(int)</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineEncoder</A>
<DD>Sets the allowed maximum size of the encoded line.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html#setMaxObjectSize(int)"><B>setMaxObjectSize(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationDecoder.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationDecoder</A>
<DD>Sets the allowed maximum size of the object to be decoded.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html#setMaxObjectSize(int)"><B>setMaxObjectSize(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationEncoder.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationEncoder</A>
<DD>Sets the allowed maximum size of the encoded object.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#setMaxObjectSize(int)"><B>setMaxObjectSize(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>Sets the allowed maximum size of the object to be decoded.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#setMaxObjectSize(int)"><B>setMaxObjectSize(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>Sets the allowed maximum size of the encoded object.
<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#setMaxPoolSize(int)"><B>setMaxPoolSize(int)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>Set the ThreadPoolExecutor's maximum pool size.
<DT><A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html#setName(java.lang.String)"><B>setName(String)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoFilterMapping.html" title="class in org.apache.mina.integration.spring">IoFilterMapping</A>
<DD>Sets the name associated with the filter.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#setNeedClientAuth(boolean)"><B>setNeedClientAuth(boolean)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Configures the engine to <em>require</em> client authentication.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#setOobInline(boolean)"><B>setOobInline(boolean)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#setOobInline(boolean)"><B>setOobInline(boolean)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html#setPassword(java.lang.String)"><B>setPassword(String)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">KeyStoreFactoryBean</A>
<DD>Sets the key store password.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#setPooled(boolean)"><B>setPooled(boolean)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Sets whether this buffer is returned back to the buffer pool when released.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#setPooled(boolean)"><B>setPooled(boolean)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setProtocol(java.lang.String)"><B>setProtocol(String)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the protocol to use when creating the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLContext.html" title="class or interface in javax.net.ssl"><CODE>SSLContext</CODE></A>.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html#setProvider(java.lang.String)"><B>setProvider(String)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">KeyStoreFactoryBean</A>
<DD>Sets the name of the provider to use when creating the key store.
<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#setQueueCapacity(int)"><B>setQueueCapacity(int)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>Set the capacity for the ThreadPoolExecutor's BlockingQueue.
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#setReadTimeout(int)"><B>setReadTimeout(int)</B></A> - 
Method in class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>Sets read timeout in seconds.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#setReceiveBufferSize(int)"><B>setReceiveBufferSize(int)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#setReceiveBufferSize(int)"><B>setReceiveBufferSize(int)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#setReceiveBufferSize(int)"><B>setReceiveBufferSize(int)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#setRejectedExecutionHandler(RejectedExecutionHandler)"><B>setRejectedExecutionHandler(RejectedExecutionHandler)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>Set the RejectedExecutionHandler to use for the ThreadPoolExecutor.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html#setResource(Resource)"><B>setResource(Resource)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">KeyStoreFactoryBean</A>
<DD>Sets a Spring <CODE>Resource</CODE> which contains the key store.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#setReuseAddress(boolean)"><B>setReuseAddress(boolean)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html#setReuseAddress(boolean)"><B>setReuseAddress(boolean)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#setReuseAddress(boolean)"><B>setReuseAddress(boolean)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#setReuseAddress(boolean)"><B>setReuseAddress(boolean)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setSecureRandom(java.security.SecureRandom)"><B>setSecureRandom(SecureRandom)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/security/SecureRandom.html" title="class or interface in java.security"><CODE>SecureRandom</CODE></A> to use when initializing the 
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLContext.html" title="class or interface in javax.net.ssl"><CODE>SSLContext</CODE></A>.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#setSendBufferSize(int)"><B>setSendBufferSize(int)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#setSendBufferSize(int)"><B>setSendBufferSize(int)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#setSendBufferSize(int)"><B>setSendBufferSize(int)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/Binding.html#setServiceConfig(org.apache.mina.common.IoServiceConfig)"><B>setServiceConfig(IoServiceConfig)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/Binding.html" title="class in org.apache.mina.integration.spring">Binding</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html#setServiceName(java.lang.String)"><B>setServiceName(String)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ExecutorThreadModelFactoryBean.html" title="class in org.apache.mina.integration.spring">ExecutorThreadModelFactoryBean</A>
<DD>Sets the name of the service as used in the call to 
 <A HREF="./org/apache/mina/common/ExecutorThreadModel.html#getInstance(java.lang.String)"><CODE>ExecutorThreadModel.getInstance(String)</CODE></A>.
<DT><A HREF="./org/apache/mina/common/ConnectFuture.html#setSession(org.apache.mina.common.IoSession)"><B>setSession(IoSession)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/ConnectFuture.html" title="interface in org.apache.mina.common">ConnectFuture</A>
<DD>Sets the newly connected session and notifies all threads waiting for
 this future.
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html#setSessionRecycler(org.apache.mina.common.IoSessionRecycler)"><B>setSessionRecycler(IoSessionRecycler)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramAcceptorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html#setSessionRecycler(org.apache.mina.common.IoSessionRecycler)"><B>setSessionRecycler(IoSessionRecycler)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramConnectorConfig.html" title="class in org.apache.mina.transport.socket.nio">DatagramConnectorConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramServiceConfig.html#setSessionRecycler(org.apache.mina.common.IoSessionRecycler)"><B>setSessionRecycler(IoSessionRecycler)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramServiceConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramServiceConfig</A>
<DD>Sets the <A HREF="./org/apache/mina/common/IoSessionRecycler.html" title="interface in org.apache.mina.common"><CODE>IoSessionRecycler</CODE></A> for this service.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#setSoLinger(int)"><B>setSoLinger(int)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#setSoLinger(int)"><B>setSoLinger(int)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html#setTarget(org.apache.mina.common.IoAcceptor)"><B>setTarget(IoAcceptor)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/IoAcceptorFactoryBean.html" title="class in org.apache.mina.integration.spring">IoAcceptorFactoryBean</A>
<DD>Sets the <A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common"><CODE>IoAcceptor</CODE></A> to be configured using this factory bean.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#setTcpNoDelay(boolean)"><B>setTcpNoDelay(boolean)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#setTcpNoDelay(boolean)"><B>setTcpNoDelay(boolean)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#setThreadFactory(ThreadFactory)"><B>setThreadFactory(ThreadFactory)</B></A> - 
Method in class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>Set the ThreadFactory to use for the ThreadPoolExecutor's thread pool.
<DT><A HREF="./org/apache/mina/common/IoServiceConfig.html#setThreadModel(org.apache.mina.common.ThreadModel)"><B>setThreadModel(ThreadModel)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoServiceConfig.html" title="interface in org.apache.mina.common">IoServiceConfig</A>
<DD>Sets the default <A HREF="./org/apache/mina/common/ThreadModel.html" title="interface in org.apache.mina.common"><CODE>ThreadModel</CODE></A> of the <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html#setThreadNamePrefix(java.lang.String)"><B>setThreadNamePrefix(String)</B></A> - 
Method in interface org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilterMBean.html" title="interface in org.apache.mina.filter.executor">ExecutorFilterMBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html#setTimeout(int)"><B>setTimeout(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html" title="class in org.apache.mina.common">PooledByteBufferAllocator</A>
<DD>Sets the timeout value of this allocator in seconds.
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#setTimeToLive(int)"><B>setTimeToLive(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#setTimeToLive(long)"><B>setTimeToLive(long)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#setTimeToLive(int)"><B>setTimeToLive(int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html#setTrafficClass(int)"><B>setTrafficClass(int)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/DatagramSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html#setTrafficClass(int)"><B>setTrafficClass(int)</B></A> - 
Method in interface org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#setTrafficClass(int)"><B>setTrafficClass(int)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#setTrafficMask(org.apache.mina.common.TrafficMask)"><B>setTrafficMask(TrafficMask)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Sets the <A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common"><CODE>TrafficMask</CODE></A> of this session which will result
 the parent <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A> to start to control the traffic
 of this session immediately.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setTrustManagerFactory(javax.net.ssl.TrustManagerFactory)"><B>setTrustManagerFactory(TrustManagerFactory)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory</CODE></A> to use.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setTrustManagerFactoryAlgorithm(java.lang.String)"><B>setTrustManagerFactoryAlgorithm(String)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the algorithm to use when creating the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory</CODE></A> 
 using <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html#getInstance(java.lang.String)" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory.getInstance(java.lang.String)</CODE></A> or
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html#getInstance(java.lang.String, java.lang.String)" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory.getInstance(java.lang.String, java.lang.String)</CODE></A>.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setTrustManagerFactoryAlgorithmUseDefault(boolean)"><B>setTrustManagerFactoryAlgorithmUseDefault(boolean)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>If this is set to <code>true</code> while no <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory</CODE></A>
 has been set using <A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setTrustManagerFactory(javax.net.ssl.TrustManagerFactory)"><CODE>SSLContextFactoryBean.setTrustManagerFactory(TrustManagerFactory)</CODE></A> and
 no algorithm has been set using 
 <A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setTrustManagerFactoryAlgorithm(java.lang.String)"><CODE>SSLContextFactoryBean.setTrustManagerFactoryAlgorithm(String)</CODE></A> the default algorithm
 return by <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html#getDefaultAlgorithm()" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory.getDefaultAlgorithm()</CODE></A> will be used.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setTrustManagerFactoryKeyStore(java.security.KeyStore)"><B>setTrustManagerFactoryKeyStore(KeyStore)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/security/KeyStore.html" title="class or interface in java.security"><CODE>KeyStore</CODE></A> which will be used in the call to 
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html#init(java.security.KeyStore)" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory.init(java.security.KeyStore)</CODE></A> when
 the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLContext.html" title="class or interface in javax.net.ssl"><CODE>SSLContext</CODE></A> is created.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setTrustManagerFactoryParameters(javax.net.ssl.ManagerFactoryParameters)"><B>setTrustManagerFactoryParameters(ManagerFactoryParameters)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/ManagerFactoryParameters.html" title="class or interface in javax.net.ssl"><CODE>ManagerFactoryParameters</CODE></A> which will be used in the call to
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html#init(javax.net.ssl.ManagerFactoryParameters)" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory.init(javax.net.ssl.ManagerFactoryParameters)</CODE></A> when
 the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLContext.html" title="class or interface in javax.net.ssl"><CODE>SSLContext</CODE></A> is created.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#setTrustManagerFactoryProvider(java.lang.String)"><B>setTrustManagerFactoryProvider(String)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>Sets the provider to use when creating the <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory</CODE></A> 
 using 
 <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/TrustManagerFactory.html#getInstance(java.lang.String, java.lang.String)" title="class or interface in javax.net.ssl"><CODE>TrustManagerFactory.getInstance(java.lang.String, java.lang.String)</CODE></A>.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html#setType(java.lang.String)"><B>setType(String)</B></A> - 
Method in class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/KeyStoreFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">KeyStoreFactoryBean</A>
<DD>Sets the type of key store to create.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#setUseClientMode(boolean)"><B>setUseClientMode(boolean)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Configures the engine to use client (or server) mode when handshaking.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#setUseDirectBuffers(boolean)"><B>setUseDirectBuffers(boolean)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#setWantClientAuth(boolean)"><B>setWantClientAuth(boolean)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Configures the engine to <em>request</em> client authentication.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html#setWorkerTimeout(int)"><B>setWorkerTimeout(int)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio">SocketConnector</A>
<DD>Set how many seconds the connection worker thread should remain alive once idle before terminating itself.
<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html#setWriteBufferSize(int)"><B>setWriteBufferSize(int)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter">StreamWriteFilter</A>
<DD>Sets the size of the write buffer in bytes.
<DT><A HREF="./org/apache/mina/common/IoSession.html#setWriteTimeout(int)"><B>setWriteTimeout(int)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Sets write timeout in seconds.
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#setWriteTimeout(int)"><B>setWriteTimeout(int)</B></A> - 
Method in class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>Sets write timeout in seconds.
<DT><A HREF="./org/apache/mina/common/WriteFuture.html#setWritten(boolean)"><B>setWritten(boolean)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/WriteFuture.html" title="interface in org.apache.mina.common">WriteFuture</A>
<DD>Sets whether the message is written or not, and notifies all threads
 waiting for this future.
<DT><A HREF="./org/apache/mina/common/SimpleByteBufferAllocator.html" title="class in org.apache.mina.common"><B>SimpleByteBufferAllocator</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A simplistic <A HREF="./org/apache/mina/common/ByteBufferAllocator.html" title="interface in org.apache.mina.common"><CODE>ByteBufferAllocator</CODE></A> which simply allocates a new
 buffer every time.<DT><A HREF="./org/apache/mina/common/SimpleByteBufferAllocator.html#SimpleByteBufferAllocator()"><B>SimpleByteBufferAllocator()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/SimpleByteBufferAllocator.html" title="class in org.apache.mina.common">SimpleByteBufferAllocator</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton"><B>SingleSessionIoHandler</B></A> - Interface in <A HREF="./org/apache/mina/handler/multiton/package-summary.html">org.apache.mina.handler.multiton</A><DD>A session handler without an <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> parameter for simplicity.<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton"><B>SingleSessionIoHandlerAdapter</B></A> - Class in <A HREF="./org/apache/mina/handler/multiton/package-summary.html">org.apache.mina.handler.multiton</A><DD>Adapter class for implementors of the <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton"><CODE>SingleSessionIoHandler</CODE></A>
 interface.<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html#SingleSessionIoHandlerAdapter(org.apache.mina.common.IoSession)"><B>SingleSessionIoHandlerAdapter(IoSession)</B></A> - 
Constructor for class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerAdapter.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerAdapter</A>
<DD>Creates a new instance that is assigned to the passed in session.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton"><B>SingleSessionIoHandlerDelegate</B></A> - Class in <A HREF="./org/apache/mina/handler/multiton/package-summary.html">org.apache.mina.handler.multiton</A><DD>An <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> implementation which delegates all requests to
 <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton"><CODE>SingleSessionIoHandler</CODE></A>s.<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html#SingleSessionIoHandlerDelegate(org.apache.mina.handler.multiton.SingleSessionIoHandlerFactory)"><B>SingleSessionIoHandlerDelegate(SingleSessionIoHandlerFactory)</B></A> - 
Constructor for class org.apache.mina.handler.multiton.<A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerDelegate.html" title="class in org.apache.mina.handler.multiton">SingleSessionIoHandlerDelegate</A>
<DD>Creates a new instance that uses the passed in
 <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerFactory.html" title="interface in org.apache.mina.handler.multiton"><CODE>SingleSessionIoHandlerFactory</CODE></A> to create new
 <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton"><CODE>SingleSessionIoHandler</CODE></A>s.
<DT><A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandlerFactory.html" title="interface in org.apache.mina.handler.multiton"><B>SingleSessionIoHandlerFactory</B></A> - Interface in <A HREF="./org/apache/mina/handler/multiton/package-summary.html">org.apache.mina.handler.multiton</A><DD>A factory that creates <A HREF="./org/apache/mina/handler/multiton/SingleSessionIoHandler.html" title="interface in org.apache.mina.handler.multiton"><CODE>SingleSessionIoHandler</CODE></A> to be used with one
 particular session.<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#size()"><B>size()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#size()"><B>size()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringStack.html#size()"><B>size()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringStack.html" title="class in org.apache.mina.util">ExpiringStack</A>
<DD>Returns the number of elements in the stack.
<DT><A HREF="./org/apache/mina/util/IdentityHashSet.html#size()"><B>size()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/IdentityHashSet.html" title="class in org.apache.mina.util">IdentityHashSet</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#size()"><B>size()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>Returns the number of elements in the queue.
<DT><A HREF="./org/apache/mina/util/Stack.html#size()"><B>size()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util">Stack</A>
<DD>Returns the number of elements in the stack.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#skip(int)"><B>skip(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Forwards the position of this buffer as the specified <code>size</code>
 bytes.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#skip(int)"><B>skip(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html#skipBytes(int)"><B>skipBytes(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationInputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationInputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#slice()"><B>slice()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#slice()"><B>slice()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TransportType.html#SOCKET"><B>SOCKET</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>Transport type: TCP/IP (Registry name: <tt>"SOCKET"</tt> or <tt>"TCP"</tt>)
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html" title="class in org.apache.mina.transport.socket.nio"><B>SocketAcceptor</B></A> - Class in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD><A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common"><CODE>IoAcceptor</CODE></A> for socket transport (TCP/IP).<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html#SocketAcceptor()"><B>SocketAcceptor()</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptor</A>
<DD>Create an acceptor with a single processing thread using a NewThreadExecutor
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html#SocketAcceptor(int, Executor)"><B>SocketAcceptor(int, Executor)</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptor</A>
<DD>Create an acceptor with the desired number of processing threads
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio"><B>SocketAcceptorConfig</B></A> - Class in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD>An <A HREF="./org/apache/mina/common/IoAcceptorConfig.html" title="interface in org.apache.mina.common"><CODE>IoAcceptorConfig</CODE></A> for <A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html" title="class in org.apache.mina.transport.socket.nio"><CODE>SocketAcceptor</CODE></A>.<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html#SocketAcceptorConfig()"><B>SocketAcceptorConfig()</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptorConfig.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptorConfig</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio"><B>SocketConnector</B></A> - Class in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD><A HREF="./org/apache/mina/common/IoConnector.html" title="interface in org.apache.mina.common"><CODE>IoConnector</CODE></A> for socket transport (TCP/IP).<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html#SocketConnector()"><B>SocketConnector()</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio">SocketConnector</A>
<DD>Create a connector with a single processing thread using a NewThreadExecutor
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html#SocketConnector(int, Executor)"><B>SocketConnector(int, Executor)</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio">SocketConnector</A>
<DD>Create a connector with the desired number of processing threads
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnectorConfig.html" title="class in org.apache.mina.transport.socket.nio"><B>SocketConnectorConfig</B></A> - Class in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD>An <A HREF="./org/apache/mina/common/IoConnectorConfig.html" title="interface in org.apache.mina.common"><CODE>IoConnectorConfig</CODE></A> for <A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio"><CODE>SocketConnector</CODE></A>.<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketConnectorConfig.html#SocketConnectorConfig()"><B>SocketConnectorConfig()</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketConnectorConfig.html" title="class in org.apache.mina.transport.socket.nio">SocketConnectorConfig</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfig.html" title="interface in org.apache.mina.transport.socket.nio"><B>SocketSessionConfig</B></A> - Interface in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD>An <A HREF="./org/apache/mina/common/IoSessionConfig.html" title="interface in org.apache.mina.common"><CODE>IoSessionConfig</CODE></A> for socket transport type.<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio"><B>SocketSessionConfigImpl</B></A> - Class in <A HREF="./org/apache/mina/transport/socket/nio/package-summary.html">org.apache.mina.transport.socket.nio</A><DD>An <A HREF="./org/apache/mina/common/IoConnectorConfig.html" title="interface in org.apache.mina.common"><CODE>IoConnectorConfig</CODE></A> for <A HREF="./org/apache/mina/transport/socket/nio/SocketConnector.html" title="class in org.apache.mina.transport.socket.nio"><CODE>SocketConnector</CODE></A>.<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html#SocketSessionConfigImpl()"><B>SocketSessionConfigImpl()</B></A> - 
Constructor for class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketSessionConfigImpl.html" title="class in org.apache.mina.transport.socket.nio">SocketSessionConfigImpl</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#SSL_SESSION"><B>SSL_SESSION</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>A session attribute key that stores underlying <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLSession.html" title="class or interface in javax.net.ssl"><CODE>SSLSession</CODE></A>
 for each session.
<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl"><B>SSLContextFactoryBean</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/ssl/package-summary.html">org.apache.mina.integration.spring.ssl</A><DD>Spring <A HREF="http://static.springframework.org/spring/docs/1.2.x/api/org/springframework/beans/factory/FactoryBean.html" title="class or interface in org.springframework.beans.factory"><CODE>FactoryBean</CODE></A> implementation 
 which makes it possible to configure <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLContext.html" title="class or interface in javax.net.ssl"><CODE>SSLContext</CODE></A> 
 instances using Spring.<DT><A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html#SSLContextFactoryBean()"><B>SSLContextFactoryBean()</B></A> - 
Constructor for class org.apache.mina.integration.spring.ssl.<A HREF="./org/apache/mina/integration/spring/ssl/SSLContextFactoryBean.html" title="class in org.apache.mina.integration.spring.ssl">SSLContextFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter"><B>SSLFilter</B></A> - Class in <A HREF="./org/apache/mina/filter/package-summary.html">org.apache.mina.filter</A><DD>An SSL filter that encrypts and decrypts the data exchanged in the session.<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#SSLFilter(javax.net.ssl.SSLContext)"><B>SSLFilter(SSLContext)</B></A> - 
Constructor for class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Creates a new SSL filter using the specified <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/javax/net/ssl/SSLContext.html" title="class or interface in javax.net.ssl"><CODE>SSLContext</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/SSLFilter.SSLFilterMessage.html" title="class in org.apache.mina.filter"><B>SSLFilter.SSLFilterMessage</B></A> - Class in <A HREF="./org/apache/mina/filter/package-summary.html">org.apache.mina.filter</A><DD>A message that is sent from <A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter"><CODE>SSLFilter</CODE></A> when the connection became
 secure or is not secure anymore.<DT><A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util"><B>Stack</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A unbounded stack.<DT><A HREF="./org/apache/mina/util/Stack.html#Stack()"><B>Stack()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/Stack.html" title="class in org.apache.mina.util">Stack</A>
<DD>Construct a new, empty stack.
<DT><A HREF="./org/apache/mina/management/StatCollector.html#start()"><B>start()</B></A> - 
Method in class org.apache.mina.management.<A HREF="./org/apache/mina/management/StatCollector.html" title="class in org.apache.mina.management">StatCollector</A>
<DD>Start collecting stats for the <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A> of the service.
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#startCollectingStats(int)"><B>startCollectingStats(int)</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#startCollectingStats(int)"><B>startCollectingStats(int)</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>start collecting throughput statistics for all the managed sessions
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#startExpiring()"><B>startExpiring()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#startExpiringIfNotStarted()"><B>startExpiringIfNotStarted()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#startSSL(org.apache.mina.common.IoSession)"><B>startSSL(IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>(Re)starts SSL session for the specified <tt>session</tt> if not started yet.
<DT><A HREF="./org/apache/mina/management/StatCollector.html" title="class in org.apache.mina.management"><B>StatCollector</B></A> - Class in <A HREF="./org/apache/mina/management/package-summary.html">org.apache.mina.management</A><DD>Collects statistics of an <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>.<DT><A HREF="./org/apache/mina/management/StatCollector.html#StatCollector(org.apache.mina.common.IoService)"><B>StatCollector(IoService)</B></A> - 
Constructor for class org.apache.mina.management.<A HREF="./org/apache/mina/management/StatCollector.html" title="class in org.apache.mina.management">StatCollector</A>
<DD>Create a stat collector for the given service with a default polling time of 5 seconds.
<DT><A HREF="./org/apache/mina/management/StatCollector.html#StatCollector(org.apache.mina.common.IoService, int)"><B>StatCollector(IoService, int)</B></A> - 
Constructor for class org.apache.mina.management.<A HREF="./org/apache/mina/management/StatCollector.html" title="class in org.apache.mina.management">StatCollector</A>
<DD>create a stat collector for the given given service
<DT><A HREF="./org/apache/mina/management/StatCollector.html#stop()"><B>stop()</B></A> - 
Method in class org.apache.mina.management.<A HREF="./org/apache/mina/management/StatCollector.html" title="class in org.apache.mina.management">StatCollector</A>
<DD>Stop collecting stats.
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html#stopCollectingStats()"><B>stopCollectingStats()</B></A> - 
Method in class org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManager.html" title="class in org.apache.mina.integration.jmx">IoServiceManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html#stopCollectingStats()"><B>stopCollectingStats()</B></A> - 
Method in interface org.apache.mina.integration.jmx.<A HREF="./org/apache/mina/integration/jmx/IoServiceManagerMBean.html" title="interface in org.apache.mina.integration.jmx">IoServiceManagerMBean</A>
<DD>stop collecting throughput statistics
<DT><A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html#stopExpiring()"><B>stopExpiring()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ExpiringSessionRecycler.html" title="class in org.apache.mina.common">ExpiringSessionRecycler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html#stopExpiring()"><B>stopExpiring()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.Expirer.html" title="class in org.apache.mina.util">ExpiringMap.Expirer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#stopSSL(org.apache.mina.common.IoSession)"><B>stopSSL(IoSession)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>Stops the SSL session by sending TLS <tt>close_notify</tt> message to
 initiate TLS closure.
<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler"><B>StreamIoHandler</B></A> - Class in <A HREF="./org/apache/mina/handler/package-summary.html">org.apache.mina.handler</A><DD>A <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> that adapts asynchronous MINA events to stream I/O.<DT><A HREF="./org/apache/mina/handler/StreamIoHandler.html#StreamIoHandler()"><B>StreamIoHandler()</B></A> - 
Constructor for class org.apache.mina.handler.<A HREF="./org/apache/mina/handler/StreamIoHandler.html" title="class in org.apache.mina.handler">StreamIoHandler</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter"><B>StreamWriteFilter</B></A> - Class in <A HREF="./org/apache/mina/filter/package-summary.html">org.apache.mina.filter</A><DD>Filter implementation which makes it possible to write <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/InputStream.html" title="class or interface in java.io"><CODE>InputStream</CODE></A>
 objects directly using <A HREF="./org/apache/mina/common/IoSession.html#write(java.lang.Object)"><CODE>IoSession.write(Object)</CODE></A>.<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html#StreamWriteFilter()"><B>StreamWriteFilter()</B></A> - 
Constructor for class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter">StreamWriteFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#subList(int, int)"><B>subList(int, int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html#SUSPENDED_READS"><B>SUSPENDED_READS</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/ReadThrottleFilterBuilder.html" title="class in org.apache.mina.filter">ReadThrottleFilterBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoSession.html#suspendRead()"><B>suspendRead()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>A shortcut method for <A HREF="./org/apache/mina/common/IoSession.html#setTrafficMask(org.apache.mina.common.TrafficMask)"><CODE>IoSession.setTrafficMask(TrafficMask)</CODE></A> that
 suspends read operations for this session.
<DT><A HREF="./org/apache/mina/common/IoSession.html#suspendWrite()"><B>suspendWrite()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>A shortcut method for <A HREF="./org/apache/mina/common/IoSession.html#setTrafficMask(org.apache.mina.common.TrafficMask)"><CODE>IoSession.setTrafficMask(TrafficMask)</CODE></A> that
 suspends write operations for this session.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#sweep()"><B>sweep()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Clears this buffer and fills its content with <tt>NUL</tt>.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#sweep(byte)"><B>sweep(byte)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Clears this buffer and fills its content with <tt>value</tt>.
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#sweep()"><B>sweep()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#sweep(byte)"><B>sweep(byte)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html" title="class in org.apache.mina.filter.codec"><B>SynchronizedProtocolDecoder</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>A <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> implementation which decorates an existing decoder
 to be thread-safe.<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html#SynchronizedProtocolDecoder(org.apache.mina.filter.codec.ProtocolDecoder)"><B>SynchronizedProtocolDecoder(ProtocolDecoder)</B></A> - 
Constructor for class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolDecoder.html" title="class in org.apache.mina.filter.codec">SynchronizedProtocolDecoder</A>
<DD>Creates a new instance which decorates the specified <tt>decoder</tt>.
<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolEncoder.html" title="class in org.apache.mina.filter.codec"><B>SynchronizedProtocolEncoder</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/package-summary.html">org.apache.mina.filter.codec</A><DD>A <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A> implementation which decorates an existing encoder
 to be thread-safe.<DT><A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolEncoder.html#SynchronizedProtocolEncoder(org.apache.mina.filter.codec.ProtocolEncoder)"><B>SynchronizedProtocolEncoder(ProtocolEncoder)</B></A> - 
Constructor for class org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/SynchronizedProtocolEncoder.html" title="class in org.apache.mina.filter.codec">SynchronizedProtocolEncoder</A>
<DD>Creates a new instance which decorates the specified <tt>encoder</tt>.
</DL>
<HR>
<A NAME="_T_"><!-- --></A><H2>
<B>T</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html" title="class in org.apache.mina.filter.codec.textline"><B>TextLineCodecFactory</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/textline/package-summary.html">org.apache.mina.filter.codec.textline</A><DD>A <A HREF="./org/apache/mina/filter/codec/ProtocolCodecFactory.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolCodecFactory</CODE></A> that performs encoding and decoding between
 a text line data and a Java string object.<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html#TextLineCodecFactory()"><B>TextLineCodecFactory()</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html" title="class in org.apache.mina.filter.codec.textline">TextLineCodecFactory</A>
<DD>Creates a new instance with the current default <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/charset/Charset.html" title="class or interface in java.nio.charset"><CODE>Charset</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html#TextLineCodecFactory(java.nio.charset.Charset)"><B>TextLineCodecFactory(Charset)</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineCodecFactory.html" title="class in org.apache.mina.filter.codec.textline">TextLineCodecFactory</A>
<DD>Creates a new instance with the specified <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/charset/Charset.html" title="class or interface in java.nio.charset"><CODE>Charset</CODE></A>.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline"><B>TextLineDecoder</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/textline/package-summary.html">org.apache.mina.filter.codec.textline</A><DD>A <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> which decodes a text line into a string.<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html#TextLineDecoder()"><B>TextLineDecoder()</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineDecoder</A>
<DD>Creates a new instance with the current default <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/charset/Charset.html" title="class or interface in java.nio.charset"><CODE>Charset</CODE></A>
 and <A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#AUTO"><CODE>LineDelimiter.AUTO</CODE></A> delimiter.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html#TextLineDecoder(java.nio.charset.Charset)"><B>TextLineDecoder(Charset)</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineDecoder</A>
<DD>Creates a new instance with the spcified <tt>charset</tt>
 and <A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#AUTO"><CODE>LineDelimiter.AUTO</CODE></A> delimiter.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html#TextLineDecoder(java.nio.charset.Charset, org.apache.mina.filter.codec.textline.LineDelimiter)"><B>TextLineDecoder(Charset, LineDelimiter)</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineDecoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineDecoder</A>
<DD>Creates a new instance with the specified <tt>charset</tt>
 and the specified <tt>delimiter</tt>.
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html" title="class in org.apache.mina.filter.codec.textline"><B>TextLineEncoder</B></A> - Class in <A HREF="./org/apache/mina/filter/codec/textline/package-summary.html">org.apache.mina.filter.codec.textline</A><DD>A <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A> which encodes a string into a text line
 which ends with the delimiter.<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html#TextLineEncoder()"><B>TextLineEncoder()</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html#TextLineEncoder(org.apache.mina.filter.codec.textline.LineDelimiter)"><B>TextLineEncoder(LineDelimiter)</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html#TextLineEncoder(java.nio.charset.Charset)"><B>TextLineEncoder(Charset)</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html#TextLineEncoder(java.nio.charset.Charset, org.apache.mina.filter.codec.textline.LineDelimiter)"><B>TextLineEncoder(Charset, LineDelimiter)</B></A> - 
Constructor for class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/TextLineEncoder.html" title="class in org.apache.mina.filter.codec.textline">TextLineEncoder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ThreadModel.html" title="interface in org.apache.mina.common"><B>ThreadModel</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Represents a thread model of an <A HREF="./org/apache/mina/common/IoService.html" title="interface in org.apache.mina.common"><CODE>IoService</CODE></A>.<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring"><B>ThreadPoolExecutorFactoryBean</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/package-summary.html">org.apache.mina.integration.spring</A><DD>Spring <CODE>FactoryBean</CODE> which enables the configuration of
 <CODE>ThreadPoolExecutor</CODE> instances using Spring.<DT><A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html#ThreadPoolExecutorFactoryBean()"><B>ThreadPoolExecutorFactoryBean()</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/ThreadPoolExecutorFactoryBean.html" title="class in org.apache.mina.integration.spring">ThreadPoolExecutorFactoryBean</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#toArray()"><B>toArray()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#toArray(java.lang.Object[])"><B>toArray(Object[])</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferProxy.html" title="class in org.apache.mina.common">ByteBufferProxy</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultIoFilterChainBuilder.html" title="class in org.apache.mina.common">DefaultIoFilterChainBuilder</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IdleStatus.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IdleStatus.html" title="class in org.apache.mina.common">IdleStatus</A>
<DD>Returns the string representation of this status.
<DT><A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IoFilter.WriteRequest.html" title="class in org.apache.mina.common">IoFilter.WriteRequest</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TransportType.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderResult.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.filter.codec.demux.<A HREF="./org/apache/mina/filter/codec/demux/MessageDecoderResult.html" title="class in org.apache.mina.filter.codec.demux">MessageDecoderResult</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.SSLFilterMessage.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.SSLFilterMessage.html" title="class in org.apache.mina.filter">SSLFilter.SSLFilterMessage</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.handler.chain.<A HREF="./org/apache/mina/handler/chain/IoHandlerChain.html" title="class in org.apache.mina.handler.chain">IoHandlerChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/AnonymousSocketAddress.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/AnonymousSocketAddress.html" title="class in org.apache.mina.util">AnonymousSocketAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/Queue.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/Queue.html" title="class in org.apache.mina.util">Queue</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common"><B>TrafficMask</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A type-safe mask that is used to control the traffic of <A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common"><CODE>IoSession</CODE></A>
 with <A HREF="./org/apache/mina/common/IoSession.html#setTrafficMask(org.apache.mina.common.TrafficMask)"><CODE>IoSession.setTrafficMask(TrafficMask)</CODE></A>.<DT><A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common"><B>TransportType</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Represents network transport types.<DT><A HREF="./org/apache/mina/common/TransportType.html#TransportType(java.lang.String[], boolean)"><B>TransportType(String[], boolean)</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/common/TransportType.html#TransportType(java.lang.String[], java.lang.Class, boolean)"><B>TransportType(String[], Class, boolean)</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>Creates a new instance.
</DL>
<HR>
<A NAME="_U_"><!-- --></A><H2>
<B>U</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/IoAcceptor.html#unbind(java.net.SocketAddress)"><B>unbind(SocketAddress)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common">IoAcceptor</A>
<DD>Unbinds from the specified <code>address</code> and disconnects all clients
 connected there.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html#unbind(java.net.SocketAddress)"><B>unbind(SocketAddress)</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html#unbind(java.net.SocketAddress)"><B>unbind(SocketAddress)</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IoAcceptor.html#unbindAll()"><B>unbindAll()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoAcceptor.html" title="interface in org.apache.mina.common">IoAcceptor</A>
<DD>Unbinds all addresses which were bound by this acceptor.
<DT><A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html#unbindAll()"><B>unbindAll()</B></A> - 
Method in class org.apache.mina.transport.socket.nio.<A HREF="./org/apache/mina/transport/socket/nio/SocketAcceptor.html" title="class in org.apache.mina.transport.socket.nio">SocketAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html#unbindAll()"><B>unbindAll()</B></A> - 
Method in class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/BlacklistFilter.html#unblock(java.net.InetAddress)"><B>unblock(InetAddress)</B></A> - 
Method in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/BlacklistFilter.html" title="class in org.apache.mina.filter">BlacklistFilter</A>
<DD>Unblocks the specified endpoint.
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#UNIX"><B>UNIX</B></A> - 
Static variable in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>The line delimiter constant of UNIX (<tt>"\n"</tt>)
<DT><A HREF="./org/apache/mina/handler/demux/UnknownMessageTypeException.html" title="class in org.apache.mina.handler.demux"><B>UnknownMessageTypeException</B></A> - Exception in <A HREF="./org/apache/mina/handler/demux/package-summary.html">org.apache.mina.handler.demux</A><DD>An exception that is thrown when <A HREF="./org/apache/mina/handler/demux/DemuxingIoHandler.html" title="class in org.apache.mina.handler.demux"><CODE>DemuxingIoHandler</CODE></A>
 cannot find any <A HREF="./org/apache/mina/handler/demux/MessageHandler.html" title="interface in org.apache.mina.handler.demux"><CODE>MessageHandler</CODE></A>s associated with the specific
 message type.<DT><A HREF="./org/apache/mina/handler/demux/UnknownMessageTypeException.html#UnknownMessageTypeException()"><B>UnknownMessageTypeException()</B></A> - 
Constructor for exception org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/UnknownMessageTypeException.html" title="class in org.apache.mina.handler.demux">UnknownMessageTypeException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/demux/UnknownMessageTypeException.html#UnknownMessageTypeException(java.lang.String, java.lang.Throwable)"><B>UnknownMessageTypeException(String, Throwable)</B></A> - 
Constructor for exception org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/UnknownMessageTypeException.html" title="class in org.apache.mina.handler.demux">UnknownMessageTypeException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/demux/UnknownMessageTypeException.html#UnknownMessageTypeException(java.lang.String)"><B>UnknownMessageTypeException(String)</B></A> - 
Constructor for exception org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/UnknownMessageTypeException.html" title="class in org.apache.mina.handler.demux">UnknownMessageTypeException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/handler/demux/UnknownMessageTypeException.html#UnknownMessageTypeException(java.lang.Throwable)"><B>UnknownMessageTypeException(Throwable)</B></A> - 
Constructor for exception org.apache.mina.handler.demux.<A HREF="./org/apache/mina/handler/demux/UnknownMessageTypeException.html" title="class in org.apache.mina.handler.demux">UnknownMessageTypeException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/SSLFilter.html#USE_NOTIFICATION"><B>USE_NOTIFICATION</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/SSLFilter.html" title="class in org.apache.mina.filter">SSLFilter</A>
<DD>A session attribute key that makes this filter to emit a
 <A HREF="./org/apache/mina/common/IoHandler.html#messageReceived(org.apache.mina.common.IoSession, java.lang.Object)"><CODE>IoHandler.messageReceived(IoSession, Object)</CODE></A> event with a
 special message (<A HREF="./org/apache/mina/filter/SSLFilter.html#SESSION_SECURED"><CODE>SSLFilter.SESSION_SECURED</CODE></A> or <A HREF="./org/apache/mina/filter/SSLFilter.html#SESSION_UNSECURED"><CODE>SSLFilter.SESSION_UNSECURED</CODE></A>).
</DL>
<HR>
<A NAME="_V_"><!-- --></A><H2>
<B>V</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/ExpiringMap.html#values()"><B>values()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExpiringMap.html" title="class in org.apache.mina.util">ExpiringMap</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/TransportType.html#VM_PIPE"><B>VM_PIPE</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common">TransportType</A>
<DD>Transport type: in-VM pipe (Registry name: <tt>"VM_PIPE"</tt>) 
 Please refer to
 <a href="./org/apache/mina/common/../protocol/vmpipe/package-summary.htm"><tt>org.apache.mina.protocol.vmpipe</tt></a>
 package.
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.transport.vmpipe"><B>VmPipeAcceptor</B></A> - Class in <A HREF="./org/apache/mina/transport/vmpipe/package-summary.html">org.apache.mina.transport.vmpipe</A><DD>Binds the specified <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A> to the specified
 <A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe"><CODE>VmPipeAddress</CODE></A>.<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html#VmPipeAcceptor()"><B>VmPipeAcceptor()</B></A> - 
Constructor for class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe"><B>VmPipeAddress</B></A> - Class in <A HREF="./org/apache/mina/transport/vmpipe/package-summary.html">org.apache.mina.transport.vmpipe</A><DD>A <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/net/SocketAddress.html" title="class or interface in java.net"><CODE>SocketAddress</CODE></A> which represents in-VM pipe port number.<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html#VmPipeAddress(int)"><B>VmPipeAddress(int)</B></A> - 
Constructor for class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe">VmPipeAddress</A>
<DD>Creates a new instance with the specifid port number.
<DT><A HREF="./org/apache/mina/integration/spring/VmPipeAddressEditor.html" title="class in org.apache.mina.integration.spring"><B>VmPipeAddressEditor</B></A> - Class in <A HREF="./org/apache/mina/integration/spring/package-summary.html">org.apache.mina.integration.spring</A><DD>Java Bean <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/beans/PropertyEditor.html" title="class or interface in java.beans"><CODE>PropertyEditor</CODE></A> which converts Strings into 
 <A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe"><CODE>VmPipeAddress</CODE></A> objects.<DT><A HREF="./org/apache/mina/integration/spring/VmPipeAddressEditor.html#VmPipeAddressEditor()"><B>VmPipeAddressEditor()</B></A> - 
Constructor for class org.apache.mina.integration.spring.<A HREF="./org/apache/mina/integration/spring/VmPipeAddressEditor.html" title="class in org.apache.mina.integration.spring">VmPipeAddressEditor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.transport.vmpipe"><B>VmPipeConnector</B></A> - Class in <A HREF="./org/apache/mina/transport/vmpipe/package-summary.html">org.apache.mina.transport.vmpipe</A><DD>Connects to <A HREF="./org/apache/mina/common/IoHandler.html" title="interface in org.apache.mina.common"><CODE>IoHandler</CODE></A>s which is bound on the specified
 <A HREF="./org/apache/mina/transport/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.transport.vmpipe"><CODE>VmPipeAddress</CODE></A>.<DT><A HREF="./org/apache/mina/transport/vmpipe/VmPipeConnector.html#VmPipeConnector()"><B>VmPipeConnector()</B></A> - 
Constructor for class org.apache.mina.transport.vmpipe.<A HREF="./org/apache/mina/transport/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.transport.vmpipe">VmPipeConnector</A>
<DD>Creates a new instance.
</DL>
<HR>
<A NAME="_W_"><!-- --></A><H2>
<B>W</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/BlockingQueue.html#waitForNewItem()"><B>waitForNewItem()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingQueue.html" title="class in org.apache.mina.util">BlockingQueue</A>
<DD>Waits until any elements are in this queue.
<DT><A HREF="./org/apache/mina/util/SessionLog.html#warn(org.apache.mina.common.IoSession, java.lang.String)"><B>warn(IoSession, String)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/SessionLog.html#warn(org.apache.mina.common.IoSession, java.lang.String, java.lang.Throwable)"><B>warn(IoSession, String, Throwable)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/SessionLog.html" title="class in org.apache.mina.util">SessionLog</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html#WINDOWS"><B>WINDOWS</B></A> - 
Static variable in class org.apache.mina.filter.codec.textline.<A HREF="./org/apache/mina/filter/codec/textline/LineDelimiter.html" title="class in org.apache.mina.filter.codec.textline">LineDelimiter</A>
<DD>The line delimiter constant of MS Windows/DOS (<tt>"\r\n"</tt>)
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#wrap(java.nio.ByteBuffer)"><B>wrap(ByteBuffer)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Wraps the specified NIO <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/ByteBuffer.html" title="class or interface in java.nio"><CODE>ByteBuffer</CODE></A> into MINA buffer.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#wrap(byte[])"><B>wrap(byte[])</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Wraps the specified byte array into MINA heap buffer.
<DT><A HREF="./org/apache/mina/common/ByteBuffer.html#wrap(byte[], int, int)"><B>wrap(byte[], int, int)</B></A> - 
Static method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common">ByteBuffer</A>
<DD>Wraps the specified byte array into MINA heap buffer.
<DT><A HREF="./org/apache/mina/common/ByteBufferAllocator.html#wrap(java.nio.ByteBuffer)"><B>wrap(ByteBuffer)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/ByteBufferAllocator.html" title="interface in org.apache.mina.common">ByteBufferAllocator</A>
<DD>Wraps the specified NIO <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/ByteBuffer.html" title="class or interface in java.nio"><CODE>ByteBuffer</CODE></A> into MINA buffer.
<DT><A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html#wrap(java.nio.ByteBuffer)"><B>wrap(ByteBuffer)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/PooledByteBufferAllocator.html" title="class in org.apache.mina.common">PooledByteBufferAllocator</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SimpleByteBufferAllocator.html#wrap(java.nio.ByteBuffer)"><B>wrap(ByteBuffer)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/SimpleByteBufferAllocator.html" title="class in org.apache.mina.common">SimpleByteBufferAllocator</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BroadcastIoSession.html#write(java.lang.Object, java.net.SocketAddress)"><B>write(Object, SocketAddress)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/BroadcastIoSession.html" title="interface in org.apache.mina.common">BroadcastIoSession</A>
<DD>Writes the specified <tt>message</tt> to the specified <tt>destination</tt>.
<DT><A HREF="./org/apache/mina/common/IoSession.html#write(java.lang.Object)"><B>write(Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/IoSession.html" title="interface in org.apache.mina.common">IoSession</A>
<DD>Writes the specified <code>message</code> to remote peer.
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#WRITE"><B>WRITE</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>This mask suspends reads, and resumes writes if writes were suspended.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolDecoderOutput.html#write(java.lang.Object)"><B>write(Object)</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolDecoderOutput.html" title="interface in org.apache.mina.filter.codec">ProtocolDecoderOutput</A>
<DD>Callback for <A HREF="./org/apache/mina/filter/codec/ProtocolDecoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolDecoder</CODE></A> to generate decoded messages.
<DT><A HREF="./org/apache/mina/filter/codec/ProtocolEncoderOutput.html#write(org.apache.mina.common.ByteBuffer)"><B>write(ByteBuffer)</B></A> - 
Method in interface org.apache.mina.filter.codec.<A HREF="./org/apache/mina/filter/codec/ProtocolEncoderOutput.html" title="interface in org.apache.mina.filter.codec">ProtocolEncoderOutput</A>
<DD>Callback for <A HREF="./org/apache/mina/filter/codec/ProtocolEncoder.html" title="interface in org.apache.mina.filter.codec"><CODE>ProtocolEncoder</CODE></A> to generate encoded
 <A HREF="./org/apache/mina/common/ByteBuffer.html" title="class in org.apache.mina.common"><CODE>ByteBuffer</CODE></A>s.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#write(int)"><B>write(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#write(byte[])"><B>write(byte[])</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#write(byte[], int, int)"><B>write(byte[], int, int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/StreamWriteFilter.html#WRITE_REQUEST_QUEUE"><B>WRITE_REQUEST_QUEUE</B></A> - 
Static variable in class org.apache.mina.filter.<A HREF="./org/apache/mina/filter/StreamWriteFilter.html" title="class in org.apache.mina.filter">StreamWriteFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeBoolean(boolean)"><B>writeBoolean(boolean)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeByte(int)"><B>writeByte(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeBytes(java.lang.String)"><B>writeBytes(String)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeChar(int)"><B>writeChar(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeChars(java.lang.String)"><B>writeChars(String)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeDouble(double)"><B>writeDouble(double)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeFloat(float)"><B>writeFloat(float)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/WriteFuture.html" title="interface in org.apache.mina.common"><B>WriteFuture</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>An <A HREF="./org/apache/mina/common/IoFuture.html" title="interface in org.apache.mina.common"><CODE>IoFuture</CODE></A> for asynchronous write requests.<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeInt(int)"><B>writeInt(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeLong(long)"><B>writeLong(long)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeObject(java.lang.Object)"><B>writeObject(Object)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/IdleStatus.html#WRITER_IDLE"><B>WRITER_IDLE</B></A> - 
Static variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/IdleStatus.html" title="class in org.apache.mina.common">IdleStatus</A>
<DD>Represents the session status that the session is not writing any data.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeShort(int)"><B>writeShort(int)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/WriteTimeoutException.html" title="class in org.apache.mina.common"><B>WriteTimeoutException</B></A> - Exception in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>An <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/io/IOException.html" title="class or interface in java.io"><CODE>IOException</CODE></A> which is thrown when write buffer is not flushed for
 <A HREF="./org/apache/mina/common/IoSession.html#getWriteTimeout()"><CODE>IoSession.getWriteTimeout()</CODE></A> seconds.<DT><A HREF="./org/apache/mina/common/WriteTimeoutException.html#WriteTimeoutException()"><B>WriteTimeoutException()</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/WriteTimeoutException.html" title="class in org.apache.mina.common">WriteTimeoutException</A>
<DD>Creates a new exception.
<DT><A HREF="./org/apache/mina/common/WriteTimeoutException.html#WriteTimeoutException(java.lang.String)"><B>WriteTimeoutException(String)</B></A> - 
Constructor for exception org.apache.mina.common.<A HREF="./org/apache/mina/common/WriteTimeoutException.html" title="class in org.apache.mina.common">WriteTimeoutException</A>
<DD>Creates a new exception.
<DT><A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html#writeUTF(java.lang.String)"><B>writeUTF(String)</B></A> - 
Method in class org.apache.mina.filter.codec.serialization.<A HREF="./org/apache/mina/filter/codec/serialization/ObjectSerializationOutputStream.html" title="class in org.apache.mina.filter.codec.serialization">ObjectSerializationOutputStream</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html#WRITTEN"><B>WRITTEN</B></A> - 
Static variable in class org.apache.mina.filter.executor.<A HREF="./org/apache/mina/filter/executor/ExecutorFilter.EventType.html" title="class in org.apache.mina.filter.executor">ExecutorFilter.EventType</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_X_"><!-- --></A><H2>
<B>X</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/common/TrafficMask.html#xor(org.apache.mina.common.TrafficMask)"><B>xor(TrafficMask)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/TrafficMask.html" title="class in org.apache.mina.common">TrafficMask</A>
<DD>Peforms an <tt>XOR</tt> operation on this mask with the specified
 <tt>mask</tt> and returns the result.
</DL>
<HR>
<A HREF="#_A_">A</A> <A HREF="#_B_">B</A> <A HREF="#_C_">C</A> <A HREF="#_D_">D</A> <A HREF="#_E_">E</A> <A HREF="#_F_">F</A> <A HREF="#_G_">G</A> <A HREF="#_H_">H</A> <A HREF="#_I_">I</A> <A HREF="#_J_">J</A> <A HREF="#_K_">K</A> <A HREF="#_L_">L</A> <A HREF="#_M_">M</A> <A HREF="#_N_">N</A> <A HREF="#_O_">O</A> <A HREF="#_P_">P</A> <A HREF="#_Q_">Q</A> <A HREF="#_R_">R</A> <A HREF="#_S_">S</A> <A HREF="#_T_">T</A> <A HREF="#_U_">U</A> <A HREF="#_V_">V</A> <A HREF="#_W_">W</A> <A HREF="#_X_">X</A> 

<!-- ======= START OF BOTTOM NAVBAR ====== -->
<A NAME="navbar_bottom"><!-- --></A>
<A HREF="#skip-navbar_bottom" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_bottom_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
  <TR ALIGN="center" VALIGN="top">
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Package</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Class</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Use</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Index</B></FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A>&nbsp;</TD>
  </TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>

<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
&nbsp;PREV&nbsp;
&nbsp;NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
  <A HREF="./index.html?index-all.html" target="_top"><B>FRAMES</B></A>  &nbsp;
&nbsp;<A HREF="index-all.html" target="_top"><B>NO FRAMES</B></A>  &nbsp;
&nbsp;<SCRIPT type="text/javascript">
  <!--
  if(window==top) {
    document.writeln('<A HREF="./allclasses-noframe.html"><B>All Classes</B></A>');
  }
  //-->
</SCRIPT>
<NOSCRIPT>
  <A HREF="./allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>


</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_bottom"></A>
<!-- ======== END OF BOTTOM NAVBAR ======= -->

<HR>

</BODY>
</HTML>
