View Javadoc
1   /*
2    * Copyright (c) 1995, 2004, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   * version 2 for more details (a copy is included in the LICENSE file that
15   * accompanied this code).
16   *
17   * You should have received a copy of the GNU General Public License version
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * questions.
24   */
25  
26  package java.io;
27  
28  /**
29   * This class allows an application to create an input stream in
30   * which the bytes read are supplied by the contents of a string.
31   * Applications can also read bytes from a byte array by using a
32   * <code>ByteArrayInputStream</code>.
33   * <p>
34   * Only the low eight bits of each character in the string are used by
35   * this class.
36   *
37   * @author     Arthur van Hoff
38   * @see        java.io.ByteArrayInputStream
39   * @see        java.io.StringReader
40   * @since      JDK1.0
41   * @deprecated This class does not properly convert characters into bytes.  As
42   *             of JDK&nbsp;1.1, the preferred way to create a stream from a
43   *             string is via the <code>StringReader</code> class.
44   */
45  @Deprecated
46  public
47  class StringBufferInputStream extends InputStream {
48      /**
49       * The string from which bytes are read.
50       */
51      protected String buffer;
52  
53      /**
54       * The index of the next character to read from the input stream buffer.
55       *
56       * @see        java.io.StringBufferInputStream#buffer
57       */
58      protected int pos;
59  
60      /**
61       * The number of valid characters in the input stream buffer.
62       *
63       * @see        java.io.StringBufferInputStream#buffer
64       */
65      protected int count;
66  
67      /**
68       * Creates a string input stream to read data from the specified string.
69       *
70       * @param      s   the underlying input buffer.
71       */
72      public StringBufferInputStream(String s) {
73          this.buffer = s;
74          count = s.length();
75      }
76  
77      /**
78       * Reads the next byte of data from this input stream. The value
79       * byte is returned as an <code>int</code> in the range
80       * <code>0</code> to <code>255</code>. If no byte is available
81       * because the end of the stream has been reached, the value
82       * <code>-1</code> is returned.
83       * <p>
84       * The <code>read</code> method of
85       * <code>StringBufferInputStream</code> cannot block. It returns the
86       * low eight bits of the next character in this input stream's buffer.
87       *
88       * @return     the next byte of data, or <code>-1</code> if the end of the
89       *             stream is reached.
90       */
91      public synchronized int read() {
92          return (pos < count) ? (buffer.charAt(pos++) & 0xFF) : -1;
93      }
94  
95      /**
96       * Reads up to <code>len</code> bytes of data from this input stream
97       * into an array of bytes.
98       * <p>
99       * The <code>read</code> method of
100      * <code>StringBufferInputStream</code> cannot block. It copies the
101      * low eight bits from the characters in this input stream's buffer into
102      * the byte array argument.
103      *
104      * @param      b     the buffer into which the data is read.
105      * @param      off   the start offset of the data.
106      * @param      len   the maximum number of bytes read.
107      * @return     the total number of bytes read into the buffer, or
108      *             <code>-1</code> if there is no more data because the end of
109      *             the stream has been reached.
110      */
111     public synchronized int read(byte b[], int off, int len) {
112         if (b == null) {
113             throw new NullPointerException();
114         } else if ((off < 0) || (off > b.length) || (len < 0) ||
115                    ((off + len) > b.length) || ((off + len) < 0)) {
116             throw new IndexOutOfBoundsException();
117         }
118         if (pos >= count) {
119             return -1;
120         }
121         if (pos + len > count) {
122             len = count - pos;
123         }
124         if (len <= 0) {
125             return 0;
126         }
127         String  s = buffer;
128         int cnt = len;
129         while (--cnt >= 0) {
130             b[off++] = (byte)s.charAt(pos++);
131         }
132 
133         return len;
134     }
135 
136     /**
137      * Skips <code>n</code> bytes of input from this input stream. Fewer
138      * bytes might be skipped if the end of the input stream is reached.
139      *
140      * @param      n   the number of bytes to be skipped.
141      * @return     the actual number of bytes skipped.
142      */
143     public synchronized long skip(long n) {
144         if (n < 0) {
145             return 0;
146         }
147         if (n > count - pos) {
148             n = count - pos;
149         }
150         pos += n;
151         return n;
152     }
153 
154     /**
155      * Returns the number of bytes that can be read from the input
156      * stream without blocking.
157      *
158      * @return     the value of <code>count&nbsp;-&nbsp;pos</code>, which is the
159      *             number of bytes remaining to be read from the input buffer.
160      */
161     public synchronized int available() {
162         return count - pos;
163     }
164 
165     /**
166      * Resets the input stream to begin reading from the first character
167      * of this input stream's underlying buffer.
168      */
169     public synchronized void reset() {
170         pos = 0;
171     }
172 }