Clover coverage report - ActiveIO - 1.0
Coverage timestamp: Fri Apr 22 2005 14:27:22 PDT
file stats: LOC: 162   Methods: 16
NCLOC: 132   Classes: 3
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
AsynchWriteAsynchChannelAdapter.java 0% 0% 0% 0%
coverage
 1   
 package org.activeio.adapter;
 2   
 
 3   
 import java.io.IOException;
 4   
 import java.io.InterruptedIOException;
 5   
 
 6   
 import org.activeio.AsynchChannel;
 7   
 import org.activeio.ChannelFactory;
 8   
 import org.activeio.FilterAsynchChannel;
 9   
 import org.activeio.Packet;
 10   
 
 11   
 import EDU.oswego.cs.dl.util.concurrent.BoundedBuffer;
 12   
 import EDU.oswego.cs.dl.util.concurrent.Channel;
 13   
 import EDU.oswego.cs.dl.util.concurrent.Executor;
 14   
 import EDU.oswego.cs.dl.util.concurrent.Latch;
 15   
 import EDU.oswego.cs.dl.util.concurrent.PooledExecutor;
 16   
 import EDU.oswego.cs.dl.util.concurrent.SynchronizedInt;
 17   
 
 18   
 public class AsynchWriteAsynchChannelAdapter extends FilterAsynchChannel {
 19   
     
 20   
     static public class ObjectDispatcherX implements Runnable {
 21   
         
 22   
         private final Executor executor;
 23   
         private final Channel queue;
 24   
         private final SynchronizedInt size = new SynchronizedInt(0);
 25   
         private final AsynchWriteAsynchChannelAdapter objectListener; 
 26   
         private long pollDelay=10;
 27   
         
 28  0
         public ObjectDispatcherX(AsynchWriteAsynchChannelAdapter objectListener) {
 29  0
             this(objectListener, 10);
 30   
         }
 31   
 
 32  0
         public ObjectDispatcherX(AsynchWriteAsynchChannelAdapter objectListener, int queueSize) {
 33  0
             this(objectListener, ChannelFactory.DEFAULT_EXECUTOR, new BoundedBuffer(queueSize));
 34   
         }
 35   
 
 36  0
         public ObjectDispatcherX(AsynchWriteAsynchChannelAdapter objectListener, Executor executor, Channel queue) {
 37  0
             this.objectListener = objectListener;
 38  0
             this.executor = executor;
 39  0
             this.queue=queue;
 40   
         }
 41   
         
 42  0
         public void add(Object o) throws InterruptedException {
 43  0
             int t = size.increment();
 44  0
             queue.put(o);
 45  0
             if( t==1 ) {
 46  0
                 executor.execute(this);
 47   
             }
 48   
         }
 49   
 
 50  0
         synchronized public void run() {
 51  0
             int t = size.get();
 52  0
             while( t > 0 ) {
 53  0
                 int count=0;
 54  0
                 try {
 55  0
                     Object o;
 56  0
                     while( (o=queue.poll(pollDelay))!=null ) {
 57  0
                         count++;
 58  0
                         objectListener.onObject(o);
 59   
                     }
 60   
                 } catch (InterruptedException e) {
 61  0
                     Thread.currentThread().interrupt();
 62  0
                     return;
 63   
                 } finally {
 64  0
                     t = size.subtract(count);
 65   
                 }
 66   
             }                
 67   
         }
 68   
 
 69   
     }
 70   
     static public class ObjectDispatcher {
 71   
         
 72   
         private final PooledExecutor executor;
 73   
         private final AsynchWriteAsynchChannelAdapter objectListener;
 74   
         
 75  0
         public ObjectDispatcher(AsynchWriteAsynchChannelAdapter objectListener) {
 76  0
             this(objectListener, 10);
 77   
         }
 78   
 
 79  0
         public ObjectDispatcher(AsynchWriteAsynchChannelAdapter objectListener, int queueSize) {
 80  0
             this.objectListener = objectListener;
 81  0
             executor = new PooledExecutor(new BoundedBuffer(queueSize), 1);
 82  0
             executor.waitWhenBlocked();
 83   
         }
 84   
         
 85  0
         public void add(final Object o) throws InterruptedException {
 86  0
             executor.execute(new Runnable(){
 87  0
                 public void run() {
 88  0
                     objectListener.onObject(o);
 89   
                 }
 90   
             }); 
 91   
         }
 92   
     }
 93   
 
 94   
     private final ObjectDispatcher dispatcher;
 95   
     private static final Object FLUSH_COMMAND = new Object();
 96   
     
 97  0
     public AsynchWriteAsynchChannelAdapter(AsynchChannel next) {
 98  0
         this(next, 10);
 99   
     }
 100   
     
 101  0
     public AsynchWriteAsynchChannelAdapter(AsynchChannel next, int queueSize) {
 102  0
         super(next);
 103  0
         this.dispatcher = new ObjectDispatcher(this, queueSize);
 104   
     }
 105   
 
 106  0
     public void onObject(Object o) {
 107  0
         try {
 108  0
             if( o == FLUSH_COMMAND ) {
 109  0
                 next.flush();
 110  0
                 return;
 111   
             }
 112  0
             if( o.getClass() == Latch.class ) {
 113  0
                 next.flush();
 114  0
                 ((Latch)o).release();
 115  0
                 return;
 116   
             }
 117  0
             next.write((Packet)o);
 118   
         } catch (IOException e) {
 119  0
             channelListener.onPacketError(e);
 120   
         }
 121   
     }
 122   
             
 123  0
     public void write(Packet packet) throws IOException {
 124  0
         try {
 125  0
             dispatcher.add(packet);
 126   
         } catch (InterruptedException e) {
 127  0
             throw new InterruptedIOException();
 128   
         }
 129   
     }
 130   
 
 131  0
     public void flush() throws IOException {
 132  0
         flush(NO_WAIT_TIMEOUT);
 133   
     }
 134   
     
 135  0
     public void stop(long timeout) throws IOException {
 136  0
         flush(WAIT_FOREVER_TIMEOUT);        
 137   
     }
 138   
     
 139   
 
 140   
     /**
 141   
      * @param timeout
 142   
      * @throws InterruptedIOException
 143   
      */
 144  0
     private void flush(long timeout) throws InterruptedIOException {
 145  0
         try {
 146  0
             if( timeout == NO_WAIT_TIMEOUT ) {
 147  0
                 dispatcher.add(FLUSH_COMMAND);
 148  0
             } else if( timeout == WAIT_FOREVER_TIMEOUT ) {
 149  0
                 Latch l = new Latch();
 150  0
                 dispatcher.add(l);
 151  0
                 l.acquire();
 152   
             } else {
 153  0
                 Latch l = new Latch();
 154  0
                 dispatcher.add(l);
 155  0
                 l.attempt(timeout);
 156   
             }
 157   
         } catch (InterruptedException e) {
 158  0
             throw new InterruptedIOException();
 159   
         }
 160   
     }
 161   
 }
 162