Clover coverage report - ActiveIO - 1.0
Coverage timestamp: Fri Apr 22 2005 14:27:22 PDT
file stats: LOC: 237   Methods: 28
NCLOC: 160   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
ByteArrayPacket.java 75% 82.1% 82.1% 81.1%
coverage coverage
 1   
 /**
 2   
  * 
 3   
  * Copyright 2004 Hiram Chirino
 4   
  * 
 5   
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 6   
  * use this file except in compliance with the License. You may obtain a copy of
 7   
  * 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, WITHOUT
 13   
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 14   
  * License for the specific language governing permissions and limitations under
 15   
  * the License.
 16   
  */
 17   
 package org.activeio.packet;
 18   
 
 19   
 import java.io.DataOutput;
 20   
 import java.io.IOException;
 21   
 import java.io.OutputStream;
 22   
 import java.lang.reflect.Constructor;
 23   
 
 24   
 import org.activeio.Packet;
 25   
 
 26   
 /**
 27   
  * Provides a Packet implementation that is directly backed by a <code>byte[]</code>.
 28   
  * 
 29   
  * @version $Revision$
 30   
  */
 31   
 final public class ByteArrayPacket implements Packet {
 32   
 
 33   
     private final byte buffer[];
 34   
 
 35   
     private final int offset;
 36   
     private final int capacity;
 37   
     private int position;
 38   
     private int limit;
 39   
     private int remaining;
 40   
     
 41   
 
 42  12436
     public ByteArrayPacket(byte buffer[]) {
 43  12436
         this(buffer,0, buffer.length);
 44   
     }
 45   
     
 46  35300
     public ByteArrayPacket(byte buffer[], int offset, int capacity) {
 47  35300
         this.buffer = buffer;
 48  35300
         this.offset=offset;
 49  35300
         this.capacity=capacity;
 50  35300
         this.position = 0;
 51  35300
         this.limit = capacity;
 52  35300
         this.remaining = limit-position;
 53   
     }
 54   
 
 55  4184
     public int position() {
 56  4184
         return position;
 57   
     }
 58   
 
 59  8460
     public void position(int position) {
 60  8460
         this.position = position;
 61  8460
         remaining = limit-position;
 62   
     }
 63   
 
 64  74
     public int limit() {
 65  74
         return limit;
 66   
     }
 67   
 
 68  144
     public void limit(int limit) {
 69  144
         this.limit = limit;
 70  144
         remaining = limit-position;
 71   
     }
 72   
 
 73  4248
     public void flip() {
 74  4248
         limit = position;
 75  4248
         position = 0;
 76  4248
         remaining = limit - position;
 77   
     }
 78   
 
 79  24578
     public int remaining() {
 80  24578
         return remaining;
 81   
     }
 82   
 
 83  6
     public void rewind() {
 84  6
         position = 0;
 85  6
         remaining = limit - position;
 86   
     }
 87   
 
 88  38488
     public boolean hasRemaining() {
 89  38488
         return remaining > 0;
 90   
     }
 91   
 
 92  24386
     public void clear() {
 93  24386
         position = 0;
 94  24386
         limit = capacity;
 95  24386
         remaining = limit - position;
 96   
     }
 97   
 
 98  2086
     public int capacity() {
 99  2086
         return capacity;
 100   
     }
 101   
 
 102  8686
     public Packet slice() {
 103  8686
         return new ByteArrayPacket(buffer, offset+position, remaining);
 104   
     }
 105   
     
 106  12170
     public Packet duplicate() {
 107  12170
         return new ByteArrayPacket(buffer, offset, capacity);
 108   
     }
 109   
 
 110  2004
     public Object duplicate(ClassLoader cl) throws IOException {
 111  2004
         try{
 112  2004
             Class clazz = cl.loadClass(ByteArrayPacket.class.getName());
 113  2004
             Constructor constructor = clazz.getConstructor(new Class[]{byte[].class, int.class, int.class});
 114  2004
             return constructor.newInstance(new Object[]{buffer, new Integer(offset), new Integer(capacity())});
 115   
         } catch (Throwable e) {
 116  0
             throw (IOException)new IOException("Could not duplicate packet in a different classloader: "+e).initCause(e);
 117   
         }
 118   
     }
 119   
 
 120  4120
     public void writeTo(OutputStream out) throws IOException {
 121  4120
         out.write(buffer, offset+position, remaining);
 122  4120
         position=limit;
 123  4120
         remaining = limit-position;
 124   
     }
 125   
     
 126  0
     public void writeTo(DataOutput out) throws IOException {
 127  0
         out.write(buffer, offset+position, remaining);
 128  0
         position=limit;
 129  0
         remaining = limit-position;
 130   
     }
 131   
 
 132   
     /**
 133   
      * @see org.activeio.Packet#read()
 134   
      */
 135  1295
     public int read() {
 136  1295
         if( !(remaining > 0) )
 137  2
             return -1;
 138  1293
         int rc = buffer[offset+position];
 139  1293
         position++;
 140  1293
         remaining = limit-position;
 141  1293
         return rc & 0xff;
 142   
     }
 143   
 
 144   
     /**
 145   
      * @see org.activeio.Packet#read(byte[], int, int)
 146   
      */
 147  78
     public int read(byte[] data, int offset, int length) {
 148  78
         if( !(remaining > 0) )
 149  16
             return -1;
 150   
         
 151  62
         int copyLength = ((length <= remaining) ? length : remaining);
 152  62
         System.arraycopy(buffer, this.offset+position, data, offset, copyLength);
 153  62
         position += copyLength;
 154  62
         remaining = limit-position;
 155  62
         return copyLength;
 156   
     }
 157   
 
 158   
     /**
 159   
      * @see org.activeio.Packet#write(int)
 160   
      */
 161  1592
     public boolean write(int data) {
 162  1592
         if( !(remaining > 0) )
 163  2
             return false;
 164  1590
         buffer[offset+position]=(byte) data;
 165  1590
         position++;
 166  1590
         remaining = limit-position;
 167  1590
         return true;
 168   
     }
 169   
 
 170   
     /**
 171   
      * @see org.activeio.Packet#write(byte[], int, int)
 172   
      */
 173  8246
     public int write(byte[] data, int offset, int length) {
 174  8246
         if( !(remaining > 0) )
 175  16
             return -1;
 176   
         
 177  8230
         int copyLength = ((length <= remaining) ? length : remaining);
 178  8230
         System.arraycopy(data, offset, buffer, this.offset+position, copyLength);
 179  8230
         position+=copyLength;
 180  8230
         remaining = limit-position;
 181  8230
         return copyLength;
 182   
     }
 183   
 
 184  8255
     public ByteSequence asByteSequence() {
 185  8255
         return new ByteSequence(buffer, offset+position, remaining);
 186   
     }
 187   
 
 188   
     /**
 189   
      * @see org.activeio.Packet#sliceAsBytes()
 190   
      */
 191  24288
     public byte[] sliceAsBytes() {
 192  24288
         if( buffer.length == remaining ) {
 193  24288
             return buffer;
 194   
         } else {
 195  0
             byte rc[] = new byte[remaining];
 196  0
             int op = position;
 197  0
             write(rc,0,remaining);
 198  0
             position=op;
 199  0
             remaining = limit-position;
 200  0
             return rc;
 201   
         }
 202   
     }
 203   
     
 204   
     /**
 205   
      * @param dest
 206   
      * @return the number of bytes read into the dest.
 207   
      */
 208  12198
     public int read(Packet dest) {        
 209  12198
         int a = dest.remaining();
 210  12198
         int rc = ((a <= remaining) ? a : remaining); 
 211  12198
         if( rc > 0 ) {
 212  12198
             dest.write( buffer, offset+position, rc);
 213  12198
             position = position+rc;
 214  12198
             remaining = limit-position;
 215   
         }
 216  12198
         return rc;
 217   
     }
 218   
     
 219  0
     public String toString() {
 220  0
         return "{position="+position+",limit="+limit+",capacity="+capacity+"}";
 221   
     }
 222   
 
 223  0
     public Object narrow(Class target) {
 224  0
         if( target.isAssignableFrom(getClass()) ) {
 225  0
             return this;
 226   
         }
 227  0
         return null;
 228   
     }
 229   
     
 230  0
     public byte[] getBuffer() {
 231  0
         return buffer;
 232   
     }
 233   
     
 234  0
     public void dispose() {        
 235   
     }
 236   
 }
 237