Clover coverage report - ActiveIO - 1.0
Coverage timestamp: Fri Apr 22 2005 14:27:22 PDT
file stats: LOC: 243   Methods: 37
NCLOC: 181   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 Source file Conditionals Statements Methods TOTAL
SocketSynchChannel.java 75% 67.6% 48.6% 62.9%
coverage coverage
 1   
 /** 
 2   
  * 
 3   
  * Copyright 2004 Hiram Chirino
 4   
  * 
 5   
  * Licensed under the Apache License, Version 2.0 (the "License"); 
 6   
  * you may not use this file except in compliance with the License. 
 7   
  * You may obtain a copy of the License at 
 8   
  * 
 9   
  * http://www.apache.org/licenses/LICENSE-2.0
 10   
  * 
 11   
  * Unless required by applicable law or agreed to in writing, software
 12   
  * distributed under the License is distributed on an "AS IS" BASIS, 
 13   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 14   
  * See the License for the specific language governing permissions and 
 15   
  * limitations under the License. 
 16   
  * 
 17   
  **/
 18   
 
 19   
 package org.activeio.net;
 20   
 
 21   
 import java.io.IOException;
 22   
 import java.io.InputStream;
 23   
 import java.io.OutputStream;
 24   
 import java.net.InetAddress;
 25   
 import java.net.Socket;
 26   
 import java.net.SocketAddress;
 27   
 import java.net.SocketException;
 28   
 import java.net.SocketTimeoutException;
 29   
 
 30   
 import org.activeio.Packet;
 31   
 import org.activeio.SynchChannel;
 32   
 import org.activeio.SynchChannelServer;
 33   
 import org.activeio.Packet.ByteSequence;
 34   
 import org.activeio.packet.ByteArrayPacket;
 35   
 import org.activeio.packet.EOSPacket;
 36   
 import org.activeio.packet.EmptyPacket;
 37   
 
 38   
 /**
 39   
  * A {@see org.activeio.SynchChannel} implementation that uses a {@see java.net.Socket}
 40   
  *  to talk to the network.
 41   
  * 
 42   
  * @version $Revision$
 43   
  */
 44   
 public class SocketSynchChannel implements SynchChannel, SocketMetadata {
 45   
 
 46   
     protected static final int DEFAULT_BUFFER_SIZE = 64 * 1024;
 47   
 
 48   
     private final Socket socket;
 49   
     private final OutputStream out;
 50   
     private final InputStream in;    
 51   
     private boolean disposed;
 52   
     private int curentSoTimeout;
 53   
 
 54   
     private Packet inputPacket;
 55   
     
 56  81
     protected SocketSynchChannel(Socket socket) throws IOException {
 57  82
         this.socket = socket;
 58  81
         socket.setReceiveBufferSize(DEFAULT_BUFFER_SIZE);
 59  80
         socket.setSendBufferSize(DEFAULT_BUFFER_SIZE);
 60  82
         in = socket.getInputStream();
 61  80
         out = socket.getOutputStream();        
 62   
     }
 63   
 
 64   
     /**
 65   
      * @see org.activeio.SynchChannel#read(long)
 66   
      */
 67  4189
     public org.activeio.Packet read(long timeout) throws IOException {
 68  4189
         try {
 69   
             
 70  4189
             if( timeout==SynchChannelServer.WAIT_FOREVER_TIMEOUT )
 71  0
                 setSoTimeout( 0 );
 72  4189
             else if( timeout==SynchChannelServer.NO_WAIT_TIMEOUT )
 73  0
                 setSoTimeout( 1 );
 74   
             else 
 75  4189
                 setSoTimeout( (int)timeout );
 76   
 
 77  4189
             if( inputPacket==null || !inputPacket.hasRemaining() ) {
 78  46
                 inputPacket = allocatePacket();
 79   
             }
 80   
             
 81  4189
             ByteSequence sequence = inputPacket.asByteSequence();
 82  4189
             int size = in.read(sequence.getData(), sequence.getOffset(), sequence.getLength());
 83  4132
             if( size == -1 )
 84  20
                 return EOSPacket.EOS_PACKET;
 85  4112
             if( size == 0 )
 86  0
                 return EmptyPacket.EMPTY_PACKET;
 87  4112
             inputPacket.position(size);
 88   
             
 89  4112
             Packet remaining = inputPacket.slice();
 90  4112
             inputPacket.flip();
 91  4112
             Packet data = inputPacket.slice();
 92   
 
 93   
             // Keep the remaining buffer around to fill with data.
 94  4112
             inputPacket = remaining;
 95  4112
             return data;
 96   
             
 97   
         } catch (SocketTimeoutException e) {
 98  56
             return null;
 99   
         }
 100   
     }
 101   
 
 102  46
     private Packet allocatePacket() {
 103  46
         return new ByteArrayPacket(new byte[DEFAULT_BUFFER_SIZE]);
 104   
     }
 105   
 
 106  4189
     protected void setSoTimeout(int i) throws SocketException {
 107  4189
         if( curentSoTimeout != i ) {
 108  57
             socket.setSoTimeout(i);
 109  57
             curentSoTimeout = i;
 110   
         }
 111   
     }
 112   
     
 113   
     /**
 114   
      * @see org.activeio.Channel#write(org.activeio.channel.Packet)
 115   
      */
 116  4120
     public void write(Packet packet) throws IOException {
 117  4120
         packet.writeTo(out);
 118   
     }
 119   
 
 120   
     /**
 121   
      * @see org.activeio.Channel#flush()
 122   
      */
 123  4093
     public void flush() throws IOException {
 124  4093
         out.flush();
 125   
     }
 126   
 
 127   
     /**
 128   
      * @see org.activeio.Disposable#dispose()
 129   
      */
 130  74
     public void dispose() {
 131  74
         if (disposed)
 132  6
             return;
 133   
 
 134  68
         try {
 135  68
             out.close();
 136   
         } catch (IOException ignore) {
 137   
         }
 138  68
         try {
 139  68
             in.close();
 140   
         } catch (IOException ignore) {
 141   
         }
 142  68
         try {
 143  68
             socket.close();
 144   
         } catch (IOException ignore) {
 145   
         }
 146  68
         disposed = true;
 147   
     }
 148   
 
 149  68
     public void start() throws IOException {
 150   
     }
 151  12
     public void stop(long timeout) throws IOException {
 152   
     }
 153   
     
 154  4
     public InetAddress getInetAddress() {
 155  4
         return socket.getInetAddress();
 156   
     }
 157  0
     public boolean getKeepAlive() throws SocketException {
 158  0
         return socket.getKeepAlive();
 159   
     }
 160  0
     public InetAddress getLocalAddress() {
 161  0
         return socket.getLocalAddress();
 162   
     }
 163  2
     public int getLocalPort() {
 164  2
         return socket.getLocalPort();
 165   
     }
 166  44
     public SocketAddress getLocalSocketAddress() {
 167  44
         return socket.getLocalSocketAddress();
 168   
     }
 169  0
     public boolean getOOBInline() throws SocketException {
 170  0
         return socket.getOOBInline();
 171   
     }
 172  2
     public int getPort() {
 173  2
         return socket.getPort();
 174   
     }
 175  0
     public int getReceiveBufferSize() throws SocketException {
 176  0
         return socket.getReceiveBufferSize();
 177   
     }
 178  44
     public SocketAddress getRemoteSocketAddress() {
 179  44
         return socket.getRemoteSocketAddress();
 180   
     }
 181  0
     public boolean getReuseAddress() throws SocketException {
 182  0
         return socket.getReuseAddress();
 183   
     }
 184  0
     public int getSendBufferSize() throws SocketException {
 185  0
         return socket.getSendBufferSize();
 186   
     }
 187  0
     public int getSoLinger() throws SocketException {
 188  0
         return socket.getSoLinger();
 189   
     }
 190  0
     public int getSoTimeout() throws SocketException {
 191  0
         return socket.getSoTimeout();
 192   
     }
 193  0
     public boolean getTcpNoDelay() throws SocketException {
 194  0
         return socket.getTcpNoDelay();
 195   
     }
 196  0
     public int getTrafficClass() throws SocketException {
 197  0
         return socket.getTrafficClass();
 198   
     }
 199  0
     public boolean isBound() {
 200  0
         return socket.isBound();
 201   
     }
 202  0
     public boolean isClosed() {
 203  0
         return socket.isClosed();
 204   
     }
 205  0
     public boolean isConnected() {
 206  0
         return socket.isConnected();
 207   
     }
 208  0
     public void setKeepAlive(boolean on) throws SocketException {
 209  0
         socket.setKeepAlive(on);
 210   
     }
 211  0
     public void setOOBInline(boolean on) throws SocketException {
 212  0
         socket.setOOBInline(on);
 213   
     }
 214  0
     public void setReceiveBufferSize(int size) throws SocketException {
 215  0
         socket.setReceiveBufferSize(size);
 216   
     }
 217  0
     public void setReuseAddress(boolean on) throws SocketException {
 218  0
         socket.setReuseAddress(on);
 219   
     }
 220  0
     public void setSendBufferSize(int size) throws SocketException {
 221  0
         socket.setSendBufferSize(size);
 222   
     }
 223  2
     public void setSoLinger(boolean on, int linger) throws SocketException {
 224  2
         socket.setSoLinger(on, linger);
 225   
     }
 226  56
     public void setTcpNoDelay(boolean on) throws SocketException {
 227  56
         socket.setTcpNoDelay(on);
 228   
     }
 229  0
     public void setTrafficClass(int tc) throws SocketException {
 230  0
         socket.setTrafficClass(tc);
 231   
     }
 232   
     
 233  66
     public Object narrow(Class target) {
 234  66
         if( target.isAssignableFrom(getClass()) ) {
 235  66
             return this;
 236   
         }
 237  0
         return null;
 238   
     }
 239   
 
 240  26
     public String toString() {
 241  26
         return "Socket Connection: "+getLocalSocketAddress()+" -> "+getRemoteSocketAddress();
 242   
     }
 243   
 }