View Javadoc

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.ByteArrayOutputStream;
21  
22  /***
23   * Optimized ByteArrayOutputStream
24   * 
25   * @version $Revision: 1.2 $
26   */
27  public class WireByteArrayOutputStream extends ByteArrayOutputStream {
28      /***
29       * Creates a new byte array output stream. The buffer capacity is initially 32 bytes, though its size increases if
30       * necessary.
31       */
32      public WireByteArrayOutputStream() {
33          super(32);
34      }
35  
36      /***
37       * Creates a new byte array output stream, with a buffer capacity of the specified size, in bytes.
38       * 
39       * @param size the initial size.
40       * @exception IllegalArgumentException if size is negative.
41       */
42      public WireByteArrayOutputStream(int size) {
43          super(size);
44      }
45  
46      /***
47       * start using a fresh byte array
48       * 
49       * @param size
50       */
51      public void restart(int size) {
52          buf = new byte[size];
53          count = 0;
54      }
55  
56      /***
57       * start using a fresh byte array
58       */
59      public void restart() {
60          restart(32);
61      }
62  
63      /***
64       * Writes the specified byte to this byte array output stream.
65       * 
66       * @param b the byte to be written.
67       */
68      public void write(int b) {
69          int newcount = count + 1;
70          if (newcount > buf.length) {
71              byte newbuf[] = new byte[Math.max(buf.length << 1, newcount)];
72              System.arraycopy(buf, 0, newbuf, 0, count);
73              buf = newbuf;
74          }
75          buf[count] = (byte) b;
76          count = newcount;
77      }
78  
79      /***
80       * Writes <code>len</code> bytes from the specified byte array starting at offset <code>off</code> to this byte
81       * array output stream.
82       * 
83       * @param b the data.
84       * @param off the start offset in the data.
85       * @param len the number of bytes to write.
86       */
87      public void write(byte b[], int off, int len) {
88          if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0)) {
89              throw new IndexOutOfBoundsException();
90          }
91          else if (len == 0) {
92              return;
93          }
94          int newcount = count + len;
95          if (newcount > buf.length) {
96              byte newbuf[] = new byte[Math.max(buf.length << 1, newcount)];
97              System.arraycopy(buf, 0, newbuf, 0, count);
98              buf = newbuf;
99          }
100         System.arraycopy(b, off, buf, count, len);
101         count = newcount;
102     }
103 
104     /***
105      * @return the underlying byte[] buffer
106      */
107     public byte[] getData() {
108         return buf;
109     }
110     
111     /***
112      * reset the output stream
113      */
114     public void reset(){
115         count = 0;
116     }
117 }