1 /***
2 *
3 * Copyright 2004 Protique Ltd
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.codehaus.activemq.message.util;
20 import java.io.ByteArrayInputStream;
21
22 /***
23 * Optimized ByteArrayInputStream that can be used more than once. Which is nice.
24 *
25 * @version $Revision: 1.1 $
26 */
27 public class WireByteArrayInputStream extends ByteArrayInputStream {
28 /***
29 * Creates a <code>WireByteArrayInputStream</code>.
30 *
31 * @param buf the input buffer.
32 */
33 public WireByteArrayInputStream(byte buf[]) {
34 super(buf);
35 }
36
37 /***
38 * Creates <code>WireByteArrayInputStream</code> that uses <code>buf</code> as its buffer array.
39 *
40 * @param buf the input buffer.
41 * @param offset the offset in the buffer of the first byte to read.
42 * @param length the maximum number of bytes to read from the buffer.
43 */
44 public WireByteArrayInputStream(byte buf[], int offset, int length) {
45 super(buf, offset, length);
46 }
47
48 /***
49 * Creates <code>WireByteArrayInputStream</code> with a minmalist byte array
50 */
51 public WireByteArrayInputStream() {
52 super(new byte[0]);
53 }
54
55 /***
56 * reset the <code>WireByteArrayInputStream</code> to use an new byte array
57 *
58 * @param newBuff buffer to use
59 * @param offset the offset in the buffer of the first byte to read.
60 * @param length the maximum number of bytes to read from the buffer.
61 */
62 public void restart(byte[] newBuff, int offset, int length) {
63 buf = newBuff;
64 pos = offset;
65 count = Math.min(offset + length, newBuff.length);
66 mark = offset;
67 }
68
69 /***
70 * reset the <code>WireByteArrayInputStream</code> to use an new byte array
71 *
72 * @param newBuff
73 */
74 public void restart(byte[] newBuff) {
75 restart(newBuff, 0, newBuff.length);
76 }
77
78 /***
79 * Reads the next byte of data from this input stream. The value byte is returned as an <code>int</code> in the
80 * range <code>0</code> to <code>255</code>. If no byte is available because the end of the stream has been
81 * reached, the value <code>-1</code> is returned.
82 * <p>
83 * This <code>read</code> method cannot block.
84 *
85 * @return the next byte of data, or <code>-1</code> if the end of the stream has been reached.
86 */
87 public int read() {
88 return (pos < count) ? (buf[pos++] & 0xff) : -1;
89 }
90
91 /***
92 * Reads up to <code>len</code> bytes of data into an array of bytes from this input stream.
93 *
94 * @param b the buffer into which the data is read.
95 * @param off the start offset of the data.
96 * @param len the maximum number of bytes read.
97 * @return the total number of bytes read into the buffer, or <code>-1</code> if there is no more data because the
98 * end of the stream has been reached.
99 */
100 public int read(byte b[], int off, int len) {
101 if (b == null) {
102 throw new NullPointerException();
103 }
104 else if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0)) {
105 throw new IndexOutOfBoundsException();
106 }
107 if (pos >= count) {
108 return -1;
109 }
110 if (pos + len > count) {
111 len = count - pos;
112 }
113 if (len <= 0) {
114 return 0;
115 }
116 System.arraycopy(buf, pos, b, off, len);
117 pos += len;
118 return len;
119 }
120
121 /***
122 * @return the number of bytes that can be read from the input stream without blocking.
123 */
124 public int available() {
125 return count - pos;
126 }
127 }