content: /*
   * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package java.nio.channels;
  
  import java.nio.channels.spi.*;
  import java.net.SocketOption;
  import java.net.SocketAddress;
  import java.util.concurrent.Future;
  import java.io.IOException;
  
  /**
   * An asynchronous channel for stream-oriented listening sockets.
   *
   * <p> An asynchronous server-socket channel is created by invoking the
   * {@link #open open} method of this class.
   * A newly-created asynchronous server-socket channel is open but not yet bound.
   * It can be bound to a local address and configured to listen for connections
   * by invoking the {@link #bind(SocketAddress,int) bind} method. Once bound,
   * the {@link #accept(Object,CompletionHandler) accept} method
   * is used to initiate the accepting of connections to the channel's socket.
   * An attempt to invoke the <tt>accept</tt> method on an unbound channel will
   * cause a {@link NotYetBoundException} to be thrown.
   *
   * <p> Channels of this type are safe for use by multiple concurrent threads
   * though at most one accept operation can be outstanding at any time.
   * If a thread initiates an accept operation before a previous accept operation
   * has completed then an {@link AcceptPendingException} will be thrown.
   *
   * <p> Socket options are configured using the {@link #setOption(SocketOption,Object)
   * setOption} method. Channels of this type support the following options:
   * <blockquote>
   * <table border summary="Socket options">
   *   <tr>
   *     <th>Option Name</th>
   *     <th>Description</th>
   *   </tr>
   *   <tr>
   *     <td> {@link java.net.StandardSocketOptions#SO_RCVBUF SO_RCVBUF} </td>
   *     <td> The size of the socket receive buffer </td>
   *   </tr>
   *   <tr>
   *     <td> {@link java.net.StandardSocketOptions#SO_REUSEADDR SO_REUSEADDR} </td>
   *     <td> Re-use address </td>
   *   </tr>
   * </table>
   * </blockquote>
   * Additional (implementation specific) options may also be supported.
   *
   * <p> <b>Usage Example:</b>
   * <pre>
   *  final AsynchronousServerSocketChannel listener =
   *      AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(5000));
   *
   *  listener.accept(null, new CompletionHandler&lt;AsynchronousSocketChannel,Void&gt;() {
   *      public void completed(AsynchronousSocketChannel ch, Void att) {
   *          // accept the next connection
   *          listener.accept(null, this);
   *
   *          // handle this connection
   *          handle(ch);
   *      }
   *      public void failed(Throwable exc, Void att) {
   *          ...
   *      }
   *  });
   * </pre>
   *
   * @since 1.7
   */
  
  public abstract class AsynchronousServerSocketChannel
      implements AsynchronousChannel, NetworkChannel
  {
      private final AsynchronousChannelProvider provider;
  
      /**
       * Initializes a new instance of this class.
       *
       * @param  provider
       *         The provider that created this channel
       */
      protected AsynchronousServerSocketChannel(AsynchronousChannelProvider provider) {
          this.provider = provider;
      }
  
      /**
       * Returns the provider that created this channel.
       *
       * @return  The provider that created this channel
       */
      public final AsynchronousChannelProvider provider() {
          return provider;
      }
  
      /**
       * Opens an asynchronous server-socket channel.
       *
       * <p> The new channel is created by invoking the {@link
       * AsynchronousChannelProvider#openAsynchronousServerSocketChannel
       * openAsynchronousServerSocketChannel} method on the {@link
       * AsynchronousChannelProvider} object that created
       * the given group. If the group parameter is <tt>null</tt> then the
       * resulting channel is created by the system-wide default provider, and
       * bound to the <em>default group</em>.
       *
       * @param   group
       *          The group to which the newly constructed channel should be bound,
       *          or <tt>null</tt> for the default group
       *
       * @return  A new asynchronous server socket channel
       *
       * @throws  ShutdownChannelGroupException
       *          If the channel group is shutdown
       * @throws  IOException
       *          If an I/O error occurs
       */
      public static AsynchronousServerSocketChannel open(AsynchronousChannelGroup group)
          throws IOException
      {
          AsynchronousChannelProvider provider = (group == null) ?
              AsynchronousChannelProvider.provider() : group.provider();
          return provider.openAsynchronousServerSocketChannel(group);
      }
  
      /**
       * Opens an asynchronous server-socket channel.
       *
       * <p> This method returns an asynchronous server socket channel that is
       * bound to the <em>default group</em>. This method is equivalent to evaluating
       * the expression:
       * <blockquote><pre>
       * open((AsynchronousChannelGroup)null);
       * </pre></blockquote>
       *
       * @return  A new asynchronous server socket channel
       *
       * @throws  IOException
       *          If an I/O error occurs
       */
      public static AsynchronousServerSocketChannel open()
          throws IOException
      {
          return open(null);
      }
  
      /**
       * Binds the channel's socket to a local address and configures the socket to
       * listen for connections.
       *
       * <p> An invocation of this method is equivalent to the following:
       * <blockquote><pre>
       * bind(local, 0);
       * </pre></blockquote>
       *
       * @param   local
       *          The local address to bind the socket, or <tt>null</tt> to bind
       *          to an automatically assigned socket address
       *
       * @return  This channel
       *
       * @throws  AlreadyBoundException               {@inheritDoc}
       * @throws  UnsupportedAddressTypeException     {@inheritDoc}
       * @throws  SecurityException                   {@inheritDoc}
       * @throws  ClosedChannelException              {@inheritDoc}
       * @throws  IOException                         {@inheritDoc}
       */
      public final AsynchronousServerSocketChannel bind(SocketAddress local)
          throws IOException
      {
          return bind(local, 0);
      }
  
      /**
       * Binds the channel's socket to a local address and configures the socket to
       * listen for connections.
       *
       * <p> This method is used to establish an association between the socket and
       * a local address. Once an association is established then the socket remains
       * bound until the associated channel is closed.
       *
       * <p> The {@code backlog} parameter is the maximum number of pending
       * connections on the socket. Its exact semantics are implementation specific.
       * In particular, an implementation may impose a maximum length or may choose
       * to ignore the parameter altogther. If the {@code backlog} parameter has
       * the value {@code 0}, or a negative value, then an implementation specific
       * default is used.
       *
       * @param   local
       *          The local address to bind the socket, or {@code null} to bind
       *          to an automatically assigned socket address
       * @param   backlog
       *          The maximum number of pending connections
       *
       * @return  This channel
       *
       * @throws  AlreadyBoundException
       *          If the socket is already bound
       * @throws  UnsupportedAddressTypeException
       *          If the type of the given address is not supported
       * @throws  SecurityException
       *          If a security manager has been installed and its {@link
       *          SecurityManager#checkListen checkListen} method denies the operation
       * @throws  ClosedChannelException
       *          If the channel is closed
       * @throws  IOException
       *          If some other I/O error occurs
       */
      public abstract AsynchronousServerSocketChannel bind(SocketAddress local, int backlog)
          throws IOException;
  
      /**
       * @throws  IllegalArgumentException                {@inheritDoc}
       * @throws  ClosedChannelException                  {@inheritDoc}
       * @throws  IOException                             {@inheritDoc}
       */
      public abstract <T> AsynchronousServerSocketChannel setOption(SocketOption<T> name, T value)
          throws IOException;
  
      /**
       * Accepts a connection.
       *
       * <p> This method initiates an asynchronous operation to accept a
       * connection made to this channel's socket. The {@code handler} parameter is
       * a completion handler that is invoked when a connection is accepted (or
       * the operation fails). The result passed to the completion handler is
       * the {@link AsynchronousSocketChannel} to the new connection.
       *
       * <p> When a new connection is accepted then the resulting {@code
       * AsynchronousSocketChannel} will be bound to the same {@link
       * AsynchronousChannelGroup} as this channel. If the group is {@link
       * AsynchronousChannelGroup#isShutdown shutdown} and a connection is accepted,
       * then the connection is closed, and the operation completes with an {@code
       * IOException} and cause {@link ShutdownChannelGroupException}.
       *
       * <p> To allow for concurrent handling of new connections, the completion
       * handler is not invoked directly by the initiating thread when a new
       * connection is accepted immediately (see <a
       * href="AsynchronousChannelGroup.html#threading">Threading</a>).
       *
       * <p> If a security manager has been installed then it verifies that the
       * address and port number of the connection's remote endpoint are permitted
       * by the security manager's {@link SecurityManager#checkAccept checkAccept}
       * method. The permission check is performed with privileges that are restricted
       * by the calling context of this method. If the permission check fails then
       * the connection is closed and the operation completes with a {@link
       * SecurityException}.
       *
       * @param   <A>
       *          The type of the attachment
       * @param   attachment
       *          The object to attach to the I/O operation; can be {@code null}
       * @param   handler
       *          The handler for consuming the result
       *
       * @throws  AcceptPendingException
       *          If an accept operation is already in progress on this channel
       * @throws  NotYetBoundException
       *          If this channel's socket has not yet been bound
       * @throws  ShutdownChannelGroupException
       *          If the channel group has terminated
       */
      public abstract <A> void accept(A attachment,
                                      CompletionHandler<AsynchronousSocketChannel,? super A> handler);
  
      /**
       * Accepts a connection.
       *
       * <p> This method initiates an asynchronous operation to accept a
       * connection made to this channel's socket. The method behaves in exactly
       * the same manner as the {@link #accept(Object, CompletionHandler)} method
       * except that instead of specifying a completion handler, this method
       * returns a {@code Future} representing the pending result. The {@code
       * Future}'s {@link Future#get() get} method returns the {@link
       * AsynchronousSocketChannel} to the new connection on successful completion.
       *
       * @return  a {@code Future} object representing the pending result
       *
       * @throws  AcceptPendingException
       *          If an accept operation is already in progress on this channel
       * @throws  NotYetBoundException
       *          If this channel's socket has not yet been bound
       */
      public abstract Future<AsynchronousSocketChannel> accept();
  
      /**
       * {@inheritDoc}
       * <p>
       * If there is a security manager set, its {@code checkConnect} method is
       * called with the local address and {@code -1} as its arguments to see
       * if the operation is allowed. If the operation is not allowed,
       * a {@code SocketAddress} representing the
       * {@link java.net.InetAddress#getLoopbackAddress loopback} address and the
       * local port of the channel's socket is returned.
       *
       * @return  The {@code SocketAddress} that the socket is bound to, or the
       *          {@code SocketAddress} representing the loopback address if
       *          denied by the security manager, or {@code null} if the
       *          channel's socket is not bound
       *
       * @throws  ClosedChannelException     {@inheritDoc}
       * @throws  IOException                {@inheritDoc}
       */
      @Override
      public abstract SocketAddress getLocalAddress() throws IOException;
  }
  