View Javadoc

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 }