libjava/java/nio/channels/spi/AbstractSelectableChannel.java

   1 /* AbstractSelectableChannel.java
   2    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package java.nio.channels.spi;
  39
  40 import java.io.IOException;
  41 import java.nio.channels.ClosedChannelException;
  42 import java.nio.channels.SelectableChannel;
  43 import java.nio.channels.SelectionKey;
  44 import java.nio.channels.Selector;
  45 import java.util.LinkedList;
  46 import java.util.List;
  47 import java.util.ListIterator;
  48
  49 public abstract class AbstractSelectableChannel extends SelectableChannel
  50 {
  51   private boolean blocking = true;
  52   private Object LOCK = new Object();
  53   private SelectorProvider provider;
  54   private LinkedList keys;
  55
  56   /**
  57    * Initializes the channel
  58    */
  59   protected AbstractSelectableChannel (SelectorProvider provider)
  60   {
  61     this.provider = provider;
  62     this.keys = new LinkedList();
  63   }
  64
  65   /**
  66    * Retrieves the object upon which the configureBlocking and register
  67    * methods synchronize.
  68    */
  69   public final Object blockingLock ()
  70   {
  71     return LOCK;
  72   }
  73
  74   /**
  75    * Adjusts this channel's blocking mode.
  76    */
  77   public final SelectableChannel configureBlocking (boolean blocking)
  78     throws IOException
  79   {
  80     synchronized (blockingLock())
  81       {
  82         if (this.blocking != blocking)
  83           {
  84             implConfigureBlocking(blocking);
  85             this.blocking = blocking;
  86           }
  87       }
  88
  89     return this;
  90   }
  91
  92   /**
  93    * Closes this channel.
  94    *
  95    * @exception IOException If an error occurs
  96    */
  97   protected final void implCloseChannel () throws IOException
  98   {
  99     implCloseSelectableChannel ();
 100   }
 101
 102   /**
 103    * Closes this selectable channel.
 104    */
 105   protected abstract void implCloseSelectableChannel () throws IOException;
 106
 107   /**
 108    * Adjusts this channel's blocking mode.
 109    */
 110   protected abstract void implConfigureBlocking (boolean block)
 111     throws IOException;
 112
 113   /**
 114    * Tells whether or not every I/O operation on this channel will block
 115    * until it completes.
 116    */
 117   public final boolean isBlocking()
 118   {
 119     return blocking;
 120   }
 121
 122   /**
 123    * Tells whether or not this channel is currently registered with
 124    * any selectors.
 125    */
 126   public final boolean isRegistered()
 127   {
 128     return !keys.isEmpty();
 129   }
 130
 131   /**
 132    * Retrieves the key representing the channel's registration with the
 133    * given selector.
 134    */
 135   public final SelectionKey keyFor(Selector selector)
 136   {
 137     if (! isOpen())
 138       return null;
 139
 140     try
 141       {
 142         synchronized(blockingLock())
 143           {
 144             return locate (selector);
 145           }
 146       }
 147     catch (Exception e)
 148       {
 149         return null;
 150       }
 151   }
 152
 153   /**
 154    * Returns the provider that created this channel.
 155    */
 156   public final SelectorProvider provider ()
 157   {
 158     return provider;
 159   }
 160
 161   private SelectionKey locate (Selector selector)
 162   {
 163     if (keys == null)
 164       return null;
 165
 166     ListIterator it = keys.listIterator ();
 167
 168     while (it.hasNext ())
 169       {
 170         SelectionKey key = (SelectionKey) it.next();
 171
 172         if (key.selector() == selector)
 173           return key;
 174       }
 175
 176     return null;
 177   }
 178
 179   private void add (SelectionKey key)
 180   {
 181     keys.add (key);
 182   }
 183
 184   /**
 185    * Registers this channel with the given selector, returning a selection key.
 186    *
 187    * @exception ClosedChannelException If the channel is already closed.
 188    */
 189   public final SelectionKey register (Selector selin, int ops, Object att)
 190     throws ClosedChannelException
 191   {
 192     if (!isOpen ())
 193       throw new ClosedChannelException();
 194
 195     SelectionKey key = null;
 196     AbstractSelector selector = (AbstractSelector) selin;
 197
 198     synchronized (blockingLock())
 199       {
 200         key = locate (selector);
 201
 202         if (key != null)
 203           {
 204             if (att != null)
 205               key.attach (att);
 206           }
 207         else
 208           {
 209             key = selector.register (this, ops, att);
 210
 211             if (key != null)
 212               add (key);
 213           }
 214       }
 215
 216     return key;
 217   }
 218 }