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 }