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 BytePacket implements Packet { 32 33 private byte data; 34 private byte position; 35 private byte limit; 36 37 public BytePacket(byte data) { 38 this.data = data; 39 clear(); 40 } 41 42 public int position() { 43 return position; 44 } 45 46 public void position(int position) { 47 this.position = (byte) position; 48 } 49 50 public int limit() { 51 return limit; 52 } 53 54 public void limit(int limit) { 55 this.limit = (byte) limit; 56 } 57 58 public void flip() { 59 limit(position()); 60 position(0); 61 } 62 63 public int remaining() { 64 return limit() - position(); 65 } 66 67 public void rewind() { 68 position(0); 69 } 70 71 public boolean hasRemaining() { 72 return remaining() > 0; 73 } 74 75 public void clear() { 76 position(0); 77 limit(capacity()); 78 } 79 80 public int capacity() { 81 return 1; 82 } 83 84 public Packet slice() { 85 if( hasRemaining() ) 86 return new BytePacket(data); 87 return EmptyPacket.EMPTY_PACKET; 88 } 89 90 public Packet duplicate() { 91 BytePacket packet = new BytePacket(data); 92 packet.limit(limit()); 93 packet.position(position()); 94 return packet; 95 } 96 97 public Object duplicate(ClassLoader cl) throws IOException { 98 try { 99 Class clazz = cl.loadClass(BytePacket.class.getName()); 100 Constructor constructor = clazz.getConstructor(new Class[]{byte.class}); 101 return constructor.newInstance(new Object[]{new Byte(data)}); 102 } catch (Throwable e) { 103 throw (IOException)new IOException("Could not duplicate packet in a different classloader: "+e).initCause(e); 104 } 105 } 106 107 public void writeTo(OutputStream out) throws IOException { 108 if( hasRemaining() ) { 109 out.write(data); 110 position(1); 111 } 112 } 113 114 public void writeTo(DataOutput out) throws IOException { 115 if( hasRemaining() ) { 116 out.write(data); 117 position(1); 118 } 119 } 120 121 /*** 122 * @see org.activeio.Packet#read() 123 */ 124 public int read() { 125 if( !hasRemaining() ) 126 return -1; 127 position(1); 128 return data & 0xff; 129 } 130 131 /*** 132 * @see org.activeio.Packet#read(byte[], int, int) 133 */ 134 public int read(byte[] data, int offset, int length) { 135 if( !hasRemaining() ) 136 return -1; 137 138 if( length > 0 ) { 139 data[offset] = this.data; 140 position(1); 141 return 1; 142 } 143 return 0; 144 } 145 146 /*** 147 * @see org.activeio.Packet#write(int) 148 */ 149 public boolean write(int data) { 150 if( !hasRemaining() ) 151 return false; 152 153 this.data = (byte) data; 154 position(1); 155 return true; 156 } 157 158 /*** 159 * @see org.activeio.Packet#write(byte[], int, int) 160 */ 161 public int write(byte[] data, int offset, int length) { 162 if( !hasRemaining() ) 163 return -1; 164 165 if( length > 0 ) { 166 this.data = data[offset] ; 167 position(1); 168 return 1; 169 } 170 return 0; 171 } 172 173 public ByteSequence asByteSequence() { 174 return null; 175 } 176 177 /*** 178 * @see org.activeio.Packet#sliceAsBytes() 179 */ 180 public byte[] sliceAsBytes() { 181 return null; 182 } 183 184 /*** 185 * @param dest 186 * @return the number of bytes read into the dest. 187 */ 188 public int read(Packet dest) { 189 if( hasRemaining() ) { 190 dest.write(data); 191 position(1); 192 return 1; 193 } 194 return 0; 195 } 196 197 public String toString() { 198 return "{position="+position()+",limit="+limit()+",capacity="+capacity()+"}"; 199 } 200 201 public Object narrow(Class target) { 202 if( target.isAssignableFrom(getClass()) ) { 203 return this; 204 } 205 return null; 206 } 207 208 public void dispose() { 209 } 210 }