WireByteArrayInputStream xref

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.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 }