ByteArraySeekableStream.java
上传用户:btjssb159
上传日期:2018-01-04
资源大小:241k
文件大小:8k
源码类别:

DNA

开发平台:

Java

  1. /*
  2.  * Copyright (c) 2001 Sun Microsystems, Inc. All Rights Reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without 
  5.  * modification, are permitted provided that the following conditions are met:
  6.  * 
  7.  * -Redistributions of source code must retain the above copyright notice, this 
  8.  * list of conditions and the following disclaimer.
  9.  *
  10.  * -Redistribution in binary form must reproduct the above copyright notice,
  11.  * this list of conditions and the following disclaimer in the documentation
  12.  * and/or other materials provided with the distribution.
  13.  * 
  14.  * Neither the name of Sun Microsystems, Inc. or the names of contributors may
  15.  * be used to endorse or promote products derived from this software without
  16.  * specific prior written permission.
  17.  * 
  18.  * This software is provided "AS IS," without a warranty of any kind. ALL
  19.  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
  20.  * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  21.  * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
  22.  * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
  23.  * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
  24.  * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
  25.  * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
  26.  * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
  27.  * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
  28.  * POSSIBILITY OF SUCH DAMAGES.
  29.  * 
  30.  * You acknowledge that Software is not designed,licensed or intended for use in 
  31.  * the design, construction, operation or maintenance of any nuclear facility.
  32.  */
  33. import java.io.InputStream;
  34. import java.io.IOException;
  35. /**
  36.  * A subclass of <code>SeekableStream</code> that takes input from an
  37.  * array of bytes.  Seeking backwards is supported.  The
  38.  * <code>mark()</code> and <code>resest()</code> methods are
  39.  * supported.
  40.  *
  41.  * <p><b> This class is not a committed part of the JAI API.  It may
  42.  * be removed or changed in future releases of JAI.</b>
  43.  */
  44. public class ByteArraySeekableStream extends SeekableStream {
  45.     /** Array holding the source data. */
  46.     private byte[] src;
  47.     /** The starting offset within the array. */
  48.     private int offset;
  49.     /** The length of the valid segment of the array. */
  50.     private int length;
  51.     
  52.     /** The current output position. */
  53.     private int pointer;
  54.     /**
  55.      * Constructs a <code>ByteArraySeekableStream</code> taking
  56.      * input from a given segment of an input <code>byte</code> array.
  57.      */
  58.     public ByteArraySeekableStream(byte[] src, int offset, int length)
  59.         throws IOException {
  60.         this.src = src;
  61.         this.offset = offset;
  62.         this.length = length;
  63.     }
  64.     /**
  65.      * Constructs a <code>ByteArraySeekableStream</code> taking
  66.      * input from an entire input <code>byte</code> array.
  67.      */
  68.     public ByteArraySeekableStream(byte[] src) throws IOException {
  69.         this(src, 0, src.length);
  70.     }
  71.     /**
  72.      * Returns <code>true</code> since this object supports seeking
  73.      * backwards.
  74.      */
  75.     public boolean canSeekBackwards() {
  76.         return true;
  77.     }
  78.     /**
  79.      * Returns the current offset in this stream. 
  80.      *
  81.      * @return     the offset from the beginning of the stream, in bytes,
  82.      *             at which the next read occurs.
  83.      */
  84.     public long getFilePointer() {
  85.         return (long)pointer;
  86.     }
  87.     /**
  88.      * Sets the offset, measured from the beginning of this 
  89.      * stream, at which the next read occurs.  Seeking backwards is
  90.      * allowed.
  91.      *
  92.      * @param      pos   the offset position, measured in bytes from the 
  93.      *                   beginning of the stream, at which to set the stream 
  94.      *                   pointer.
  95.      */
  96.     public void seek(long pos) {
  97.         pointer = (int)pos;
  98.     }
  99.     /**
  100.      * Reads the next byte of data from the input array. The value byte is
  101.      * returned as an <code>int</code> in the range <code>0</code> to
  102.      * <code>255</code>. If no byte is available because the end of the stream
  103.      * has been reached, the value <code>-1</code> is returned.
  104.      */
  105.     public int read() {
  106.         if (pointer < length + offset) {
  107.             return (int)(src[pointer++ + offset] & 0xff);
  108.         } else {
  109.             return -1;
  110.         }
  111.     }
  112.     /**
  113.      * Copies up to <code>len</code> bytes of data from the input array into
  114.      * an array of bytes.  An attempt is made to copy as many as
  115.      * <code>len</code> bytes, but a smaller number may be copied, possibly
  116.      * zero. The number of bytes actually copied is returned as an integer.
  117.      *
  118.      * <p> If <code>b</code> is <code>null</code>, a
  119.      * <code>NullPointerException</code> is thrown.
  120.      *
  121.      * <p> If <code>off</code> is negative, or <code>len</code> is negative, or
  122.      * <code>off+len</code> is greater than the length of the array
  123.      * <code>b</code>, then an <code>IndexOutOfBoundsException</code> is
  124.      * thrown.
  125.      *
  126.      * <p> If <code>len</code> is zero, then no bytes are copied and
  127.      * <code>0</code> is returned; otherwise, there is an attempt to copy at
  128.      * least one byte. If no byte is available because the stream is at end of
  129.      * stream, the value <code>-1</code> is returned; otherwise, at least one
  130.      * byte is copied into <code>b</code>.
  131.      *
  132.      * <p> The first byte copied is stored into element
  133.      * <code>b[off]</code>, the next one into <code>b[off+1]</code>,
  134.      * and so on. The number of bytes copied is, at most, equal to
  135.      * <code>len</code>. Let <i>k</i> be the number of bytes actually
  136.      * copied; these bytes will be stored in elements
  137.      * <code>b[off]</code> through
  138.      * <code>b[off+</code><i>k</i><code>-1]</code>, leaving elements
  139.      * <code>b[off+</code><i>k</i><code>]</code> through
  140.      * <code>b[off+len-1]</code> unaffected.
  141.      *
  142.      * <p> In every case, elements <code>b[0]</code> through
  143.      * <code>b[off]</code> and elements <code>b[off+len]</code> through
  144.      * <code>b[b.length-1]</code> are unaffected.
  145.      *
  146.      * @param      b     the buffer into which the data is copied.
  147.      * @param      off   the start offset in array <code>b</code>
  148.      *                   at which the data is written.
  149.      * @param      len   the maximum number of bytes to copy.
  150.      * @return     the total number of bytes read into the buffer, or
  151.      *             <code>-1</code> if there is no more data because the end of
  152.      *             the stream has been reached.
  153.      */
  154.     public int read(byte[] b, int off, int len) {
  155.         if (b == null) {
  156.             throw new NullPointerException();
  157.         }
  158.         if ((off < 0) || (len < 0) || (off + len > b.length)) {
  159.             throw new IndexOutOfBoundsException();
  160.         }
  161.         if (len == 0) {
  162.             return 0;
  163.         }
  164.         int oldPointer = pointer;
  165.         pointer = Math.min(pointer + len, length + offset);
  166.         if (pointer == oldPointer) {
  167.             return -1;
  168.         } else {
  169.             System.arraycopy(src, oldPointer, b, off, pointer - oldPointer);
  170.             return pointer - oldPointer;
  171.         }
  172.     }
  173.     /**
  174.      * Attempts to skip over <code>n</code> bytes of input discarding the 
  175.      * skipped bytes. 
  176.      * <p>
  177.      * 
  178.      * This method may skip over some smaller number of bytes, possibly zero. 
  179.      * This may result from any of a number of conditions; reaching end of 
  180.      * stream before <code>n</code> bytes have been skipped is only one 
  181.      * possibility. This method never throws an <code>EOFException</code>. 
  182.      * The actual number of bytes skipped is returned.  If <code>n</code> 
  183.      * is negative, no bytes are skipped.
  184.      *
  185.      * @param      n   the number of bytes to be skipped.
  186.      * @return     the actual number of bytes skipped.
  187.      */
  188.     public int skipBytes(int n) {
  189.         int oldPointer = pointer;
  190.         pointer = Math.min(pointer + n, length + offset);
  191.         return pointer - oldPointer;
  192.     }
  193.     /** Does nothing. */
  194.     public void close() {
  195.     }
  196.     /** Returns the number of valid bytes in the input array. */
  197.     public long length() {
  198.         return length;
  199.     }
  200. }