<!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_02) on Mon Jul 11 13:14:42 KST 2005 -->
<META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<TITLE>
Index (MINA 0.7.3 API)
</TITLE>


<LINK REL ="stylesheet" TYPE="text/css" HREF="./stylesheet.css" TITLE="Style">

<SCRIPT type="text/javascript">
function windowTitle()
{
    parent.document.title="Index (MINA 0.7.3 API)";
}
</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="#_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> <HR>
<A NAME="_A_"><!-- --></A><H2>
<B>A</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io"><B>AbstractIoFilterChain</B></A> - Class in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>An abstract implementation of <A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io"><CODE>IoFilterChain</CODE></A> that provides
 common operations for developers to support specific transport types.<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#AbstractIoFilterChain()"><B>AbstractIoFilterChain()</B></A> - 
Constructor for class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol"><B>AbstractProtocolFilterChain</B></A> - Class in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>An abstract implementation of <A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolFilterChain</CODE></A> that provides
 common operations for developers to extend protocol layer.<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#AbstractProtocolFilterChain()"><B>AbstractProtocolFilterChain()</B></A> - 
Constructor for class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<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/BlockingSet.html#add(java.lang.Object)"><B>add(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingSet.html" title="class in org.apache.mina.util">BlockingSet</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#addAfter(java.lang.String, java.lang.String, org.apache.mina.io.IoFilter)"><B>addAfter(String, String, IoFilter)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>Adds the specified interceptor with the specified name just after the interceptor whose name is
 <code>baseName</code> in this chain.
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html#addAfter(java.lang.String, java.lang.String, org.apache.mina.io.IoFilter)"><B>addAfter(String, String, IoFilter)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io">IoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#addAfter(java.lang.String, java.lang.String, org.apache.mina.protocol.ProtocolFilter)"><B>addAfter(String, String, ProtocolFilter)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>Adds the specified interceptor with the specified name just after the interceptor whose name is
 <code>baseName</code> in this chain.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html#addAfter(java.lang.String, java.lang.String, org.apache.mina.protocol.ProtocolFilter)"><B>addAfter(String, String, ProtocolFilter)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol">ProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#addBefore(java.lang.String, java.lang.String, org.apache.mina.io.IoFilter)"><B>addBefore(String, String, IoFilter)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>Adds the specified interceptor with the specified name just before the interceptor whose name is
 <code>baseName</code> in this chain.
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html#addBefore(java.lang.String, java.lang.String, org.apache.mina.io.IoFilter)"><B>addBefore(String, String, IoFilter)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io">IoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#addBefore(java.lang.String, java.lang.String, org.apache.mina.protocol.ProtocolFilter)"><B>addBefore(String, String, ProtocolFilter)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>Adds the specified interceptor with the specified name just before the interceptor whose name is
 <code>baseName</code> in this chain.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html#addBefore(java.lang.String, java.lang.String, org.apache.mina.protocol.ProtocolFilter)"><B>addBefore(String, String, ProtocolFilter)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol">ProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#addFirst(java.lang.String, org.apache.mina.io.IoFilter)"><B>addFirst(String, IoFilter)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>Adds the specified interceptor with the specified name at the beginning of this chain.
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html#addFirst(java.lang.String, org.apache.mina.io.IoFilter)"><B>addFirst(String, IoFilter)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io">IoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#addFirst(java.lang.String, org.apache.mina.protocol.ProtocolFilter)"><B>addFirst(String, ProtocolFilter)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>Adds the specified interceptor with the specified name at the beginning of this chain.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html#addFirst(java.lang.String, org.apache.mina.protocol.ProtocolFilter)"><B>addFirst(String, ProtocolFilter)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol">ProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#addLast(java.lang.String, org.apache.mina.io.IoFilter)"><B>addLast(String, IoFilter)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>Adds the specified interceptor with the specified name at the end of this chain.
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html#addLast(java.lang.String, org.apache.mina.io.IoFilter)"><B>addLast(String, IoFilter)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io">IoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#addLast(java.lang.String, org.apache.mina.protocol.ProtocolFilter)"><B>addLast(String, ProtocolFilter)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>Adds the specified interceptor with the specified name at the end of this chain.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html#addLast(java.lang.String, org.apache.mina.protocol.ProtocolFilter)"><B>addLast(String, ProtocolFilter)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol">ProtocolFilterChain</A>
<DD>&nbsp;
<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/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#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#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/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/BaseSession.html" title="class in org.apache.mina.common"><B>BaseSession</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Base implementation of <A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common"><CODE>Session</CODE></A>.<DT><A HREF="./org/apache/mina/common/BaseSession.html#BaseSession()"><B>BaseSession()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSessionConfig.html" title="class in org.apache.mina.common"><B>BaseSessionConfig</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Base implementation of <A HREF="./org/apache/mina/common/SessionConfig.html" title="interface in org.apache.mina.common"><CODE>SessionConfig</CODE></A>s.<DT><A HREF="./org/apache/mina/common/BaseSessionConfig.html#BaseSessionConfig()"><B>BaseSessionConfig()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionConfig.html" title="class in org.apache.mina.common">BaseSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSessionManager.html" title="class in org.apache.mina.common"><B>BaseSessionManager</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Base implementation of <A HREF="./org/apache/mina/common/SessionManager.html" title="interface in org.apache.mina.common"><CODE>SessionManager</CODE></A>s.<DT><A HREF="./org/apache/mina/common/BaseSessionManager.html#BaseSessionManager()"><B>BaseSessionManager()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionManager.html" title="class in org.apache.mina.common">BaseSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util"><B>BaseThreadPool</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A base implementation of Thread-pooling filters.<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#BaseThreadPool()"><B>BaseThreadPool()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>Creates a new instance with default thread pool settings.
<DT><A HREF="./org/apache/mina/io/datagram/DatagramAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.io.IoHandler)"><B>bind(SocketAddress, IoHandler)</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramAcceptor.html" title="class in org.apache.mina.io.datagram">DatagramAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.io.IoHandler)"><B>bind(SocketAddress, IoHandler)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoAcceptor.html" title="interface in org.apache.mina.io">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/io/socket/SocketAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.io.IoHandler)"><B>bind(SocketAddress, IoHandler)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketAcceptor.html" title="class in org.apache.mina.io.socket">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/protocol/io/IoProtocolAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.protocol.ProtocolProvider)"><B>bind(SocketAddress, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html" title="class in org.apache.mina.protocol.io">IoProtocolAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.protocol.ProtocolProvider)"><B>bind(SocketAddress, ProtocolProvider)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolAcceptor.html" title="interface in org.apache.mina.protocol">ProtocolAcceptor</A>
<DD>Binds to the specified <code>address</code> and handles incoming
 connections with the specified <code>protocolProvider</code>.
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAcceptor.html#bind(java.net.SocketAddress, org.apache.mina.protocol.ProtocolProvider)"><B>bind(SocketAddress, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#bind(org.apache.mina.registry.Service, org.apache.mina.io.IoHandler)"><B>bind(Service, IoHandler)</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>Binds the specified I/O handler to the specified service.
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#bind(org.apache.mina.registry.Service, org.apache.mina.protocol.ProtocolProvider)"><B>bind(Service, ProtocolProvider)</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>Binds the specified protocol provider to the specified service.
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#bind(org.apache.mina.registry.Service, org.apache.mina.io.IoHandler)"><B>bind(Service, IoHandler)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#bind(org.apache.mina.registry.Service, org.apache.mina.protocol.ProtocolProvider)"><B>bind(Service, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/BlacklistFilter.html" title="class in org.apache.mina.io.filter"><B>BlacklistFilter</B></A> - Class in <A HREF="./org/apache/mina/io/filter/package-summary.html">org.apache.mina.io.filter</A><DD>A <A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io"><CODE>IoFilter</CODE></A> which blocks connections from blacklisted remote
 address.<DT><A HREF="./org/apache/mina/io/filter/BlacklistFilter.html#BlacklistFilter()"><B>BlacklistFilter()</B></A> - 
Constructor for class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/BlacklistFilter.html" title="class in org.apache.mina.io.filter">BlacklistFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/BlacklistFilter.html#block(java.net.InetAddress)"><B>block(InetAddress)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/BlacklistFilter.html" title="class in org.apache.mina.io.filter">BlacklistFilter</A>
<DD>Blocks the specified endpoint.
<DT><A HREF="./org/apache/mina/util/BlockingSet.html" title="class in org.apache.mina.util"><B>BlockingSet</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/util/HashSet.html" title="class or interface in java.util"><CODE>HashSet</CODE></A> that can wait until it is not empty.<DT><A HREF="./org/apache/mina/util/BlockingSet.html#BlockingSet()"><B>BlockingSet()</B></A> - 
Constructor for class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingSet.html" title="class in org.apache.mina.util">BlockingSet</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/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/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 pooled 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/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.
</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/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/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/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/io/AbstractIoFilterChain.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>Removes all interceptors added to this chain.
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html#clear()"><B>clear()</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io">IoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#clear()"><B>clear()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>Removes all interceptors added to this chain.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html#clear()"><B>clear()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol">ProtocolFilterChain</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/registry/Service.html#clone()"><B>clone()</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry">Service</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#close()"><B>close()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#close()"><B>close()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Closes this session immediately.
<DT><A HREF="./org/apache/mina/common/Session.html#close(boolean)"><B>close(boolean)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Closes this session immediately.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#close()"><B>close()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#close(boolean)"><B>close(boolean)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/EventType.html#CLOSED"><B>CLOSED</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/EventType.html" title="class in org.apache.mina.util">EventType</A>
<DD>&nbsp;
<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(org.apache.mina.common.ByteBuffer)"><B>compareTo(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>&nbsp;
<DT><A HREF="./org/apache/mina/common/ByteBufferProxy.html#compareTo(org.apache.mina.common.ByteBuffer)"><B>compareTo(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/protocol/vmpipe/VmPipeAddress.html#compareTo(java.lang.Object)"><B>compareTo(Object)</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramConnector.html#connect(java.net.SocketAddress, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, IoHandler)</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramConnector.html" title="class in org.apache.mina.io.datagram">DatagramConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramConnector.html#connect(java.net.SocketAddress, int, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, int, IoHandler)</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramConnector.html" title="class in org.apache.mina.io.datagram">DatagramConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, int, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, SocketAddress, int, IoHandler)</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramConnector.html" title="class in org.apache.mina.io.datagram">DatagramConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, SocketAddress, IoHandler)</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramConnector.html" title="class in org.apache.mina.io.datagram">DatagramConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoConnector.html#connect(java.net.SocketAddress, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, IoHandler)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io">IoConnector</A>
<DD>Connects to the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/io/IoConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, SocketAddress, IoHandler)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io">IoConnector</A>
<DD>Connects to the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/io/IoConnector.html#connect(java.net.SocketAddress, int, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, int, IoHandler)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io">IoConnector</A>
<DD>Connects to the specified <code>address</code> with timeout.
<DT><A HREF="./org/apache/mina/io/IoConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, int, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, SocketAddress, int, IoHandler)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io">IoConnector</A>
<DD>Connects to the specified <code>address</code> with timeout.
<DT><A HREF="./org/apache/mina/io/socket/SocketConnector.html#connect(java.net.SocketAddress, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, IoHandler)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketConnector.html" title="class in org.apache.mina.io.socket">SocketConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, SocketAddress, IoHandler)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketConnector.html" title="class in org.apache.mina.io.socket">SocketConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketConnector.html#connect(java.net.SocketAddress, int, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, int, IoHandler)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketConnector.html" title="class in org.apache.mina.io.socket">SocketConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, int, org.apache.mina.io.IoHandler)"><B>connect(SocketAddress, SocketAddress, int, IoHandler)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketConnector.html" title="class in org.apache.mina.io.socket">SocketConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html#connect(java.net.SocketAddress, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io">IoProtocolConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, SocketAddress, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io">IoProtocolConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html#connect(java.net.SocketAddress, int, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, int, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io">IoProtocolConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, int, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, SocketAddress, int, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io">IoProtocolConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolConnector.html#connect(java.net.SocketAddress, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, ProtocolProvider)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolConnector.html" title="interface in org.apache.mina.protocol">ProtocolConnector</A>
<DD>Connects to the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/protocol/ProtocolConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, SocketAddress, ProtocolProvider)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolConnector.html" title="interface in org.apache.mina.protocol">ProtocolConnector</A>
<DD>Connects to the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/protocol/ProtocolConnector.html#connect(java.net.SocketAddress, int, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, int, ProtocolProvider)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolConnector.html" title="interface in org.apache.mina.protocol">ProtocolConnector</A>
<DD>Connects to the specified <code>address</code> with timeout.
<DT><A HREF="./org/apache/mina/protocol/ProtocolConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, int, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, SocketAddress, int, ProtocolProvider)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolConnector.html" title="interface in org.apache.mina.protocol">ProtocolConnector</A>
<DD>Connects to the specified <code>address</code> with timeout.
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html#connect(java.net.SocketAddress, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, SocketAddress, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html#connect(java.net.SocketAddress, int, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, int, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html#connect(java.net.SocketAddress, java.net.SocketAddress, int, org.apache.mina.protocol.ProtocolProvider)"><B>connect(SocketAddress, SocketAddress, int, ProtocolProvider)</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#createHeadFilter()"><B>createHeadFilter()</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>Override this method to create custom head of this filter chain.
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#createHeadFilter()"><B>createHeadFilter()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>Override this method to create custom head of this filter chain.
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#createTailFilter()"><B>createTailFilter()</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>Override this method to create custom tail of this filter chain.
<DT><A HREF="./org/apache/mina/io/IoSessionManagerFilterChain.html#createTailFilter()"><B>createTailFilter()</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoSessionManagerFilterChain.html" title="class in org.apache.mina.io">IoSessionManagerFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#createTailFilter()"><B>createTailFilter()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>Override this method to create custom head of this filter chain.
<DT><A HREF="./org/apache/mina/protocol/ProtocolSessionManagerFilterChain.html#createTailFilter()"><B>createTailFilter()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSessionManagerFilterChain.html" title="class in org.apache.mina.protocol">ProtocolSessionManagerFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/CumulativeProtocolDecoder.html" title="class in org.apache.mina.protocol.codec"><B>CumulativeProtocolDecoder</B></A> - Class in <A HREF="./org/apache/mina/protocol/codec/package-summary.html">org.apache.mina.protocol.codec</A><DD>A <A HREF="./org/apache/mina/protocol/ProtocolDecoder.html" title="interface in org.apache.mina.protocol"><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/protocol/codec/CumulativeProtocolDecoder.html#CumulativeProtocolDecoder(int)"><B>CumulativeProtocolDecoder(int)</B></A> - 
Constructor for class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/CumulativeProtocolDecoder.html" title="class in org.apache.mina.protocol.codec">CumulativeProtocolDecoder</A>
<DD>Creates a new instance with the specified default capacity of
 cumulative buffer.
</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/io/datagram/DatagramAcceptor.html" title="class in org.apache.mina.io.datagram"><B>DatagramAcceptor</B></A> - Class in <A HREF="./org/apache/mina/io/datagram/package-summary.html">org.apache.mina.io.datagram</A><DD><A HREF="./org/apache/mina/io/IoAcceptor.html" title="interface in org.apache.mina.io"><CODE>IoAcceptor</CODE></A> for datagram transport (UDP/IP).<DT><A HREF="./org/apache/mina/io/datagram/DatagramAcceptor.html#DatagramAcceptor()"><B>DatagramAcceptor()</B></A> - 
Constructor for class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramAcceptor.html" title="class in org.apache.mina.io.datagram">DatagramAcceptor</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/io/datagram/DatagramConnector.html" title="class in org.apache.mina.io.datagram"><B>DatagramConnector</B></A> - Class in <A HREF="./org/apache/mina/io/datagram/package-summary.html">org.apache.mina.io.datagram</A><DD><A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io"><CODE>IoConnector</CODE></A> for datagram transport (UDP/IP).<DT><A HREF="./org/apache/mina/io/datagram/DatagramConnector.html#DatagramConnector()"><B>DatagramConnector()</B></A> - 
Constructor for class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramConnector.html" title="class in org.apache.mina.io.datagram">DatagramConnector</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#datagramIoAcceptor"><B>datagramIoAcceptor</B></A> - 
Variable in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#datagramProtocolAcceptor"><B>datagramProtocolAcceptor</B></A> - 
Variable in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramSessionConfig.html" title="class in org.apache.mina.io.datagram"><B>DatagramSessionConfig</B></A> - Class in <A HREF="./org/apache/mina/io/datagram/package-summary.html">org.apache.mina.io.datagram</A><DD>A <A HREF="./org/apache/mina/common/SessionConfig.html" title="interface in org.apache.mina.common"><CODE>SessionConfig</CODE></A> for datagram transport (UDP/IP).<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#dataRead(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoSession, ByteBuffer)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/BlacklistFilter.html#dataRead(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoFilter.NextFilter, IoSession, ByteBuffer)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/BlacklistFilter.html" title="class in org.apache.mina.io.filter">BlacklistFilter</A>
<DD>Forwards event if and if only the remote address of session is not
 blacklisted.
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#dataRead(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoFilter.NextFilter, IoSession, ByteBuffer)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html#dataRead(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoFilter.NextFilter, IoSession, ByteBuffer)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter">IoThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#dataRead(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoFilter.NextFilter, IoSession, ByteBuffer)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#dataRead(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoSession, ByteBuffer)</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>Forwards read data to input stream.
<DT><A HREF="./org/apache/mina/io/IoFilter.html#dataRead(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoFilter.NextFilter, IoSession, ByteBuffer)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/io/IoHandler.html#dataRead(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><CODE>IoHandler.dataRead(IoSession, ByteBuffer)</CODE></A> event.
<DT><A HREF="./org/apache/mina/io/IoFilter.NextFilter.html#dataRead(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoSession, ByteBuffer)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.NextFilter.html" title="interface in org.apache.mina.io">IoFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilterAdapter.html#dataRead(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoFilter.NextFilter, IoSession, ByteBuffer)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterAdapter.html" title="class in org.apache.mina.io">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoHandler.html#dataRead(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoSession, ByteBuffer)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io">IoHandler</A>
<DD>Invoked when data is read from the connection.
<DT><A HREF="./org/apache/mina/io/IoHandlerAdapter.html#dataRead(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer)"><B>dataRead(IoSession, ByteBuffer)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandlerAdapter.html" title="class in org.apache.mina.io">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#dataWritten(org.apache.mina.io.IoSession, java.lang.Object)"><B>dataWritten(IoSession, Object)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#dataWritten(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, java.lang.Object)"><B>dataWritten(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html#dataWritten(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, java.lang.Object)"><B>dataWritten(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter">IoThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#dataWritten(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, java.lang.Object)"><B>dataWritten(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilter.html#dataWritten(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, java.lang.Object)"><B>dataWritten(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/io/IoHandler.html#dataWritten(org.apache.mina.io.IoSession, java.lang.Object)"><CODE>IoHandler.dataWritten(IoSession, Object)</CODE></A> event.
<DT><A HREF="./org/apache/mina/io/IoFilter.NextFilter.html#dataWritten(org.apache.mina.io.IoSession, java.lang.Object)"><B>dataWritten(IoSession, Object)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.NextFilter.html" title="interface in org.apache.mina.io">IoFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilterAdapter.html#dataWritten(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, java.lang.Object)"><B>dataWritten(IoFilter.NextFilter, IoSession, Object)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterAdapter.html" title="class in org.apache.mina.io">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoHandler.html#dataWritten(org.apache.mina.io.IoSession, java.lang.Object)"><B>dataWritten(IoSession, Object)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io">IoHandler</A>
<DD>Invoked when MINA wrote <A HREF="./org/apache/mina/io/IoSession.html#write(org.apache.mina.common.ByteBuffer, java.lang.Object)"><CODE>IoSession.write(ByteBuffer, Object)</CODE></A>
 request successfully.
<DT><A HREF="./org/apache/mina/io/IoHandlerAdapter.html#dataWritten(org.apache.mina.io.IoSession, java.lang.Object)"><B>dataWritten(IoSession, Object)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandlerAdapter.html" title="class in org.apache.mina.io">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decodable(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer)"><B>decodable(ProtocolSession, ByteBuffer)</B></A> - 
Method in interface org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html" title="interface in org.apache.mina.protocol.codec">MessageDecoder</A>
<DD>Checks the specified buffer is decodable by this decoder.
<DT><A HREF="./org/apache/mina/protocol/codec/CumulativeProtocolDecoder.html#decode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><B>decode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/CumulativeProtocolDecoder.html" title="class in org.apache.mina.protocol.codec">CumulativeProtocolDecoder</A>
<DD>Cumulates content of <tt>in</tt> into internal buffer and forwards
 decoding request to <A HREF="./org/apache/mina/protocol/codec/CumulativeProtocolDecoder.html#doDecode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><CODE>CumulativeProtocolDecoder.doDecode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><B>decode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in interface org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html" title="interface in org.apache.mina.protocol.codec">MessageDecoder</A>
<DD>Decodes binary or protocol-specific content into higher-level message objects.
<DT><A HREF="./org/apache/mina/protocol/ProtocolDecoder.html#decode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><B>decode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolDecoder.html" title="interface in org.apache.mina.protocol">ProtocolDecoder</A>
<DD>Decodes binary or protocol-specific content into higher-level message objects.
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#DEFAULT_KEEP_ALIVE_TIME"><B>DEFAULT_KEEP_ALIVE_TIME</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>Default keep-alive time of thread pool (1 min).
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#DEFAULT_MAXIMUM_POOL_SIZE"><B>DEFAULT_MAXIMUM_POOL_SIZE</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>Default maximum size of thread pool (2G).
<DT><A HREF="./org/apache/mina/common/DefaultExceptionMonitor.html" title="class in org.apache.mina.common"><B>DefaultExceptionMonitor</B></A> - Class in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>A default <A HREF="./org/apache/mina/common/ExceptionMonitor.html" title="interface in org.apache.mina.common"><CODE>ExceptionMonitor</CODE></A> implementation that logs uncaught
 exceptions using <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/logging/Logger.html" title="class or interface in java.util.logging"><CODE>Logger</CODE></A>.<DT><A HREF="./org/apache/mina/common/DefaultExceptionMonitor.html#DefaultExceptionMonitor()"><B>DefaultExceptionMonitor()</B></A> - 
Constructor for class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultExceptionMonitor.html" title="class in org.apache.mina.common">DefaultExceptionMonitor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.protocol.codec"><B>DemuxingProtocolCodecFactory</B></A> - Class in <A HREF="./org/apache/mina/protocol/codec/package-summary.html">org.apache.mina.protocol.codec</A><DD>A composite <A HREF="./org/apache/mina/protocol/ProtocolCodecFactory.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolCodecFactory</CODE></A> that consists of multiple
 <A HREF="./org/apache/mina/protocol/codec/MessageEncoder.html" title="interface in org.apache.mina.protocol.codec"><CODE>MessageEncoder</CODE></A>s and <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html" title="interface in org.apache.mina.protocol.codec"><CODE>MessageDecoder</CODE></A>s.<DT><A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html#DemuxingProtocolCodecFactory()"><B>DemuxingProtocolCodecFactory()</B></A> - 
Constructor for class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.protocol.codec">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html" title="class in org.apache.mina.protocol.handler"><B>DemuxingProtocolHandler</B></A> - Class in <A HREF="./org/apache/mina/protocol/handler/package-summary.html">org.apache.mina.protocol.handler</A><DD>A <A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolHandler</CODE></A> that demuxes <code>messageReceived</code> events
 to the appropriate <A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler"><CODE>MessageHandler</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html#DemuxingProtocolHandler()"><B>DemuxingProtocolHandler()</B></A> - 
Constructor for class org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html" title="class in org.apache.mina.protocol.handler">DemuxingProtocolHandler</A>
<DD>Creates a new instance with no registered <A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler"><CODE>MessageHandler</CODE></A>s.
<DT><A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html#deregisterMessageType(java.lang.Class)"><B>deregisterMessageType(Class)</B></A> - 
Method in class org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html" title="class in org.apache.mina.protocol.handler">DemuxingProtocolHandler</A>
<DD>Deregisters a <A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler"><CODE>MessageHandler</CODE></A> that receives the messages of
 the specified <code>type</code>.
<DT><A HREF="./org/apache/mina/protocol/codec/CumulativeProtocolDecoder.html#doDecode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><B>doDecode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/CumulativeProtocolDecoder.html" title="class in org.apache.mina.protocol.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/io/AbstractIoFilterChain.html#doWrite(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>doWrite(IoSession, ByteBuffer, Object)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoSessionFilterChain.html#doWrite(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>doWrite(IoSession, ByteBuffer, Object)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoSessionFilterChain.html" title="class in org.apache.mina.io">IoSessionFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#doWrite(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>doWrite(ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolSessionFilterChain.html#doWrite(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>doWrite(ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSessionFilterChain.html" title="class in org.apache.mina.protocol">ProtocolSessionFilterChain</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_E_"><!-- --></A><H2>
<B>E</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/protocol/ProtocolEncoder.html#encode(org.apache.mina.protocol.ProtocolSession, java.lang.Object, org.apache.mina.protocol.ProtocolEncoderOutput)"><B>encode(ProtocolSession, Object, ProtocolEncoderOutput)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolEncoder.html" title="interface in org.apache.mina.protocol">ProtocolEncoder</A>
<DD>Encodes higher-level message objects into binary or protocol-specific data.
<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/protocol/vmpipe/VmPipeAddress.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/Service.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry">Service</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/EventType.html" title="class in org.apache.mina.util"><B>EventType</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>Enumeration for MINA event types.<DT><A HREF="./org/apache/mina/util/EventType.html#EXCEPTION"><B>EXCEPTION</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/EventType.html" title="class in org.apache.mina.util">EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/DefaultExceptionMonitor.html#exceptionCaught(java.lang.Object, java.lang.Throwable)"><B>exceptionCaught(Object, Throwable)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/DefaultExceptionMonitor.html" title="class in org.apache.mina.common">DefaultExceptionMonitor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/ExceptionMonitor.html#exceptionCaught(java.lang.Object, java.lang.Throwable)"><B>exceptionCaught(Object, Throwable)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/ExceptionMonitor.html" title="interface in org.apache.mina.common">ExceptionMonitor</A>
<DD>Invoked when there are any uncaught exceptions.
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#exceptionCaught(org.apache.mina.io.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#exceptionCaught(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html#exceptionCaught(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter">IoThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#exceptionCaught(org.apache.mina.io.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>Forwards caught exceptions to input stream.
<DT><A HREF="./org/apache/mina/io/IoFilter.html#exceptionCaught(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/io/IoHandler.html#exceptionCaught(org.apache.mina.io.IoSession, java.lang.Throwable)"><CODE>IoHandler.exceptionCaught(IoSession, Throwable)</CODE></A> event.
<DT><A HREF="./org/apache/mina/io/IoFilter.NextFilter.html#exceptionCaught(org.apache.mina.io.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.NextFilter.html" title="interface in org.apache.mina.io">IoFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilterAdapter.html#exceptionCaught(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterAdapter.html" title="class in org.apache.mina.io">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoHandler.html#exceptionCaught(org.apache.mina.io.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io">IoHandler</A>
<DD>Invoked when any exception is thrown by user <A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io"><CODE>IoHandler</CODE></A>
 implementation or by MINA.
<DT><A HREF="./org/apache/mina/io/IoHandlerAdapter.html#exceptionCaught(org.apache.mina.io.IoSession, java.lang.Throwable)"><B>exceptionCaught(IoSession, Throwable)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandlerAdapter.html" title="class in org.apache.mina.io">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#exceptionCaught(org.apache.mina.protocol.ProtocolSession, java.lang.Throwable)"><B>exceptionCaught(ProtocolSession, Throwable)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#exceptionCaught(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Throwable)"><B>exceptionCaught(ProtocolFilter.NextFilter, ProtocolSession, Throwable)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html#exceptionCaught(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Throwable)"><B>exceptionCaught(ProtocolFilter.NextFilter, ProtocolSession, Throwable)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.html#exceptionCaught(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Throwable)"><B>exceptionCaught(ProtocolFilter.NextFilter, ProtocolSession, Throwable)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter</A>
<DD>Filters <A HREF="./org/apache/mina/protocol/ProtocolHandler.html#exceptionCaught(org.apache.mina.protocol.ProtocolSession, java.lang.Throwable)"><CODE>ProtocolHandler.exceptionCaught(ProtocolSession,Throwable)</CODE></A>
 event.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html#exceptionCaught(org.apache.mina.protocol.ProtocolSession, java.lang.Throwable)"><B>exceptionCaught(ProtocolSession, Throwable)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html#exceptionCaught(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Throwable)"><B>exceptionCaught(ProtocolFilter.NextFilter, ProtocolSession, Throwable)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html" title="class in org.apache.mina.protocol">ProtocolFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandler.html#exceptionCaught(org.apache.mina.protocol.ProtocolSession, java.lang.Throwable)"><B>exceptionCaught(ProtocolSession, Throwable)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol">ProtocolHandler</A>
<DD>Invoked when any exception is thrown by user <A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolHandler</CODE></A>
 implementation or by MINA.
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html#exceptionCaught(org.apache.mina.protocol.ProtocolSession, java.lang.Throwable)"><B>exceptionCaught(ProtocolSession, Throwable)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html" title="class in org.apache.mina.protocol">ProtocolHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSessionManager.html#exceptionMonitor"><B>exceptionMonitor</B></A> - 
Variable in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionManager.html" title="class in org.apache.mina.common">BaseSessionManager</A>
<DD>Current exception monitor.
<DT><A HREF="./org/apache/mina/common/ExceptionMonitor.html" title="interface in org.apache.mina.common"><B>ExceptionMonitor</B></A> - Interface 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/util/ExceptionUtil.html" title="class in org.apache.mina.util"><B>ExceptionUtil</B></A> - Class in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>Exception utility.</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/io/AbstractIoFilterChain.html#filterWrite(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>filterWrite(IoSession, ByteBuffer, Object)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#filterWrite(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>filterWrite(IoFilter.NextFilter, IoSession, ByteBuffer, Object)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html#filterWrite(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>filterWrite(IoFilter.NextFilter, IoSession, ByteBuffer, Object)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter">IoThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#filterWrite(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>filterWrite(IoFilter.NextFilter, IoSession, ByteBuffer, Object)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilter.html#filterWrite(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>filterWrite(IoFilter.NextFilter, IoSession, ByteBuffer, Object)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/io/IoSession.html#write(org.apache.mina.common.ByteBuffer, java.lang.Object)"><CODE>IoSession.write(ByteBuffer, Object)</CODE></A> method invocation.
<DT><A HREF="./org/apache/mina/io/IoFilter.NextFilter.html#filterWrite(org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>filterWrite(IoSession, ByteBuffer, Object)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.NextFilter.html" title="interface in org.apache.mina.io">IoFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilterAdapter.html#filterWrite(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>filterWrite(IoFilter.NextFilter, IoSession, ByteBuffer, Object)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterAdapter.html" title="class in org.apache.mina.io">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#filterWrite(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>filterWrite(ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#filterWrite(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>filterWrite(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html#filterWrite(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>filterWrite(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.html#filterWrite(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>filterWrite(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter</A>
<DD>Filters <A HREF="./org/apache/mina/protocol/ProtocolSession.html#write(java.lang.Object)"><CODE>ProtocolSession.write(Object)</CODE></A> method invocation.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html#filterWrite(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>filterWrite(ProtocolSession, Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html#filterWrite(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>filterWrite(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html" title="class in org.apache.mina.protocol">ProtocolFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#findIoAcceptor(org.apache.mina.common.TransportType)"><B>findIoAcceptor(TransportType)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#findProtocolAcceptor(org.apache.mina.common.TransportType)"><B>findProtocolAcceptor(TransportType)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#fireEvent(java.lang.Object, org.apache.mina.common.Session, org.apache.mina.util.EventType, java.lang.Object)"><B>fireEvent(Object, Session, EventType, Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>&nbsp;
<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;
</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/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/registry/Service.html#getAddress()"><B>getAddress()</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry">Service</A>
<DD>Returns the socket address this service is bound on.
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#getAllServices()"><B>getAllServices()</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>Returns <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 all services bound in this registry.
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#getAllServices()"><B>getAllServices()</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#getAttachment()"><B>getAttachment()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getAttachment()"><B>getAttachment()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns an attachment of this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getAttachment()"><B>getAttachment()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#getAttribute(java.lang.String)"><B>getAttribute(String)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getAttribute(java.lang.String)"><B>getAttribute(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the value of user-defined attribute of this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getAttribute(java.lang.String)"><B>getAttribute(String)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#getAttributeKeys()"><B>getAttributeKeys()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getAttributeKeys()"><B>getAttributeKeys()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the set of keys of all user-defined attributes.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getAttributeKeys()"><B>getAttributeKeys()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<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/io/socket/SocketAcceptor.html#getBacklog()"><B>getBacklog()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketAcceptor.html" title="class in org.apache.mina.io.socket">SocketAcceptor</A>
<DD>Returns the default backlog value which is used when user binds.
<DT><A HREF="./org/apache/mina/protocol/ProtocolViolationException.html#getBuffer()"><B>getBuffer()</B></A> - 
Method in exception org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolViolationException.html" title="class in org.apache.mina.protocol">ProtocolViolationException</A>
<DD>Returns unknown message part.
<DT><A HREF="./org/apache/mina/protocol/SimpleProtocolEncoderOutput.html#getBufferQueue()"><B>getBufferQueue()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/SimpleProtocolEncoderOutput.html" title="class in org.apache.mina.protocol">SimpleProtocolEncoderOutput</A>
<DD>&nbsp;
<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/io/AbstractIoFilterChain.html#getChild(java.lang.String)"><B>getChild(String)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html#getChild(java.lang.String)"><B>getChild(String)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io">IoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#getChild(java.lang.String)"><B>getChild(String)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html#getChild(java.lang.String)"><B>getChild(String)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol">ProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#getChildren()"><B>getChildren()</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html#getChildren()"><B>getChildren()</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io">IoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#getChildren()"><B>getChildren()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html#getChildren()"><B>getChildren()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol">ProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#getChildrenReversed()"><B>getChildrenReversed()</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html#getChildrenReversed()"><B>getChildrenReversed()</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io">IoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#getChildrenReversed()"><B>getChildrenReversed()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html#getChildrenReversed()"><B>getChildrenReversed()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol">ProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolProvider.html#getCodecFactory()"><B>getCodecFactory()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolProvider.html" title="interface in org.apache.mina.protocol">ProtocolProvider</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getConfig()"><B>getConfig()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the configuration of this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getConfig()"><B>getConfig()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getDecoder()"><B>getDecoder()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolSession.html#getDecoder()"><B>getDecoder()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSession.html" title="interface in org.apache.mina.protocol">ProtocolSession</A>
<DD>Returns the <A HREF="./org/apache/mina/protocol/ProtocolDecoder.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolDecoder</CODE></A> for this session.
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#getDefaultLevel()"><B>getDefaultLevel()</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>Returns the default level of log entry this filter logs.
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#getDefaultLevel()"><B>getDefaultLevel()</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>Returns the default level of log entry this filter logs.
<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/io/filter/SSLFilter.html#getEnabledCipherSuites()"><B>getEnabledCipherSuites()</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.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/io/filter/SSLFilter.html#getEnabledProtocols()"><B>getEnabledProtocols()</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.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/protocol/io/IoProtocolSession.html#getEncoder()"><B>getEncoder()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolSession.html#getEncoder()"><B>getEncoder()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSession.html" title="interface in org.apache.mina.protocol">ProtocolSession</A>
<DD>Returns the <A HREF="./org/apache/mina/protocol/ProtocolEncoder.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolEncoder</CODE></A> for this session.
<DT><A HREF="./org/apache/mina/common/BaseSessionManager.html#getExceptionMonitor()"><B>getExceptionMonitor()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionManager.html" title="class in org.apache.mina.common">BaseSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SessionManager.html#getExceptionMonitor()"><B>getExceptionMonitor()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/SessionManager.html" title="interface in org.apache.mina.common">SessionManager</A>
<DD>Returns the current exception monitor.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html#getExceptionMonitor()"><B>getExceptionMonitor()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html" title="class in org.apache.mina.protocol.io">IoProtocolAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html#getExceptionMonitor()"><B>getExceptionMonitor()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io">IoProtocolConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramAcceptor.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramAcceptor.html" title="class in org.apache.mina.io.datagram">DatagramAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramConnector.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramConnector.html" title="class in org.apache.mina.io.datagram">DatagramConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoSession.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoSession.html" title="interface in org.apache.mina.io">IoSession</A>
<DD>Returns the filter chain that only affects this session.
<DT><A HREF="./org/apache/mina/io/IoSessionManager.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoSessionManager.html" title="interface in org.apache.mina.io">IoSessionManager</A>
<DD>Returns the filter chain that filters all events which is related
 with sessions this manager manages.
<DT><A HREF="./org/apache/mina/io/socket/SocketAcceptor.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketAcceptor.html" title="class in org.apache.mina.io.socket">SocketAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketConnector.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketConnector.html" title="class in org.apache.mina.io.socket">SocketConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html" title="class in org.apache.mina.protocol.io">IoProtocolAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io">IoProtocolConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolSession.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSession.html" title="interface in org.apache.mina.protocol">ProtocolSession</A>
<DD>Returns the filter chain that only affects this session.
<DT><A HREF="./org/apache/mina/protocol/ProtocolSessionManager.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSessionManager.html" title="interface in org.apache.mina.protocol">ProtocolSessionManager</A>
<DD>Returns the filter chain that filters all events which is related
 with sessions this manager manages.
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAcceptor.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html#getFilterChain()"><B>getFilterChain()</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeConnector</A>
<DD>&nbsp;
<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/io/IoSession.html#getHandler()"><B>getHandler()</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoSession.html" title="interface in org.apache.mina.io">IoSession</A>
<DD>Returns the event handler for this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getHandler()"><B>getHandler()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolProvider.html#getHandler()"><B>getHandler()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolProvider.html" title="interface in org.apache.mina.protocol">ProtocolProvider</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolSession.html#getHandler()"><B>getHandler()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSession.html" title="interface in org.apache.mina.protocol">ProtocolSession</A>
<DD>Returns the <A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolHandler</CODE></A> which handles this session.
<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/common/BaseSessionConfig.html#getIdleTime(org.apache.mina.common.IdleStatus)"><B>getIdleTime(IdleStatus)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionConfig.html" title="class in org.apache.mina.common">BaseSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SessionConfig.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/SessionConfig.html" title="interface in org.apache.mina.common">SessionConfig</A>
<DD>Returns idle time for the specified type of idleness in seconds.
<DT><A HREF="./org/apache/mina/common/BaseSessionConfig.html#getIdleTimeInMillis(org.apache.mina.common.IdleStatus)"><B>getIdleTimeInMillis(IdleStatus)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionConfig.html" title="class in org.apache.mina.common">BaseSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SessionConfig.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/SessionConfig.html" title="interface in org.apache.mina.common">SessionConfig</A>
<DD>Returnd idle time for the specified type of idleness in milliseconds.
<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/protocol/io/IoProtocolAcceptor.html#getIoAcceptor()"><B>getIoAcceptor()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html" title="class in org.apache.mina.protocol.io">IoProtocolAcceptor</A>
<DD>Returns the underlying <A HREF="./org/apache/mina/io/IoAcceptor.html" title="interface in org.apache.mina.io"><CODE>IoAcceptor</CODE></A> instance this acceptor is
 wrapping.
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#getIoAcceptor(org.apache.mina.common.TransportType)"><B>getIoAcceptor(TransportType)</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#getIoAcceptor(org.apache.mina.common.TransportType)"><B>getIoAcceptor(TransportType)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html#getIoConnector()"><B>getIoConnector()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io">IoProtocolConnector</A>
<DD>Returns the underlying <A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io"><CODE>IoConnector</CODE></A> instance this acceptor is
 wrapping.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getIoSession()"><B>getIoSession()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>Returns the <A HREF="./org/apache/mina/io/IoSession.html" title="interface in org.apache.mina.io"><CODE>IoSession</CODE></A> this session is backed by.
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#getKeepAlive()"><B>getKeepAlive()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#getKeepAliveTime()"><B>getKeepAliveTime()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ThreadPool.html#getKeepAliveTime()"><B>getKeepAliveTime()</B></A> - 
Method in interface org.apache.mina.util.<A HREF="./org/apache/mina/util/ThreadPool.html" title="interface in org.apache.mina.util">ThreadPool</A>
<DD>Returns the keep-alive time until the thread suicides after it became
 idle (milliseconds unit).
<DT><A HREF="./org/apache/mina/common/BaseSession.html#getLastIoTime()"><B>getLastIoTime()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getLastIoTime()"><B>getLastIoTime()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the time in millis when I/O occurred lastly.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getLastIoTime()"><B>getLastIoTime()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#getLastReadTime()"><B>getLastReadTime()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getLastReadTime()"><B>getLastReadTime()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the time in millis when read operation occurred lastly.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getLastReadTime()"><B>getLastReadTime()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#getLastWriteTime()"><B>getLastWriteTime()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getLastWriteTime()"><B>getLastWriteTime()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the time in millis when write operation occurred lastly.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getLastWriteTime()"><B>getLastWriteTime()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getLocalAddress()"><B>getLocalAddress()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the socket address of local machine which is associated with this
 session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getLocalAddress()"><B>getLocalAddress()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/SessionLog.html#getLogger(org.apache.mina.common.Session)"><B>getLogger(Session)</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#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/io/IoSessionManagerFilterChain.html#getManager()"><B>getManager()</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoSessionManagerFilterChain.html" title="class in org.apache.mina.io">IoSessionManagerFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolSessionManagerFilterChain.html#getManager()"><B>getManager()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSessionManagerFilterChain.html" title="class in org.apache.mina.protocol">ProtocolSessionManagerFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#getMaximumPoolSize()"><B>getMaximumPoolSize()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ThreadPool.html#getMaximumPoolSize()"><B>getMaximumPoolSize()</B></A> - 
Method in interface org.apache.mina.util.<A HREF="./org/apache/mina/util/ThreadPool.html" title="interface in org.apache.mina.util">ThreadPool</A>
<DD>Returns the maximum size of the thread pool.
<DT><A HREF="./org/apache/mina/protocol/ProtocolViolationException.html#getMessage()"><B>getMessage()</B></A> - 
Method in exception org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolViolationException.html" title="class in org.apache.mina.protocol">ProtocolViolationException</A>
<DD>Returns the message and the hexdump of the unknown part.
<DT><A HREF="./org/apache/mina/protocol/SimpleProtocolDecoderOutput.html#getMessageQueue()"><B>getMessageQueue()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/SimpleProtocolDecoderOutput.html" title="class in org.apache.mina.protocol">SimpleProtocolDecoderOutput</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/MessageEncoder.html#getMessageTypes()"><B>getMessageTypes()</B></A> - 
Method in interface org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageEncoder.html" title="interface in org.apache.mina.protocol.codec">MessageEncoder</A>
<DD>Returns the set of message classes this encoder can encode.
<DT><A HREF="./org/apache/mina/registry/Service.html#getName()"><B>getName()</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry">Service</A>
<DD>Returns the name of this service (protocol).
<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/io/socket/SocketSessionConfig.html#getOOBInline()"><B>getOOBInline()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#getPoolSize()"><B>getPoolSize()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ThreadPool.html#getPoolSize()"><B>getPoolSize()</B></A> - 
Method in interface org.apache.mina.util.<A HREF="./org/apache/mina/util/ThreadPool.html" title="interface in org.apache.mina.util">ThreadPool</A>
<DD>Returns the number of threads in the thread pool.
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html#getPort()"><B>getPort()</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAddress</A>
<DD>Returns the port number.
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#getProtocolAcceptor(org.apache.mina.common.TransportType)"><B>getProtocolAcceptor(TransportType)</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#getProtocolAcceptor(org.apache.mina.common.TransportType)"><B>getProtocolAcceptor(TransportType)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#getReadBytes()"><B>getReadBytes()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getReadBytes()"><B>getReadBytes()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the total number of bytes which were read from this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getReadBytes()"><B>getReadBytes()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#getReadTimeout()"><B>getReadTimeout()</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>Returns read timeout in seconds.
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#getReceiveBufferSize()"><B>getReceiveBufferSize()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getRemoteAddress()"><B>getRemoteAddress()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the socket address of remote peer.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getRemoteAddress()"><B>getRemoteAddress()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramSessionConfig.html#getReuseAddress()"><B>getReuseAddress()</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramSessionConfig.html" title="class in org.apache.mina.io.datagram">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#getReuseAddress()"><B>getReuseAddress()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getScheduledWriteRequests()"><B>getScheduledWriteRequests()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the number of write requests which are scheduled to be written
 to this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getScheduledWriteRequests()"><B>getScheduledWriteRequests()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#getSendBufferSize()"><B>getSendBufferSize()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#getServices(java.lang.String)"><B>getServices(String)</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>Returns <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 services bound in this registry with the
 specified service(or protocol) name.
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#getServices(org.apache.mina.common.TransportType)"><B>getServices(TransportType)</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>Returns <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 services bound in this registry with the
 specified transport type.
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#getServices(int)"><B>getServices(int)</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>Returns <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 services bound in this registry with the
 specified port number.
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#getServices(java.lang.String)"><B>getServices(String)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#getServices(org.apache.mina.common.TransportType)"><B>getServices(TransportType)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#getServices(int)"><B>getServices(int)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#getSessionReceiveBufferSize()"><B>getSessionReceiveBufferSize()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<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/io/socket/SocketSessionConfig.html#getSoLinger()"><B>getSoLinger()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#getSSLSession(org.apache.mina.io.IoSession)"><B>getSSLSession(IoSession)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.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/io/socket/SocketSessionConfig.html#getTcpNoDelay()"><B>getTcpNoDelay()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramSessionConfig.html#getTrafficClass()"><B>getTrafficClass()</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramSessionConfig.html" title="class in org.apache.mina.io.datagram">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#getTrafficClass()"><B>getTrafficClass()</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getTransportType()"><B>getTransportType()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns transport type of this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getTransportType()"><B>getTransportType()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/Service.html#getTransportType()"><B>getTransportType()</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry">Service</A>
<DD>Returns the transport type this service uses.
<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>&nbsp;
<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>&nbsp;
<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>&nbsp;
<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>&nbsp;
<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>&nbsp;
<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>&nbsp;
<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/common/BaseSessionConfig.html#getWriteTimeout()"><B>getWriteTimeout()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionConfig.html" title="class in org.apache.mina.common">BaseSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SessionConfig.html#getWriteTimeout()"><B>getWriteTimeout()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/SessionConfig.html" title="interface in org.apache.mina.common">SessionConfig</A>
<DD>Returns write timeout in seconds.
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#getWriteTimeout()"><B>getWriteTimeout()</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>Returns write timeout in seconds.
<DT><A HREF="./org/apache/mina/common/BaseSessionConfig.html#getWriteTimeoutInMillis()"><B>getWriteTimeoutInMillis()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionConfig.html" title="class in org.apache.mina.common">BaseSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SessionConfig.html#getWriteTimeoutInMillis()"><B>getWriteTimeoutInMillis()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/SessionConfig.html" title="interface in org.apache.mina.common">SessionConfig</A>
<DD>Returns write timeout in milliseconds.
<DT><A HREF="./org/apache/mina/common/BaseSession.html#getWrittenBytes()"><B>getWrittenBytes()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getWrittenBytes()"><B>getWrittenBytes()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the total number of bytes which were written to this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getWrittenBytes()"><B>getWrittenBytes()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#getWrittenWriteRequests()"><B>getWrittenWriteRequests()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#getWrittenWriteRequests()"><B>getWrittenWriteRequests()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns the total number of write requests which were written to this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#getWrittenWriteRequests()"><B>getWrittenWriteRequests()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_H_"><!-- --></A><H2>
<B>H</B></H2>
<DL>
<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/protocol/vmpipe/VmPipeAddress.html#hashCode()"><B>hashCode()</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/Service.html#hashCode()"><B>hashCode()</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry">Service</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/EventType.html#IDLE"><B>IDLE</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/EventType.html" title="class in org.apache.mina.util">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/io/IoSession.html" title="interface in org.apache.mina.io"><CODE>IoSession</CODE></A> or
 <A HREF="./org/apache/mina/protocol/ProtocolSession.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolSession</CODE></A>.<DT><A HREF="./org/apache/mina/common/BaseSession.html#increaseReadBytes(int)"><B>increaseReadBytes(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#increaseWrittenBytes(int)"><B>increaseWrittenBytes(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#increaseWrittenWriteRequests()"><B>increaseWrittenWriteRequests()</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/SessionUtil.html#initialize(org.apache.mina.common.Session)"><B>initialize(Session)</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/io/IoAcceptor.html" title="interface in org.apache.mina.io"><B>IoAcceptor</B></A> - Interface in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>Accepts incoming connection, communicates with clients, and fires events to
 <A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io"><CODE>IoHandler</CODE></A>s.<DT><A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io"><B>IoConnector</B></A> - Interface in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>Connects to endpoint, communicates with the server, and fires events to
 <A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io"><CODE>IoHandler</CODE></A>s.<DT><A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io"><B>IoFilter</B></A> - Interface in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>A filter which intercepts <A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io"><CODE>IoHandler</CODE></A> events like Servlet filters.<DT><A HREF="./org/apache/mina/io/IoFilter.NextFilter.html" title="interface in org.apache.mina.io"><B>IoFilter.NextFilter</B></A> - Interface in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/io/IoFilterAdapter.html" title="class in org.apache.mina.io"><B>IoFilterAdapter</B></A> - Class in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>An abstract adapter class for <A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io"><CODE>IoFilter</CODE></A>.<DT><A HREF="./org/apache/mina/io/IoFilterAdapter.html#IoFilterAdapter()"><B>IoFilterAdapter()</B></A> - 
Constructor for class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterAdapter.html" title="class in org.apache.mina.io">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io"><B>IoFilterChain</B></A> - Interface in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io"><B>IoHandler</B></A> - Interface in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>Handles all I/O events fired by <A HREF="./org/apache/mina/io/IoAcceptor.html" title="interface in org.apache.mina.io"><CODE>IoAcceptor</CODE></A> and <A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io"><CODE>IoConnector</CODE></A>.<DT><A HREF="./org/apache/mina/io/IoHandlerAdapter.html" title="class in org.apache.mina.io"><B>IoHandlerAdapter</B></A> - Class in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>An abstract adapter class for <A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io"><CODE>IoHandler</CODE></A>.<DT><A HREF="./org/apache/mina/io/IoHandlerAdapter.html#IoHandlerAdapter()"><B>IoHandlerAdapter()</B></A> - 
Constructor for class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandlerAdapter.html" title="class in org.apache.mina.io">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter"><B>IoLoggingFilter</B></A> - Class in <A HREF="./org/apache/mina/io/filter/package-summary.html">org.apache.mina.io.filter</A><DD>Logs all MINA I/O events to <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/logging/Logger.html" title="class or interface in java.util.logging"><CODE>Logger</CODE></A>.<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#IoLoggingFilter()"><B>IoLoggingFilter()</B></A> - 
Constructor for class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html" title="class in org.apache.mina.protocol.io"><B>IoProtocolAcceptor</B></A> - Class in <A HREF="./org/apache/mina/protocol/io/package-summary.html">org.apache.mina.protocol.io</A><DD>A <A HREF="./org/apache/mina/protocol/ProtocolAcceptor.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolAcceptor</CODE></A> which wraps <A HREF="./org/apache/mina/io/IoAcceptor.html" title="interface in org.apache.mina.io"><CODE>IoAcceptor</CODE></A> to provide
 low-level I/O.<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html#IoProtocolAcceptor(org.apache.mina.io.IoAcceptor)"><B>IoProtocolAcceptor(IoAcceptor)</B></A> - 
Constructor for class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html" title="class in org.apache.mina.protocol.io">IoProtocolAcceptor</A>
<DD>Creates a new instance with the specified <A HREF="./org/apache/mina/io/IoAcceptor.html" title="interface in org.apache.mina.io"><CODE>IoAcceptor</CODE></A>.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io"><B>IoProtocolConnector</B></A> - Class in <A HREF="./org/apache/mina/protocol/io/package-summary.html">org.apache.mina.protocol.io</A><DD>A <A HREF="./org/apache/mina/protocol/ProtocolConnector.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolConnector</CODE></A> which wraps <A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io"><CODE>IoConnector</CODE></A> to provide
 low-level I/O.<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html#IoProtocolConnector(org.apache.mina.io.IoConnector)"><B>IoProtocolConnector(IoConnector)</B></A> - 
Constructor for class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io">IoProtocolConnector</A>
<DD>Creates a new instance with the specified <A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io"><CODE>IoConnector</CODE></A>.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io"><B>IoProtocolSession</B></A> - Class in <A HREF="./org/apache/mina/protocol/io/package-summary.html">org.apache.mina.protocol.io</A><DD>A <A HREF="./org/apache/mina/protocol/ProtocolSession.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolSession</CODE></A> that is backed by <A HREF="./org/apache/mina/io/IoSession.html" title="interface in org.apache.mina.io"><CODE>IoSession</CODE></A>.<DT><A HREF="./org/apache/mina/io/IoSession.html" title="interface in org.apache.mina.io"><B>IoSession</B></A> - Interface in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>A <A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common"><CODE>Session</CODE></A> that represents low-level I/O connection between two
 endpoints regardless of underlying transport types.<DT><A HREF="./org/apache/mina/io/IoSessionFilterChain.html" title="class in org.apache.mina.io"><B>IoSessionFilterChain</B></A> - Class in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>An <A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io"><CODE>IoFilterChain</CODE></A> that forwards <tt>filterWrite</tt>
 requests to the specified <A HREF="./org/apache/mina/io/IoSessionManagerFilterChain.html" title="class in org.apache.mina.io"><CODE>IoSessionManagerFilterChain</CODE></A>.<DT><A HREF="./org/apache/mina/io/IoSessionFilterChain.html#IoSessionFilterChain(org.apache.mina.io.IoSessionManagerFilterChain)"><B>IoSessionFilterChain(IoSessionManagerFilterChain)</B></A> - 
Constructor for class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoSessionFilterChain.html" title="class in org.apache.mina.io">IoSessionFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoSessionManager.html" title="interface in org.apache.mina.io"><B>IoSessionManager</B></A> - Interface in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>A <A HREF="./org/apache/mina/common/SessionManager.html" title="interface in org.apache.mina.common"><CODE>SessionManager</CODE></A> for I/O layer.<DT><A HREF="./org/apache/mina/io/IoSessionManagerFilterChain.html" title="class in org.apache.mina.io"><B>IoSessionManagerFilterChain</B></A> - Class in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</A><DD>An <A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io"><CODE>IoFilterChain</CODE></A> that forwards all events
 except <tt>filterWrite</tt> to the <A HREF="./org/apache/mina/io/IoSessionFilterChain.html" title="class in org.apache.mina.io"><CODE>IoSessionFilterChain</CODE></A>
 of the recipient session.<DT><A HREF="./org/apache/mina/io/IoSessionManagerFilterChain.html#IoSessionManagerFilterChain(org.apache.mina.io.IoSessionManager)"><B>IoSessionManagerFilterChain(IoSessionManager)</B></A> - 
Constructor for class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoSessionManagerFilterChain.html" title="class in org.apache.mina.io">IoSessionManagerFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter"><B>IoThreadPoolFilter</B></A> - Class in <A HREF="./org/apache/mina/io/filter/package-summary.html">org.apache.mina.io.filter</A><DD>A Thread-pooling filter.<DT><A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html#IoThreadPoolFilter()"><B>IoThreadPoolFilter()</B></A> - 
Constructor for class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter">IoThreadPoolFilter</A>
<DD>Creates a new instanceof this filter with default thread pool settings.
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#ioThreadPoolFilter"><B>ioThreadPoolFilter</B></A> - 
Variable in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</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/common/Session.html#isConnected()"><B>isConnected()</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Returns <code>true</code> if this session is connected with remote peer.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#isConnected()"><B>isConnected()</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</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/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/common/BaseSession.html#isIdle(org.apache.mina.common.IdleStatus)"><B>isIdle(IdleStatus)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.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/Session.html" title="interface in org.apache.mina.common">Session</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/protocol/io/IoProtocolSession.html#isIdle(org.apache.mina.common.IdleStatus)"><B>isIdle(IdleStatus)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#isNeedClientAuth()"><B>isNeedClientAuth()</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>Returns <tt>true</tt> if the engine will <em>require</em> client authentication.
<DT><A HREF="./org/apache/mina/common/TransportType.html#isStateless()"><B>isStateless()</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
 stateless.
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#isUseClientMode()"><B>isUseClientMode()</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.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/io/filter/SSLFilter.html#isWantClientAuth()"><B>isWantClientAuth()</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>Returns <tt>true</tt> if the engine will <em>request</em> client authentication.
<DT><A HREF="./org/apache/mina/util/BlockingSet.html#iterator()"><B>iterator()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingSet.html" title="class in org.apache.mina.util">BlockingSet</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_L_"><!-- --></A><H2>
<B>L</B></H2>
<DL>
<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>&nbsp;
<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/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/util/SessionLog.html#log(java.util.logging.Level, org.apache.mina.common.Session, java.lang.String)"><B>log(Level, Session, 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#log(java.util.logging.Level, org.apache.mina.common.Session, java.lang.String, java.lang.Throwable)"><B>log(Level, Session, 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/io/filter/IoLoggingFilter.html#LOGGER"><B>LOGGER</B></A> - 
Static variable in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>Session attribute key: <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/logging/Logger.html" title="class or interface in java.util.logging"><CODE>Logger</CODE></A>
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#LOGGER"><B>LOGGER</B></A> - 
Static variable in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>Session attribute key: <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/logging/Logger.html" title="class or interface in java.util.logging"><CODE>Logger</CODE></A>
<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: <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/logging/Logger.html" title="class or interface in java.util.logging"><CODE>Logger</CODE></A>
</DL>
<HR>
<A NAME="_M_"><!-- --></A><H2>
<B>M</B></H2>
<DL>
<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/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/protocol/ProtocolEncoderOutput.html#mergeAll()"><B>mergeAll()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolEncoderOutput.html" title="interface in org.apache.mina.protocol">ProtocolEncoderOutput</A>
<DD>Merges all buffers you wrote via <A HREF="./org/apache/mina/protocol/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/protocol/SimpleProtocolEncoderOutput.html#mergeAll()"><B>mergeAll()</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/SimpleProtocolEncoderOutput.html" title="class in org.apache.mina.protocol">SimpleProtocolEncoderOutput</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html" title="interface in org.apache.mina.protocol.codec"><B>MessageDecoder</B></A> - Interface in <A HREF="./org/apache/mina/protocol/codec/package-summary.html">org.apache.mina.protocol.codec</A><DD>Decodes specific messages.<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoderFactory.html" title="interface in org.apache.mina.protocol.codec"><B>MessageDecoderFactory</B></A> - Interface in <A HREF="./org/apache/mina/protocol/codec/package-summary.html">org.apache.mina.protocol.codec</A><DD>A factory that creates a new instance of <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html" title="interface in org.apache.mina.protocol.codec"><CODE>MessageDecoder</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoderResult.html" title="class in org.apache.mina.protocol.codec"><B>MessageDecoderResult</B></A> - Class in <A HREF="./org/apache/mina/protocol/codec/package-summary.html">org.apache.mina.protocol.codec</A><DD>Represents results from <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html" title="interface in org.apache.mina.protocol.codec"><CODE>MessageDecoder</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/codec/MessageEncoder.html" title="interface in org.apache.mina.protocol.codec"><B>MessageEncoder</B></A> - Interface in <A HREF="./org/apache/mina/protocol/codec/package-summary.html">org.apache.mina.protocol.codec</A><DD>Encodes messages of specific types specified by <A HREF="./org/apache/mina/protocol/codec/MessageEncoder.html#getMessageTypes()"><CODE>MessageEncoder.getMessageTypes()</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/codec/MessageEncoderFactory.html" title="interface in org.apache.mina.protocol.codec"><B>MessageEncoderFactory</B></A> - Interface in <A HREF="./org/apache/mina/protocol/codec/package-summary.html">org.apache.mina.protocol.codec</A><DD>A factory that creates a new instance of <A HREF="./org/apache/mina/protocol/codec/MessageEncoder.html" title="interface in org.apache.mina.protocol.codec"><CODE>MessageEncoder</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler"><B>MessageHandler</B></A> - Interface in <A HREF="./org/apache/mina/protocol/handler/package-summary.html">org.apache.mina.protocol.handler</A><DD>A handler interface that <A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html" title="class in org.apache.mina.protocol.handler"><CODE>DemuxingProtocolHandler</CODE></A> forwards
 <code>messageReceived</code> events to.<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#messageReceived(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#messageReceived(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html#messageReceived(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html#messageReceived(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html" title="class in org.apache.mina.protocol.handler">DemuxingProtocolHandler</A>
<DD>Forwards the received events into the appropriate <A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler"><CODE>MessageHandler</CODE></A>
 which is registered by <A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html#registerMessageType(java.lang.Class, org.apache.mina.protocol.handler.MessageHandler)"><CODE>DemuxingProtocolHandler.registerMessageType(Class, MessageHandler)</CODE></A>.
<DT><A HREF="./org/apache/mina/protocol/handler/MessageHandler.html#messageReceived(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolSession, Object)</B></A> - 
Method in interface org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler">MessageHandler</A>
<DD>Invoked when the specific type of message is received from the
 specified <code>session</code>.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.html#messageReceived(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter</A>
<DD>Filters <A HREF="./org/apache/mina/protocol/ProtocolHandler.html#messageReceived(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><CODE>ProtocolHandler.messageReceived(ProtocolSession,Object)</CODE></A>
 event.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html#messageReceived(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolSession, Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html#messageReceived(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html" title="class in org.apache.mina.protocol">ProtocolFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandler.html#messageReceived(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolSession, Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol">ProtocolHandler</A>
<DD>Invoked when protocol message is received.
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html#messageReceived(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageReceived(ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html" title="class in org.apache.mina.protocol">ProtocolHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#messageSent(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageSent(ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#messageSent(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageSent(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html#messageSent(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageSent(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.html#messageSent(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageSent(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter</A>
<DD>Filters <A HREF="./org/apache/mina/protocol/ProtocolHandler.html#messageSent(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><CODE>ProtocolHandler.messageSent(ProtocolSession,Object)</CODE></A>
 event.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html#messageSent(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageSent(ProtocolSession, Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html#messageSent(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageSent(ProtocolFilter.NextFilter, ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html" title="class in org.apache.mina.protocol">ProtocolFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandler.html#messageSent(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageSent(ProtocolSession, Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol">ProtocolHandler</A>
<DD>Invoked when protocol message that user requested by
 <A HREF="./org/apache/mina/protocol/ProtocolSession.html#write(java.lang.Object)"><CODE>ProtocolSession.write(Object)</CODE></A> is sent out actually.
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html#messageSent(org.apache.mina.protocol.ProtocolSession, java.lang.Object)"><B>messageSent(ProtocolSession, Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html" title="class in org.apache.mina.protocol">ProtocolHandlerAdapter</A>
<DD>&nbsp;
<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/protocol/codec/MessageDecoder.html#NEED_DATA"><B>NEED_DATA</B></A> - 
Static variable in interface org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html" title="interface in org.apache.mina.protocol.codec">MessageDecoder</A>
<DD>Represents a result from <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decodable(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(ProtocolSession, ByteBuffer)</CODE></A> and
 <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoderResult.html#NEED_DATA"><B>NEED_DATA</B></A> - 
Static variable in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoderResult.html" title="class in org.apache.mina.protocol.codec">MessageDecoderResult</A>
<DD>Represents a result from <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decodable(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(ProtocolSession, ByteBuffer)</CODE></A>
 and <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html#newDecoder()"><B>newDecoder()</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.protocol.codec">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoderFactory.html#newDecoder()"><B>newDecoder()</B></A> - 
Method in interface org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoderFactory.html" title="interface in org.apache.mina.protocol.codec">MessageDecoderFactory</A>
<DD>Creates a new message decoder.
<DT><A HREF="./org/apache/mina/protocol/ProtocolCodecFactory.html#newDecoder()"><B>newDecoder()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolCodecFactory.html" title="interface in org.apache.mina.protocol">ProtocolCodecFactory</A>
<DD>Creates a new instance of <A HREF="./org/apache/mina/protocol/ProtocolDecoder.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolDecoder</CODE></A> which decodes binary or
 protocol-specific data into message objects.
<DT><A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html#newEncoder()"><B>newEncoder()</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.protocol.codec">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/MessageEncoderFactory.html#newEncoder()"><B>newEncoder()</B></A> - 
Method in interface org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageEncoderFactory.html" title="interface in org.apache.mina.protocol.codec">MessageEncoderFactory</A>
<DD>Creates a new message encoder.
<DT><A HREF="./org/apache/mina/protocol/ProtocolCodecFactory.html#newEncoder()"><B>newEncoder()</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolCodecFactory.html" title="interface in org.apache.mina.protocol">ProtocolCodecFactory</A>
<DD>Creates a new instance of <A HREF="./org/apache/mina/protocol/ProtocolEncoder.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolEncoder</CODE></A> which encodes message
 objects into binary or protocol-specific data.
<DT><A HREF="./org/apache/mina/protocol/handler/MessageHandler.html#NOOP"><B>NOOP</B></A> - 
Static variable in interface org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler">MessageHandler</A>
<DD>A <A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler"><CODE>MessageHandler</CODE></A> that does nothing.
<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#NOT_OK"><B>NOT_OK</B></A> - 
Static variable in interface org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html" title="interface in org.apache.mina.protocol.codec">MessageDecoder</A>
<DD>Represents a result from <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decodable(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(ProtocolSession, ByteBuffer)</CODE></A> and
 <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoderResult.html#NOT_OK"><B>NOT_OK</B></A> - 
Static variable in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoderResult.html" title="class in org.apache.mina.protocol.codec">MessageDecoderResult</A>
<DD>Represents a result from <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decodable(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(ProtocolSession, ByteBuffer)</CODE></A>
 and <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
</DL>
<HR>
<A NAME="_O_"><!-- --></A><H2>
<B>O</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#OK"><B>OK</B></A> - 
Static variable in interface org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html" title="interface in org.apache.mina.protocol.codec">MessageDecoder</A>
<DD>Represents a result from <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decodable(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(ProtocolSession, ByteBuffer)</CODE></A> and
 <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/protocol/codec/MessageDecoderResult.html#OK"><B>OK</B></A> - 
Static variable in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoderResult.html" title="class in org.apache.mina.protocol.codec">MessageDecoderResult</A>
<DD>Represents a result from <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decodable(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer)"><CODE>MessageDecoder.decodable(ProtocolSession, ByteBuffer)</CODE></A>
 and <A HREF="./org/apache/mina/protocol/codec/MessageDecoder.html#decode(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.ByteBuffer, org.apache.mina.protocol.ProtocolDecoderOutput)"><CODE>MessageDecoder.decode(ProtocolSession, ByteBuffer, ProtocolDecoderOutput)</CODE></A>.
<DT><A HREF="./org/apache/mina/util/EventType.html#OPENED"><B>OPENED</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/EventType.html" title="class in org.apache.mina.util">EventType</A>
<DD>&nbsp;
<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/io/package-summary.html"><B>org.apache.mina.io</B></A> - package org.apache.mina.io<DD>Low-level protocol implementation layer (I/O layer).<DT><A HREF="./org/apache/mina/io/datagram/package-summary.html"><B>org.apache.mina.io.datagram</B></A> - package org.apache.mina.io.datagram<DD>Datagram (UDP/IP) support.<DT><A HREF="./org/apache/mina/io/filter/package-summary.html"><B>org.apache.mina.io.filter</B></A> - package org.apache.mina.io.filter<DD>Basic <code>IoHandlerFilter</code> implementations.<DT><A HREF="./org/apache/mina/io/handler/package-summary.html"><B>org.apache.mina.io.handler</B></A> - package org.apache.mina.io.handler<DD>Useful <code>IoHandler</code> implementations.<DT><A HREF="./org/apache/mina/io/socket/package-summary.html"><B>org.apache.mina.io.socket</B></A> - package org.apache.mina.io.socket<DD>Socket (TCP/IP) support.<DT><A HREF="./org/apache/mina/protocol/package-summary.html"><B>org.apache.mina.protocol</B></A> - package org.apache.mina.protocol<DD>High-level protocol implementation layer (Protocol layer).<DT><A HREF="./org/apache/mina/protocol/codec/package-summary.html"><B>org.apache.mina.protocol.codec</B></A> - package org.apache.mina.protocol.codec<DD>Useful <code>ProtocolEncoder</code> and <code>ProtocolDecoder</code> implementations.<DT><A HREF="./org/apache/mina/protocol/filter/package-summary.html"><B>org.apache.mina.protocol.filter</B></A> - package org.apache.mina.protocol.filter<DD>Basic <code>ProtocolHandlerFilter</code> implementations.<DT><A HREF="./org/apache/mina/protocol/handler/package-summary.html"><B>org.apache.mina.protocol.handler</B></A> - package org.apache.mina.protocol.handler<DD>Useful <code>ProtocolHandler</code> implementations.<DT><A HREF="./org/apache/mina/protocol/io/package-summary.html"><B>org.apache.mina.protocol.io</B></A> - package org.apache.mina.protocol.io<DD>A wrapper for <code>org.apache.mina.io</code> package to support low-level I/O.<DT><A HREF="./org/apache/mina/protocol/vmpipe/package-summary.html"><B>org.apache.mina.protocol.vmpipe</B></A> - package org.apache.mina.protocol.vmpipe<DD>In-VM pipe support which removes the overhead of local loopback communication.<DT><A HREF="./org/apache/mina/registry/package-summary.html"><B>org.apache.mina.registry</B></A> - package org.apache.mina.registry<DD>A frontend package that makes setting up MINA easier.<DT><A HREF="./org/apache/mina/util/package-summary.html"><B>org.apache.mina.util</B></A> - package org.apache.mina.util<DD>This package is used by MINA internally.</DL>
<HR>
<A NAME="_P_"><!-- --></A><H2>
<B>P</B></H2>
<DL>
<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/io/filter/IoLoggingFilter.html#PREFIX"><B>PREFIX</B></A> - 
Static variable in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>Session attribute key: prefix string
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#PREFIX"><B>PREFIX</B></A> - 
Static variable in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</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/io/filter/IoThreadPoolFilter.html#processEvent(java.lang.Object, org.apache.mina.common.Session, org.apache.mina.util.EventType, java.lang.Object)"><B>processEvent(Object, Session, EventType, Object)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter">IoThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html#processEvent(java.lang.Object, org.apache.mina.common.Session, org.apache.mina.util.EventType, java.lang.Object)"><B>processEvent(Object, Session, EventType, Object)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#processEvent(java.lang.Object, org.apache.mina.common.Session, org.apache.mina.util.EventType, java.lang.Object)"><B>processEvent(Object, Session, EventType, Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>Implement this method to forward events to <tt>nextFilter</tt>.
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#processStreamIo(org.apache.mina.io.IoSession, java.io.InputStream, java.io.OutputStream)"><B>processStreamIo(IoSession, InputStream, OutputStream)</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.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.
<DT><A HREF="./org/apache/mina/protocol/ProtocolAcceptor.html" title="interface in org.apache.mina.protocol"><B>ProtocolAcceptor</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>Accepts incoming connection, communicates with clients, and fires events to
 <A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolHandler</CODE></A>s.<DT><A HREF="./org/apache/mina/protocol/ProtocolCodecFactory.html" title="interface in org.apache.mina.protocol"><B>ProtocolCodecFactory</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>Provides <A HREF="./org/apache/mina/protocol/ProtocolEncoder.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolEncoder</CODE></A> and <A HREF="./org/apache/mina/protocol/ProtocolDecoder.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolDecoder</CODE></A> which translates
 binary or protocol specific data into message object and vice versa.<DT><A HREF="./org/apache/mina/protocol/ProtocolConnector.html" title="interface in org.apache.mina.protocol"><B>ProtocolConnector</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>Connects to endpoint, communicates with the server, and fires events to
 <A HREF="./org/apache/mina/protocol/ProtocolProvider.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolProvider</CODE></A>s.<DT><A HREF="./org/apache/mina/protocol/ProtocolDecoder.html" title="interface in org.apache.mina.protocol"><B>ProtocolDecoder</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>Decodes binary or protocol-specific data into higher-level message objects.<DT><A HREF="./org/apache/mina/protocol/ProtocolDecoderOutput.html" title="interface in org.apache.mina.protocol"><B>ProtocolDecoderOutput</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>Callback for <A HREF="./org/apache/mina/protocol/ProtocolDecoder.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolDecoder</CODE></A> to generate decoded messages.<DT><A HREF="./org/apache/mina/protocol/ProtocolEncoder.html" title="interface in org.apache.mina.protocol"><B>ProtocolEncoder</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>Encodes higher-level message objects into binary or protocol-specific data.<DT><A HREF="./org/apache/mina/protocol/ProtocolEncoderOutput.html" title="interface in org.apache.mina.protocol"><B>ProtocolEncoderOutput</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>Callback for <A HREF="./org/apache/mina/protocol/ProtocolEncoder.html" title="interface in org.apache.mina.protocol"><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/protocol/ProtocolFilter.html" title="interface in org.apache.mina.protocol"><B>ProtocolFilter</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>A filter which intercepts <A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolHandler</CODE></A> events like Servlet
 filters.<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html" title="interface in org.apache.mina.protocol"><B>ProtocolFilter.NextFilter</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html" title="class in org.apache.mina.protocol"><B>ProtocolFilterAdapter</B></A> - Class in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>An abstract adapter class for <A HREF="./org/apache/mina/protocol/ProtocolFilter.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolFilter</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html#ProtocolFilterAdapter()"><B>ProtocolFilterAdapter()</B></A> - 
Constructor for class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html" title="class in org.apache.mina.protocol">ProtocolFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol"><B>ProtocolFilterChain</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>&nbsp;<DT><A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol"><B>ProtocolHandler</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>Handles all protocol events fired by MINA.<DT><A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html" title="class in org.apache.mina.protocol"><B>ProtocolHandlerAdapter</B></A> - Class in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>An abstract adapter class for <A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolHandler</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html#ProtocolHandlerAdapter()"><B>ProtocolHandlerAdapter()</B></A> - 
Constructor for class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html" title="class in org.apache.mina.protocol">ProtocolHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter"><B>ProtocolLoggingFilter</B></A> - Class in <A HREF="./org/apache/mina/protocol/filter/package-summary.html">org.apache.mina.protocol.filter</A><DD>Logs all MINA protocol events to <A HREF="http://java.sun.com/j2se/1.5.0/docs/api/java/util/logging/Logger.html" title="class or interface in java.util.logging"><CODE>Logger</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#ProtocolLoggingFilter()"><B>ProtocolLoggingFilter()</B></A> - 
Constructor for class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/protocol/ProtocolProvider.html" title="interface in org.apache.mina.protocol"><B>ProtocolProvider</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>Provides a required information to implement high-level protocols.<DT><A HREF="./org/apache/mina/protocol/ProtocolSession.html" title="interface in org.apache.mina.protocol"><B>ProtocolSession</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>A <A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common"><CODE>Session</CODE></A> which represents high-level protocol connection between two
 endpoints regardless of underlying transport types.<DT><A HREF="./org/apache/mina/protocol/ProtocolSessionFilterChain.html" title="class in org.apache.mina.protocol"><B>ProtocolSessionFilterChain</B></A> - Class in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>An <A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io"><CODE>IoFilterChain</CODE></A> that forwards <tt>filterWrite</tt>
 requests to the specified <A HREF="./org/apache/mina/io/IoSessionManagerFilterChain.html" title="class in org.apache.mina.io"><CODE>IoSessionManagerFilterChain</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/ProtocolSessionFilterChain.html#ProtocolSessionFilterChain(org.apache.mina.protocol.ProtocolSessionManagerFilterChain)"><B>ProtocolSessionFilterChain(ProtocolSessionManagerFilterChain)</B></A> - 
Constructor for class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSessionFilterChain.html" title="class in org.apache.mina.protocol">ProtocolSessionFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolSessionManager.html" title="interface in org.apache.mina.protocol"><B>ProtocolSessionManager</B></A> - Interface in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>A <A HREF="./org/apache/mina/common/SessionManager.html" title="interface in org.apache.mina.common"><CODE>SessionManager</CODE></A> for Protocol layer.<DT><A HREF="./org/apache/mina/protocol/ProtocolSessionManagerFilterChain.html" title="class in org.apache.mina.protocol"><B>ProtocolSessionManagerFilterChain</B></A> - Class in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>An <A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolFilterChain</CODE></A> that forwards all events
 except <tt>filterWrite</tt> to the <A HREF="./org/apache/mina/protocol/ProtocolSessionFilterChain.html" title="class in org.apache.mina.protocol"><CODE>ProtocolSessionFilterChain</CODE></A>
 of the recipient session.<DT><A HREF="./org/apache/mina/protocol/ProtocolSessionManagerFilterChain.html#ProtocolSessionManagerFilterChain(org.apache.mina.protocol.ProtocolSessionManager)"><B>ProtocolSessionManagerFilterChain(ProtocolSessionManager)</B></A> - 
Constructor for class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSessionManagerFilterChain.html" title="class in org.apache.mina.protocol">ProtocolSessionManagerFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter"><B>ProtocolThreadPoolFilter</B></A> - Class in <A HREF="./org/apache/mina/protocol/filter/package-summary.html">org.apache.mina.protocol.filter</A><DD>A Thread-pooling filter.<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html#ProtocolThreadPoolFilter()"><B>ProtocolThreadPoolFilter()</B></A> - 
Constructor for class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolThreadPoolFilter</A>
<DD>Creates a new instanceof this filter with default thread pool settings.
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#protocolThreadPoolFilter"><B>protocolThreadPoolFilter</B></A> - 
Variable in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolViolationException.html" title="class in org.apache.mina.protocol"><B>ProtocolViolationException</B></A> - Exception in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>An exception that is thrown when <A HREF="./org/apache/mina/protocol/ProtocolEncoder.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolEncoder</CODE></A> cannot understand or
 failed to validate the specified message, or when <A HREF="./org/apache/mina/protocol/ProtocolDecoder.html" title="interface in org.apache.mina.protocol"><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/protocol/ProtocolViolationException.html#ProtocolViolationException()"><B>ProtocolViolationException()</B></A> - 
Constructor for exception org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolViolationException.html" title="class in org.apache.mina.protocol">ProtocolViolationException</A>
<DD>Constructs a new instance.
<DT><A HREF="./org/apache/mina/protocol/ProtocolViolationException.html#ProtocolViolationException(java.lang.String)"><B>ProtocolViolationException(String)</B></A> - 
Constructor for exception org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolViolationException.html" title="class in org.apache.mina.protocol">ProtocolViolationException</A>
<DD>Constructs a new instance with the specified message.
<DT><A HREF="./org/apache/mina/protocol/ProtocolViolationException.html#ProtocolViolationException(java.lang.Throwable)"><B>ProtocolViolationException(Throwable)</B></A> - 
Constructor for exception org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolViolationException.html" title="class in org.apache.mina.protocol">ProtocolViolationException</A>
<DD>Constructs a new instance with the specified cause.
<DT><A HREF="./org/apache/mina/protocol/ProtocolViolationException.html#ProtocolViolationException(java.lang.String, java.lang.Throwable)"><B>ProtocolViolationException(String, Throwable)</B></A> - 
Constructor for exception org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolViolationException.html" title="class in org.apache.mina.protocol">ProtocolViolationException</A>
<DD>Constructs a new instance with the specified message and the specified
 cause.
<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>&nbsp;
<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>&nbsp;
<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/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#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/util/EventType.html#READ"><B>READ</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/EventType.html" title="class in org.apache.mina.util">EventType</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/util/EventType.html#RECEIVED"><B>RECEIVED</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/EventType.html" title="class in org.apache.mina.util">EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html#register(java.lang.Class)"><B>register(Class)</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.protocol.codec">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html#register(org.apache.mina.protocol.codec.MessageEncoder)"><B>register(MessageEncoder)</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.protocol.codec">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html#register(org.apache.mina.protocol.codec.MessageEncoderFactory)"><B>register(MessageEncoderFactory)</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.protocol.codec">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html#register(org.apache.mina.protocol.codec.MessageDecoder)"><B>register(MessageDecoder)</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.protocol.codec">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html#register(org.apache.mina.protocol.codec.MessageDecoderFactory)"><B>register(MessageDecoderFactory)</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/DemuxingProtocolCodecFactory.html" title="class in org.apache.mina.protocol.codec">DemuxingProtocolCodecFactory</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html#registerMessageType(java.lang.Class, org.apache.mina.protocol.handler.MessageHandler)"><B>registerMessageType(Class, MessageHandler)</B></A> - 
Method in class org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html" title="class in org.apache.mina.protocol.handler">DemuxingProtocolHandler</A>
<DD>Registers a <A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler"><CODE>MessageHandler</CODE></A> that receives the messages of
 the specified <code>type</code>.
<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/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/io/AbstractIoFilterChain.html#remove(java.lang.String)"><B>remove(String)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>Removes the interceptor with the specified name from this chain.
<DT><A HREF="./org/apache/mina/io/IoFilterChain.html#remove(java.lang.String)"><B>remove(String)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterChain.html" title="interface in org.apache.mina.io">IoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#remove(java.lang.String)"><B>remove(String)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>Removes the interceptor with the specified name from this chain.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html#remove(java.lang.String)"><B>remove(String)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterChain.html" title="interface in org.apache.mina.protocol">ProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BlockingSet.html#remove(java.lang.Object)"><B>remove(Object)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingSet.html" title="class in org.apache.mina.util">BlockingSet</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/common/BaseSession.html#removeAttribute(java.lang.String)"><B>removeAttribute(String)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#removeAttribute(java.lang.String)"><B>removeAttribute(String)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Removes a user-defined attribute with the specified key.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#removeAttribute(java.lang.String)"><B>removeAttribute(String)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<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/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;
</DL>
<HR>
<A NAME="_S_"><!-- --></A><H2>
<B>S</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/EventType.html#SENT"><B>SENT</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/EventType.html" title="class in org.apache.mina.util">EventType</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry"><B>Service</B></A> - Class in <A HREF="./org/apache/mina/registry/package-summary.html">org.apache.mina.registry</A><DD>Represents a service that is registered to <A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry"><CODE>ServiceRegistry</CODE></A>.<DT><A HREF="./org/apache/mina/registry/Service.html#Service(java.lang.String, org.apache.mina.common.TransportType, int)"><B>Service(String, TransportType, int)</B></A> - 
Constructor for class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry">Service</A>
<DD>Creates a new instance with the specified protocol name, transport type,
 and port number to be bound.
<DT><A HREF="./org/apache/mina/registry/Service.html#Service(java.lang.String, org.apache.mina.common.TransportType, java.net.SocketAddress)"><B>Service(String, TransportType, SocketAddress)</B></A> - 
Constructor for class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry">Service</A>
<DD>Creates a new instance with the specified protocol name, transport type,
 and socket address to be bound.
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry"><B>ServiceRegistry</B></A> - Interface in <A HREF="./org/apache/mina/registry/package-summary.html">org.apache.mina.registry</A><DD>Interface for the internet service registry.<DT><A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common"><B>Session</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/io/AbstractIoFilterChain.html#sessionClosed(org.apache.mina.io.IoSession)"><B>sessionClosed(IoSession)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#sessionClosed(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html#sessionClosed(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter">IoThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#sessionClosed(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#sessionClosed(org.apache.mina.io.IoSession)"><B>sessionClosed(IoSession)</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>Closes input stream.
<DT><A HREF="./org/apache/mina/io/IoFilter.NextFilter.html#sessionClosed(org.apache.mina.io.IoSession)"><B>sessionClosed(IoSession)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.NextFilter.html" title="interface in org.apache.mina.io">IoFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilter.html#sessionClosed(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/io/IoHandler.html#sessionClosed(org.apache.mina.io.IoSession)"><CODE>IoHandler.sessionClosed(IoSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/io/IoFilterAdapter.html#sessionClosed(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionClosed(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterAdapter.html" title="class in org.apache.mina.io">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoHandler.html#sessionClosed(org.apache.mina.io.IoSession)"><B>sessionClosed(IoSession)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io">IoHandler</A>
<DD>Invoked when the connection is closed.
<DT><A HREF="./org/apache/mina/io/IoHandlerAdapter.html#sessionClosed(org.apache.mina.io.IoSession)"><B>sessionClosed(IoSession)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandlerAdapter.html" title="class in org.apache.mina.io">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#sessionClosed(org.apache.mina.protocol.ProtocolSession)"><B>sessionClosed(ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#sessionClosed(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession)"><B>sessionClosed(ProtocolFilter.NextFilter, ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html#sessionClosed(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession)"><B>sessionClosed(ProtocolFilter.NextFilter, ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html#sessionClosed(org.apache.mina.protocol.ProtocolSession)"><B>sessionClosed(ProtocolSession)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.html#sessionClosed(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession)"><B>sessionClosed(ProtocolFilter.NextFilter, ProtocolSession)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter</A>
<DD>Filters <A HREF="./org/apache/mina/protocol/ProtocolHandler.html#sessionClosed(org.apache.mina.protocol.ProtocolSession)"><CODE>ProtocolHandler.sessionClosed(ProtocolSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html#sessionClosed(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession)"><B>sessionClosed(ProtocolFilter.NextFilter, ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html" title="class in org.apache.mina.protocol">ProtocolFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandler.html#sessionClosed(org.apache.mina.protocol.ProtocolSession)"><B>sessionClosed(ProtocolSession)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol">ProtocolHandler</A>
<DD>Invoked when the connection is closed.
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html#sessionClosed(org.apache.mina.protocol.ProtocolSession)"><B>sessionClosed(ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html" title="class in org.apache.mina.protocol">ProtocolHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SessionConfig.html" title="interface in org.apache.mina.common"><B>SessionConfig</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Provides general or <A HREF="./org/apache/mina/common/TransportType.html" title="class in org.apache.mina.common"><CODE>TransportType</CODE></A>-specific configuration.<DT><A HREF="./org/apache/mina/io/IoHandler.html#sessionCreated(org.apache.mina.io.IoSession)"><B>sessionCreated(IoSession)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io">IoHandler</A>
<DD>Invoked when the session is created.
<DT><A HREF="./org/apache/mina/io/IoHandlerAdapter.html#sessionCreated(org.apache.mina.io.IoSession)"><B>sessionCreated(IoSession)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandlerAdapter.html" title="class in org.apache.mina.io">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandler.html#sessionCreated(org.apache.mina.protocol.ProtocolSession)"><B>sessionCreated(ProtocolSession)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol">ProtocolHandler</A>
<DD>Invoked when the session is created.
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html#sessionCreated(org.apache.mina.protocol.ProtocolSession)"><B>sessionCreated(ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html" title="class in org.apache.mina.protocol">ProtocolHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#sessionIdle(org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#sessionIdle(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html#sessionIdle(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter">IoThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#sessionIdle(org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>Handles read timeout.
<DT><A HREF="./org/apache/mina/io/IoFilter.NextFilter.html#sessionIdle(org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.NextFilter.html" title="interface in org.apache.mina.io">IoFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilter.html#sessionIdle(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/io/IoHandler.html#sessionIdle(org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><CODE>IoHandler.sessionIdle(IoSession, IdleStatus)</CODE></A> event.
<DT><A HREF="./org/apache/mina/io/IoFilterAdapter.html#sessionIdle(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoFilter.NextFilter, IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterAdapter.html" title="class in org.apache.mina.io">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoHandler.html#sessionIdle(org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io">IoHandler</A>
<DD>Invoked when the connection is idle.
<DT><A HREF="./org/apache/mina/io/IoHandlerAdapter.html#sessionIdle(org.apache.mina.io.IoSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(IoSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandlerAdapter.html" title="class in org.apache.mina.io">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#sessionIdle(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(ProtocolSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#sessionIdle(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(ProtocolFilter.NextFilter, ProtocolSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html#sessionIdle(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(ProtocolFilter.NextFilter, ProtocolSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html#sessionIdle(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(ProtocolSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.html#sessionIdle(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(ProtocolFilter.NextFilter, ProtocolSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter</A>
<DD>Filters <A HREF="./org/apache/mina/protocol/ProtocolHandler.html#sessionIdle(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.IdleStatus)"><CODE>ProtocolHandler.sessionIdle(ProtocolSession,IdleStatus)</CODE></A>
 event.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html#sessionIdle(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(ProtocolFilter.NextFilter, ProtocolSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html" title="class in org.apache.mina.protocol">ProtocolFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandler.html#sessionIdle(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(ProtocolSession, IdleStatus)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol">ProtocolHandler</A>
<DD>Invoked when the connection is idle.
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html#sessionIdle(org.apache.mina.protocol.ProtocolSession, org.apache.mina.common.IdleStatus)"><B>sessionIdle(ProtocolSession, IdleStatus)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html" title="class in org.apache.mina.protocol">ProtocolHandlerAdapter</A>
<DD>&nbsp;
<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>Call <A HREF="./org/apache/mina/util/SessionLog.html#getLogger(org.apache.mina.common.Session)"><CODE>SessionLog.getLogger(Session)</CODE></A>, <A HREF="./org/apache/mina/util/SessionLog.html#log(java.util.logging.Level, org.apache.mina.common.Session, java.lang.String)"><CODE>SessionLog.log(Level,Session, String)</CODE></A>, and
 <A HREF="./org/apache/mina/util/SessionLog.html#log(java.util.logging.Level, org.apache.mina.common.Session, java.lang.String, java.lang.Throwable)"><CODE>SessionLog.log(Level,Session, String, Throwable)</CODE></A> 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/SessionManager.html" title="interface in org.apache.mina.common"><B>SessionManager</B></A> - Interface in <A HREF="./org/apache/mina/common/package-summary.html">org.apache.mina.common</A><DD>Base interface for all acceptors and connectors that manage
 sessions.<DT><A HREF="./org/apache/mina/io/AbstractIoFilterChain.html#sessionOpened(org.apache.mina.io.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/AbstractIoFilterChain.html" title="class in org.apache.mina.io">AbstractIoFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/BlacklistFilter.html#sessionOpened(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/BlacklistFilter.html" title="class in org.apache.mina.io.filter">BlacklistFilter</A>
<DD>Close connection immediately if the remote address of session is
 blacklisted.
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#sessionOpened(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html#sessionOpened(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoThreadPoolFilter.html" title="class in org.apache.mina.io.filter">IoThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#sessionOpened(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#sessionOpened(org.apache.mina.io.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>Initializes streams and timeout settings.
<DT><A HREF="./org/apache/mina/io/IoFilter.NextFilter.html#sessionOpened(org.apache.mina.io.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.NextFilter.html" title="interface in org.apache.mina.io">IoFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoFilter.html#sessionOpened(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilter.html" title="interface in org.apache.mina.io">IoFilter</A>
<DD>Filters <A HREF="./org/apache/mina/io/IoHandler.html#sessionOpened(org.apache.mina.io.IoSession)"><CODE>IoHandler.sessionOpened(IoSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/io/IoFilterAdapter.html#sessionOpened(org.apache.mina.io.IoFilter.NextFilter, org.apache.mina.io.IoSession)"><B>sessionOpened(IoFilter.NextFilter, IoSession)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoFilterAdapter.html" title="class in org.apache.mina.io">IoFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoHandler.html#sessionOpened(org.apache.mina.io.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io">IoHandler</A>
<DD>Invoked when the connection is opened.
<DT><A HREF="./org/apache/mina/io/IoHandlerAdapter.html#sessionOpened(org.apache.mina.io.IoSession)"><B>sessionOpened(IoSession)</B></A> - 
Method in class org.apache.mina.io.<A HREF="./org/apache/mina/io/IoHandlerAdapter.html" title="class in org.apache.mina.io">IoHandlerAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html#sessionOpened(org.apache.mina.protocol.ProtocolSession)"><B>sessionOpened(ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/AbstractProtocolFilterChain.html" title="class in org.apache.mina.protocol">AbstractProtocolFilterChain</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#sessionOpened(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession)"><B>sessionOpened(ProtocolFilter.NextFilter, ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html#sessionOpened(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession)"><B>sessionOpened(ProtocolFilter.NextFilter, ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolThreadPoolFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolThreadPoolFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html#sessionOpened(org.apache.mina.protocol.ProtocolSession)"><B>sessionOpened(ProtocolSession)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.NextFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter.NextFilter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilter.html#sessionOpened(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession)"><B>sessionOpened(ProtocolFilter.NextFilter, ProtocolSession)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilter.html" title="interface in org.apache.mina.protocol">ProtocolFilter</A>
<DD>Filters <A HREF="./org/apache/mina/protocol/ProtocolHandler.html#sessionOpened(org.apache.mina.protocol.ProtocolSession)"><CODE>ProtocolHandler.sessionOpened(ProtocolSession)</CODE></A> event.
<DT><A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html#sessionOpened(org.apache.mina.protocol.ProtocolFilter.NextFilter, org.apache.mina.protocol.ProtocolSession)"><B>sessionOpened(ProtocolFilter.NextFilter, ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolFilterAdapter.html" title="class in org.apache.mina.protocol">ProtocolFilterAdapter</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandler.html#sessionOpened(org.apache.mina.protocol.ProtocolSession)"><B>sessionOpened(ProtocolSession)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandler.html" title="interface in org.apache.mina.protocol">ProtocolHandler</A>
<DD>Invoked when the connection is opened.
<DT><A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html#sessionOpened(org.apache.mina.protocol.ProtocolSession)"><B>sessionOpened(ProtocolSession)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolHandlerAdapter.html" title="class in org.apache.mina.protocol">ProtocolHandlerAdapter</A>
<DD>&nbsp;
<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>Exception utility.<DT><A HREF="./org/apache/mina/common/BaseSession.html#setAttachment(java.lang.Object)"><B>setAttachment(Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.html#setAttachment(java.lang.Object)"><B>setAttachment(Object)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Sets an attachment of this session.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#setAttachment(java.lang.Object)"><B>setAttachment(Object)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#setAttribute(java.lang.String, java.lang.Object)"><B>setAttribute(String, Object)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/Session.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/Session.html" title="interface in org.apache.mina.common">Session</A>
<DD>Sets a user-defined attribute.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#setAttribute(java.lang.String, java.lang.Object)"><B>setAttribute(String, Object)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<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/io/socket/SocketAcceptor.html#setBacklog(int)"><B>setBacklog(int)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketAcceptor.html" title="class in org.apache.mina.io.socket">SocketAcceptor</A>
<DD>Sets the default backlog value which is used when user binds.
<DT><A HREF="./org/apache/mina/protocol/ProtocolViolationException.html#setBuffer(org.apache.mina.common.ByteBuffer)"><B>setBuffer(ByteBuffer)</B></A> - 
Method in exception org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolViolationException.html" title="class in org.apache.mina.protocol">ProtocolViolationException</A>
<DD>Sets unknown message part.
<DT><A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html#setDefaultLevel(java.util.logging.Level)"><B>setDefaultLevel(Level)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/IoLoggingFilter.html" title="class in org.apache.mina.io.filter">IoLoggingFilter</A>
<DD>Sets the default level of log entry this filter logs.
<DT><A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html#setDefaultLevel(java.util.logging.Level)"><B>setDefaultLevel(Level)</B></A> - 
Method in class org.apache.mina.protocol.filter.<A HREF="./org/apache/mina/protocol/filter/ProtocolLoggingFilter.html" title="class in org.apache.mina.protocol.filter">ProtocolLoggingFilter</A>
<DD>Sets the default level of log entry this filter logs.
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#setEnabledCipherSuites(java.lang.String[])"><B>setEnabledCipherSuites(String[])</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.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/io/filter/SSLFilter.html#setEnabledProtocols(java.lang.String[])"><B>setEnabledProtocols(String[])</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.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/common/BaseSessionManager.html#setExceptionMonitor(org.apache.mina.common.ExceptionMonitor)"><B>setExceptionMonitor(ExceptionMonitor)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionManager.html" title="class in org.apache.mina.common">BaseSessionManager</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SessionManager.html#setExceptionMonitor(org.apache.mina.common.ExceptionMonitor)"><B>setExceptionMonitor(ExceptionMonitor)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/SessionManager.html" title="interface in org.apache.mina.common">SessionManager</A>
<DD>Sets the uncaught exception monitor.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html#setExceptionMonitor(org.apache.mina.common.ExceptionMonitor)"><B>setExceptionMonitor(ExceptionMonitor)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html" title="class in org.apache.mina.protocol.io">IoProtocolAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html#setExceptionMonitor(org.apache.mina.common.ExceptionMonitor)"><B>setExceptionMonitor(ExceptionMonitor)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolConnector.html" title="class in org.apache.mina.protocol.io">IoProtocolConnector</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSession.html#setIdle(org.apache.mina.common.IdleStatus, boolean)"><B>setIdle(IdleStatus, boolean)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSession.html" title="class in org.apache.mina.common">BaseSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/BaseSessionConfig.html#setIdleTime(org.apache.mina.common.IdleStatus, int)"><B>setIdleTime(IdleStatus, int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionConfig.html" title="class in org.apache.mina.common">BaseSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SessionConfig.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/SessionConfig.html" title="interface in org.apache.mina.common">SessionConfig</A>
<DD>Sets idle time for the specified type of idleness in seconds.
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#setKeepAlive(boolean)"><B>setKeepAlive(boolean)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#setKeepAliveTime(int)"><B>setKeepAliveTime(int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ThreadPool.html#setKeepAliveTime(int)"><B>setKeepAliveTime(int)</B></A> - 
Method in interface org.apache.mina.util.<A HREF="./org/apache/mina/util/ThreadPool.html" title="interface in org.apache.mina.util">ThreadPool</A>
<DD>Sets the keep-alive time until the thread suicides after it became idle
 (milliseconds unit).
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#setMaximumPoolSize(int)"><B>setMaximumPoolSize(int)</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ThreadPool.html#setMaximumPoolSize(int)"><B>setMaximumPoolSize(int)</B></A> - 
Method in interface org.apache.mina.util.<A HREF="./org/apache/mina/util/ThreadPool.html" title="interface in org.apache.mina.util">ThreadPool</A>
<DD>Sets the maximum size of the thread pool.
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#setNeedClientAuth(boolean)"><B>setNeedClientAuth(boolean)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>Configures the engine to <em>require</em> client authentication.
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#setOOBInline(boolean)"><B>setOOBInline(boolean)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#setReadTimeout(int)"><B>setReadTimeout(int)</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>Sets read timeout in seconds.
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#setReceiveBufferSize(int)"><B>setReceiveBufferSize(int)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramSessionConfig.html#setReuseAddress(boolean)"><B>setReuseAddress(boolean)</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramSessionConfig.html" title="class in org.apache.mina.io.datagram">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#setReuseAddress(boolean)"><B>setReuseAddress(boolean)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#setSendBufferSize(int)"><B>setSendBufferSize(int)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#setSessionReceiveBufferSize(int)"><B>setSessionReceiveBufferSize(int)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#setSoLinger(boolean, int)"><B>setSoLinger(boolean, int)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#setTcpNoDelay(boolean)"><B>setTcpNoDelay(boolean)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/datagram/DatagramSessionConfig.html#setTrafficClass(int)"><B>setTrafficClass(int)</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramSessionConfig.html" title="class in org.apache.mina.io.datagram">DatagramSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html#setTrafficClass(int)"><B>setTrafficClass(int)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket">SocketSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#setUseClientMode(boolean)"><B>setUseClientMode(boolean)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>Configures the engine to use client (or server) mode when handshaking.
<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#setWantClientAuth(boolean)"><B>setWantClientAuth(boolean)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>Configures the engine to <em>request</em> client authentication.
<DT><A HREF="./org/apache/mina/common/BaseSessionConfig.html#setWriteTimeout(int)"><B>setWriteTimeout(int)</B></A> - 
Method in class org.apache.mina.common.<A HREF="./org/apache/mina/common/BaseSessionConfig.html" title="class in org.apache.mina.common">BaseSessionConfig</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/common/SessionConfig.html#setWriteTimeout(int)"><B>setWriteTimeout(int)</B></A> - 
Method in interface org.apache.mina.common.<A HREF="./org/apache/mina/common/SessionConfig.html" title="interface in org.apache.mina.common">SessionConfig</A>
<DD>Sets write timeout in seconds.
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#setWriteTimeout(int)"><B>setWriteTimeout(int)</B></A> - 
Method in class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>Sets write timeout in seconds.
<DT><A HREF="./org/apache/mina/protocol/SimpleProtocolDecoderOutput.html" title="class in org.apache.mina.protocol"><B>SimpleProtocolDecoderOutput</B></A> - Class in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>A <A HREF="./org/apache/mina/protocol/ProtocolDecoderOutput.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolDecoderOutput</CODE></A> based on queue.<DT><A HREF="./org/apache/mina/protocol/SimpleProtocolDecoderOutput.html#SimpleProtocolDecoderOutput()"><B>SimpleProtocolDecoderOutput()</B></A> - 
Constructor for class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/SimpleProtocolDecoderOutput.html" title="class in org.apache.mina.protocol">SimpleProtocolDecoderOutput</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/SimpleProtocolEncoderOutput.html" title="class in org.apache.mina.protocol"><B>SimpleProtocolEncoderOutput</B></A> - Class in <A HREF="./org/apache/mina/protocol/package-summary.html">org.apache.mina.protocol</A><DD>A <A HREF="./org/apache/mina/protocol/ProtocolEncoderOutput.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolEncoderOutput</CODE></A> based on queue.<DT><A HREF="./org/apache/mina/protocol/SimpleProtocolEncoderOutput.html#SimpleProtocolEncoderOutput()"><B>SimpleProtocolEncoderOutput()</B></A> - 
Constructor for class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/SimpleProtocolEncoderOutput.html" title="class in org.apache.mina.protocol">SimpleProtocolEncoderOutput</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry"><B>SimpleServiceRegistry</B></A> - Class in <A HREF="./org/apache/mina/registry/package-summary.html">org.apache.mina.registry</A><DD>A simple implementation of <A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry"><CODE>ServiceRegistry</CODE></A>.<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#SimpleServiceRegistry()"><B>SimpleServiceRegistry()</B></A> - 
Constructor for class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</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/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/io/socket/SocketAcceptor.html" title="class in org.apache.mina.io.socket"><B>SocketAcceptor</B></A> - Class in <A HREF="./org/apache/mina/io/socket/package-summary.html">org.apache.mina.io.socket</A><DD><A HREF="./org/apache/mina/io/IoAcceptor.html" title="interface in org.apache.mina.io"><CODE>IoAcceptor</CODE></A> for socket transport (TCP/IP).<DT><A HREF="./org/apache/mina/io/socket/SocketAcceptor.html#SocketAcceptor()"><B>SocketAcceptor()</B></A> - 
Constructor for class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketAcceptor.html" title="class in org.apache.mina.io.socket">SocketAcceptor</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/io/socket/SocketConnector.html" title="class in org.apache.mina.io.socket"><B>SocketConnector</B></A> - Class in <A HREF="./org/apache/mina/io/socket/package-summary.html">org.apache.mina.io.socket</A><DD><A HREF="./org/apache/mina/io/IoConnector.html" title="interface in org.apache.mina.io"><CODE>IoConnector</CODE></A> for socket transport (TCP/IP).<DT><A HREF="./org/apache/mina/io/socket/SocketConnector.html#SocketConnector()"><B>SocketConnector()</B></A> - 
Constructor for class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketConnector.html" title="class in org.apache.mina.io.socket">SocketConnector</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#socketIoAcceptor"><B>socketIoAcceptor</B></A> - 
Variable in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#socketProtocolAcceptor"><B>socketProtocolAcceptor</B></A> - 
Variable in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/socket/SocketSessionConfig.html" title="class in org.apache.mina.io.socket"><B>SocketSessionConfig</B></A> - Class in <A HREF="./org/apache/mina/io/socket/package-summary.html">org.apache.mina.io.socket</A><DD>A <A HREF="./org/apache/mina/common/SessionConfig.html" title="interface in org.apache.mina.common"><CODE>SessionConfig</CODE></A> for socket transport (TCP/IP).<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#SSL_SESSION"><B>SSL_SESSION</B></A> - 
Static variable in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter">SSLFilter</A>
<DD>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/io/filter/SSLFilter.html" title="class in org.apache.mina.io.filter"><B>SSLFilter</B></A> - Class in <A HREF="./org/apache/mina/io/filter/package-summary.html">org.apache.mina.io.filter</A><DD>An SSL filter that encrypts and decrypts the data exchanged in the session.<DT><A HREF="./org/apache/mina/io/filter/SSLFilter.html#SSLFilter(javax.net.ssl.SSLContext)"><B>SSLFilter(SSLContext)</B></A> - 
Constructor for class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/SSLFilter.html" title="class in org.apache.mina.io.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/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/util/BaseThreadPool.html#start()"><B>start()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ThreadPool.html#start()"><B>start()</B></A> - 
Method in interface org.apache.mina.util.<A HREF="./org/apache/mina/util/ThreadPool.html" title="interface in org.apache.mina.util">ThreadPool</A>
<DD>Starts thread pool threads and starts forwarding events to them.
<DT><A HREF="./org/apache/mina/util/BaseThreadPool.html#stop()"><B>stop()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BaseThreadPool.html" title="class in org.apache.mina.util">BaseThreadPool</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/util/ThreadPool.html#stop()"><B>stop()</B></A> - 
Method in interface org.apache.mina.util.<A HREF="./org/apache/mina/util/ThreadPool.html" title="interface in org.apache.mina.util">ThreadPool</A>
<DD>Stops all thread pool threads.
<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler"><B>StreamIoHandler</B></A> - Class in <A HREF="./org/apache/mina/io/handler/package-summary.html">org.apache.mina.io.handler</A><DD>A <A HREF="./org/apache/mina/io/IoHandler.html" title="interface in org.apache.mina.io"><CODE>IoHandler</CODE></A> that adapts asynchronous MINA events to stream I/O.<DT><A HREF="./org/apache/mina/io/handler/StreamIoHandler.html#StreamIoHandler()"><B>StreamIoHandler()</B></A> - 
Constructor for class org.apache.mina.io.handler.<A HREF="./org/apache/mina/io/handler/StreamIoHandler.html" title="class in org.apache.mina.io.handler">StreamIoHandler</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_T_"><!-- --></A><H2>
<B>T</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/ThreadPool.html" title="interface in org.apache.mina.util"><B>ThreadPool</B></A> - Interface in <A HREF="./org/apache/mina/util/package-summary.html">org.apache.mina.util</A><DD>A generic thread pool interface.<DT><A HREF="./org/apache/mina/util/ExceptionUtil.html#throwException(java.lang.Throwable)"><B>throwException(Throwable)</B></A> - 
Static method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/ExceptionUtil.html" title="class in org.apache.mina.util">ExceptionUtil</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/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/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/protocol/codec/MessageDecoderResult.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.protocol.codec.<A HREF="./org/apache/mina/protocol/codec/MessageDecoderResult.html" title="class in org.apache.mina.protocol.codec">MessageDecoderResult</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAddress</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/Service.html#toString()"><B>toString()</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/Service.html" title="class in org.apache.mina.registry">Service</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/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.
</DL>
<HR>
<A NAME="_U_"><!-- --></A><H2>
<B>U</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/io/datagram/DatagramAcceptor.html#unbind(java.net.SocketAddress)"><B>unbind(SocketAddress)</B></A> - 
Method in class org.apache.mina.io.datagram.<A HREF="./org/apache/mina/io/datagram/DatagramAcceptor.html" title="class in org.apache.mina.io.datagram">DatagramAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/IoAcceptor.html#unbind(java.net.SocketAddress)"><B>unbind(SocketAddress)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoAcceptor.html" title="interface in org.apache.mina.io">IoAcceptor</A>
<DD>Unbinds from the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/io/socket/SocketAcceptor.html#unbind(java.net.SocketAddress)"><B>unbind(SocketAddress)</B></A> - 
Method in class org.apache.mina.io.socket.<A HREF="./org/apache/mina/io/socket/SocketAcceptor.html" title="class in org.apache.mina.io.socket">SocketAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html#unbind(java.net.SocketAddress)"><B>unbind(SocketAddress)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolAcceptor.html" title="class in org.apache.mina.protocol.io">IoProtocolAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolAcceptor.html#unbind(java.net.SocketAddress)"><B>unbind(SocketAddress)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolAcceptor.html" title="interface in org.apache.mina.protocol">ProtocolAcceptor</A>
<DD>Unbinds from the specified <code>address</code>.
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAcceptor.html#unbind(java.net.SocketAddress)"><B>unbind(SocketAddress)</B></A> - 
Method in class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAcceptor</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#unbind(org.apache.mina.registry.Service)"><B>unbind(Service)</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>Unbinds the specified service (and its aggregated I/O handler or
 protocol provider).
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#unbind(org.apache.mina.registry.Service)"><B>unbind(Service)</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/registry/ServiceRegistry.html#unbindAll()"><B>unbindAll()</B></A> - 
Method in interface org.apache.mina.registry.<A HREF="./org/apache/mina/registry/ServiceRegistry.html" title="interface in org.apache.mina.registry">ServiceRegistry</A>
<DD>Unbinds all services (and their aggregated I/O handlers or
 protocol providers).
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#unbindAll()"><B>unbindAll()</B></A> - 
Method in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/io/filter/BlacklistFilter.html#unblock(java.net.InetAddress)"><B>unblock(InetAddress)</B></A> - 
Method in class org.apache.mina.io.filter.<A HREF="./org/apache/mina/io/filter/BlacklistFilter.html" title="class in org.apache.mina.io.filter">BlacklistFilter</A>
<DD>Unblocks the specified endpoint.
<DT><A HREF="./org/apache/mina/protocol/handler/UnknownMessageTypeException.html" title="class in org.apache.mina.protocol.handler"><B>UnknownMessageTypeException</B></A> - Exception in <A HREF="./org/apache/mina/protocol/handler/package-summary.html">org.apache.mina.protocol.handler</A><DD>An exception that is thrown when <A HREF="./org/apache/mina/protocol/handler/DemuxingProtocolHandler.html" title="class in org.apache.mina.protocol.handler"><CODE>DemuxingProtocolHandler</CODE></A>
 cannot find any <A HREF="./org/apache/mina/protocol/handler/MessageHandler.html" title="interface in org.apache.mina.protocol.handler"><CODE>MessageHandler</CODE></A>s associated with the specific
 message type.<DT><A HREF="./org/apache/mina/protocol/handler/UnknownMessageTypeException.html#UnknownMessageTypeException()"><B>UnknownMessageTypeException()</B></A> - 
Constructor for exception org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/UnknownMessageTypeException.html" title="class in org.apache.mina.protocol.handler">UnknownMessageTypeException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/handler/UnknownMessageTypeException.html#UnknownMessageTypeException(java.lang.String, java.lang.Throwable)"><B>UnknownMessageTypeException(String, Throwable)</B></A> - 
Constructor for exception org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/UnknownMessageTypeException.html" title="class in org.apache.mina.protocol.handler">UnknownMessageTypeException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/handler/UnknownMessageTypeException.html#UnknownMessageTypeException(java.lang.String)"><B>UnknownMessageTypeException(String)</B></A> - 
Constructor for exception org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/UnknownMessageTypeException.html" title="class in org.apache.mina.protocol.handler">UnknownMessageTypeException</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/handler/UnknownMessageTypeException.html#UnknownMessageTypeException(java.lang.Throwable)"><B>UnknownMessageTypeException(Throwable)</B></A> - 
Constructor for exception org.apache.mina.protocol.handler.<A HREF="./org/apache/mina/protocol/handler/UnknownMessageTypeException.html" title="class in org.apache.mina.protocol.handler">UnknownMessageTypeException</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_V_"><!-- --></A><H2>
<B>V</B></H2>
<DL>
<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="..
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.protocol.vmpipe"><B>VmPipeAcceptor</B></A> - Class in <A HREF="./org/apache/mina/protocol/vmpipe/package-summary.html">org.apache.mina.protocol.vmpipe</A><DD>Binds the specified <A HREF="./org/apache/mina/protocol/ProtocolProvider.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolProvider</CODE></A> to the specified
 <A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.protocol.vmpipe"><CODE>VmPipeAddress</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAcceptor.html#VmPipeAcceptor()"><B>VmPipeAcceptor()</B></A> - 
Constructor for class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAcceptor.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAcceptor</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html#vmPipeAcceptor"><B>vmPipeAcceptor</B></A> - 
Variable in class org.apache.mina.registry.<A HREF="./org/apache/mina/registry/SimpleServiceRegistry.html" title="class in org.apache.mina.registry">SimpleServiceRegistry</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.protocol.vmpipe"><B>VmPipeAddress</B></A> - Class in <A HREF="./org/apache/mina/protocol/vmpipe/package-summary.html">org.apache.mina.protocol.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/protocol/vmpipe/VmPipeAddress.html#VmPipeAddress(int)"><B>VmPipeAddress(int)</B></A> - 
Constructor for class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeAddress</A>
<DD>Creates a new instance with the specifid port number.
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.protocol.vmpipe"><B>VmPipeConnector</B></A> - Class in <A HREF="./org/apache/mina/protocol/vmpipe/package-summary.html">org.apache.mina.protocol.vmpipe</A><DD>Connects to <A HREF="./org/apache/mina/protocol/ProtocolProvider.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolProvider</CODE></A>s which is bound on the specified
 <A HREF="./org/apache/mina/protocol/vmpipe/VmPipeAddress.html" title="class in org.apache.mina.protocol.vmpipe"><CODE>VmPipeAddress</CODE></A>.<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html#VmPipeConnector()"><B>VmPipeConnector()</B></A> - 
Constructor for class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeConnector.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeConnector</A>
<DD>Creates a new instance.
<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeSessionConfig.html" title="class in org.apache.mina.protocol.vmpipe"><B>VmPipeSessionConfig</B></A> - Class in <A HREF="./org/apache/mina/protocol/vmpipe/package-summary.html">org.apache.mina.protocol.vmpipe</A><DD>A <A HREF="./org/apache/mina/common/SessionConfig.html" title="interface in org.apache.mina.common"><CODE>SessionConfig</CODE></A> for in-VM pipe transport.<DT><A HREF="./org/apache/mina/protocol/vmpipe/VmPipeSessionConfig.html#VmPipeSessionConfig()"><B>VmPipeSessionConfig()</B></A> - 
Constructor for class org.apache.mina.protocol.vmpipe.<A HREF="./org/apache/mina/protocol/vmpipe/VmPipeSessionConfig.html" title="class in org.apache.mina.protocol.vmpipe">VmPipeSessionConfig</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_W_"><!-- --></A><H2>
<B>W</B></H2>
<DL>
<DT><A HREF="./org/apache/mina/util/BlockingSet.html#waitForNewItem()"><B>waitForNewItem()</B></A> - 
Method in class org.apache.mina.util.<A HREF="./org/apache/mina/util/BlockingSet.html" title="class in org.apache.mina.util">BlockingSet</A>
<DD>&nbsp;
<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/io/IoSession.html#write(org.apache.mina.common.ByteBuffer, java.lang.Object)"><B>write(ByteBuffer, Object)</B></A> - 
Method in interface org.apache.mina.io.<A HREF="./org/apache/mina/io/IoSession.html" title="interface in org.apache.mina.io">IoSession</A>
<DD>Writes the content of the specified <code>buf</code>.
<DT><A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html#write(java.lang.Object)"><B>write(Object)</B></A> - 
Method in class org.apache.mina.protocol.io.<A HREF="./org/apache/mina/protocol/io/IoProtocolSession.html" title="class in org.apache.mina.protocol.io">IoProtocolSession</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/ProtocolDecoderOutput.html#write(java.lang.Object)"><B>write(Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolDecoderOutput.html" title="interface in org.apache.mina.protocol">ProtocolDecoderOutput</A>
<DD>Callback for <A HREF="./org/apache/mina/protocol/ProtocolDecoder.html" title="interface in org.apache.mina.protocol"><CODE>ProtocolDecoder</CODE></A> to generate decoded messages.
<DT><A HREF="./org/apache/mina/protocol/ProtocolEncoderOutput.html#write(org.apache.mina.common.ByteBuffer)"><B>write(ByteBuffer)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolEncoderOutput.html" title="interface in org.apache.mina.protocol">ProtocolEncoderOutput</A>
<DD>Callback for <A HREF="./org/apache/mina/protocol/ProtocolEncoder.html" title="interface in org.apache.mina.protocol"><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/protocol/ProtocolSession.html#write(java.lang.Object)"><B>write(Object)</B></A> - 
Method in interface org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/ProtocolSession.html" title="interface in org.apache.mina.protocol">ProtocolSession</A>
<DD>Writes the specified <code>message</code> to remote peer.
<DT><A HREF="./org/apache/mina/protocol/SimpleProtocolDecoderOutput.html#write(java.lang.Object)"><B>write(Object)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/SimpleProtocolDecoderOutput.html" title="class in org.apache.mina.protocol">SimpleProtocolDecoderOutput</A>
<DD>&nbsp;
<DT><A HREF="./org/apache/mina/protocol/SimpleProtocolEncoderOutput.html#write(org.apache.mina.common.ByteBuffer)"><B>write(ByteBuffer)</B></A> - 
Method in class org.apache.mina.protocol.<A HREF="./org/apache/mina/protocol/SimpleProtocolEncoderOutput.html" title="class in org.apache.mina.protocol">SimpleProtocolEncoderOutput</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/io/WriteTimeoutException.html" title="class in org.apache.mina.io"><B>WriteTimeoutException</B></A> - Exception in <A HREF="./org/apache/mina/io/package-summary.html">org.apache.mina.io</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/SessionConfig.html#getWriteTimeout()"><CODE>SessionConfig.getWriteTimeout()</CODE></A> seconds.<DT><A HREF="./org/apache/mina/io/WriteTimeoutException.html#WriteTimeoutException()"><B>WriteTimeoutException()</B></A> - 
Constructor for exception org.apache.mina.io.<A HREF="./org/apache/mina/io/WriteTimeoutException.html" title="class in org.apache.mina.io">WriteTimeoutException</A>
<DD>Creates a new exception.
<DT><A HREF="./org/apache/mina/io/WriteTimeoutException.html#WriteTimeoutException(java.lang.String)"><B>WriteTimeoutException(String)</B></A> - 
Constructor for exception org.apache.mina.io.<A HREF="./org/apache/mina/io/WriteTimeoutException.html" title="class in org.apache.mina.io">WriteTimeoutException</A>
<DD>Creates a new exception.
<DT><A HREF="./org/apache/mina/util/EventType.html#WRITTEN"><B>WRITTEN</B></A> - 
Static variable in class org.apache.mina.util.<A HREF="./org/apache/mina/util/EventType.html" title="class in org.apache.mina.util">EventType</A>
<DD>&nbsp;
</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="#_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> 

<!-- ======= 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>
Copyright &copy; 2004-2005 . All Rights Reserved.
</BODY>
</HTML>
