1 | /*
|
---|
2 | * An InputStreamReader that does no character encoding translations.
|
---|
3 | * Copyright (C) 2001 Stephen Ostermiller <[email protected]>
|
---|
4 | *
|
---|
5 | * Changes: (2001 by Gerwin Klein <[email protected]>)
|
---|
6 | * - commented out package declaration for the example
|
---|
7 | * - original version at http://www.smo.f2s.com/utils/
|
---|
8 | *
|
---|
9 | * This program is free software; you can redistribute it and/or modify
|
---|
10 | * it under the terms of the GNU General Public License as published by
|
---|
11 | * the Free Software Foundation; either version 2 of the License, or
|
---|
12 | * (at your option) any later version.
|
---|
13 | *
|
---|
14 | * This program is distributed in the hope that it will be useful,
|
---|
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
17 | * GNU General Public License for more details.
|
---|
18 | *
|
---|
19 | * See COPYING.TXT for details.
|
---|
20 | */
|
---|
21 |
|
---|
22 | // package com.Ostermiller.util;
|
---|
23 |
|
---|
24 | import java.io.*;
|
---|
25 |
|
---|
26 | /**
|
---|
27 | * A StraightStreamReader is a bridge from byte streams to character streams: It reads bytes
|
---|
28 | * and translates them into characters without using a character encoding. The characters
|
---|
29 | * that a StraightStreamReader returns may not be valid unicode characters but they are
|
---|
30 | * guaranteed to be in the 0x00 to 0xFF range.
|
---|
31 | * <P>
|
---|
32 | * Most of the time you want to do character encoding translation when translating bytes to
|
---|
33 | * characters. If you are planning on displaying the text, you should always do this and should
|
---|
34 | * use an InputStreamReader for the purpose. Sometimes it is useful to treat characters as bytes
|
---|
35 | * with some extra bits. In these cases you would want to use a StraightStreamReader.
|
---|
36 | * <P>
|
---|
37 | * For top efficiency, consider wrapping an StraightStreamReader within a BufferedReader. For example:<br>
|
---|
38 | * <code>BufferedReader in = new BufferedReader(new StraightStreamReader(System.in));</code>
|
---|
39 | */
|
---|
40 | public class StraightStreamReader extends Reader{
|
---|
41 |
|
---|
42 | /**
|
---|
43 | * The input stream from which all methods in this class read.
|
---|
44 | */
|
---|
45 | private InputStream in;
|
---|
46 |
|
---|
47 | /**
|
---|
48 | * A byte array to be used for calls to the InputStream. This
|
---|
49 | * is cached as a class variable to avoid object creation and
|
---|
50 | * deletion each time a read is called. This buffer may be
|
---|
51 | * null and may not be large enough. Make sure to check it
|
---|
52 | * before using it.
|
---|
53 | */
|
---|
54 | private byte[] buffer;
|
---|
55 |
|
---|
56 | /**
|
---|
57 | * Create a StraightStreamReader from an InputStream
|
---|
58 | *
|
---|
59 | * @param in InputStream to wrap a Reader around.
|
---|
60 | */
|
---|
61 | public StraightStreamReader(InputStream in) {
|
---|
62 | this.in = in;
|
---|
63 | }
|
---|
64 |
|
---|
65 | /**
|
---|
66 | * Close the stream.
|
---|
67 | *
|
---|
68 | * @throws IOException If an I/O error occurs
|
---|
69 | */
|
---|
70 | public void close() throws IOException {
|
---|
71 | in.close();
|
---|
72 | }
|
---|
73 |
|
---|
74 | /**
|
---|
75 | * Mark the present position in the stream. Subsequent calls to reset()
|
---|
76 | * will attempt to reposition the stream to this point. Not all
|
---|
77 | * character-input streams support the mark() operation.
|
---|
78 | *
|
---|
79 | * @param readAheadLimit Limit on the number of characters that may be read
|
---|
80 | * while still preserving the mark. After reading this many characters,
|
---|
81 | * attempting to reset the stream may fail.
|
---|
82 | * @throws IOException If the stream does not support mark(), or if some other I/O error occurs
|
---|
83 | */
|
---|
84 | public void mark(int readAheadLimit) throws IOException {
|
---|
85 | in.mark(readAheadLimit);
|
---|
86 | }
|
---|
87 |
|
---|
88 | /**
|
---|
89 | * Tell whether this stream supports the mark() operation.
|
---|
90 | *
|
---|
91 | * @return true if and only if this stream supports the mark operation.
|
---|
92 | */
|
---|
93 | public boolean markSupported(){
|
---|
94 | return in.markSupported();
|
---|
95 | }
|
---|
96 |
|
---|
97 | /**
|
---|
98 | * Read a single character. This method will block until a character is available, an
|
---|
99 | * I/O error occurs, or the end of the stream is reached.
|
---|
100 | *
|
---|
101 | * @return The character read, as an integer in the range 0 to 256 (0x00-0xff), or -1 if
|
---|
102 | * the end of the stream has been reached
|
---|
103 | * @throws IOException If an I/O error occurs
|
---|
104 | */
|
---|
105 | public int read() throws IOException {
|
---|
106 | return in.read();
|
---|
107 | }
|
---|
108 |
|
---|
109 | /**
|
---|
110 | * Read characters into an array. This method will block until some input is available,
|
---|
111 | * an I/O error occurs, or the end of the stream is reached.
|
---|
112 | *
|
---|
113 | * @param cbuf Destination buffer
|
---|
114 | * @return The number of bytes read, or -1 if the end of the stream has been reached
|
---|
115 | * @throws IOException If an I/O error occurs
|
---|
116 | */
|
---|
117 | public int read(char[] cbuf) throws IOException {
|
---|
118 | return read(cbuf, 0, cbuf.length);
|
---|
119 | }
|
---|
120 |
|
---|
121 | /**
|
---|
122 | * Read characters into an array. This method will block until some input is available,
|
---|
123 | * an I/O error occurs, or the end of the stream is reached.
|
---|
124 | *
|
---|
125 | * @param cbuf Destination buffer
|
---|
126 | * @param off Offset at which to start storing characters
|
---|
127 | * @param len Maximum number of characters to read
|
---|
128 | * @return The number of bytes read, or -1 if the end of the stream has been reached
|
---|
129 | * @throws IOException If an I/O error occurs
|
---|
130 | */
|
---|
131 | public int read(char[] cbuf, int off, int len) throws IOException {
|
---|
132 | // ensure the capacity of the buffer that we will be using
|
---|
133 | // to read from the input stream
|
---|
134 | if (buffer == null || buffer.length < len){
|
---|
135 | buffer = new byte[len];
|
---|
136 | }
|
---|
137 | // read from the input stream and copy it to the character array
|
---|
138 | int length = in.read(buffer, 0, len);
|
---|
139 | for (int i=0; i<length; i++){
|
---|
140 | cbuf[off+i] = (char)(0xFF & buffer[i]);
|
---|
141 | }
|
---|
142 | return length;
|
---|
143 | }
|
---|
144 |
|
---|
145 | /**
|
---|
146 | * Tell whether this stream is ready to be read.
|
---|
147 | *
|
---|
148 | * @return True if the next read() is guaranteed not to block for input, false otherwise.
|
---|
149 | * Note that returning false does not guarantee that the next read will block.
|
---|
150 | * @throws IOException If an I/O error occurs
|
---|
151 | */
|
---|
152 | public boolean ready() throws IOException {
|
---|
153 | return (in.available() > 0);
|
---|
154 | }
|
---|
155 |
|
---|
156 | /**
|
---|
157 | * Reset the stream. If the stream has been marked, then attempt to reposition it at the mark.
|
---|
158 | * If the stream has not been marked, then attempt to reset it in some way appropriate to the
|
---|
159 | * particular stream, for example by repositioning it to its starting point. Not all
|
---|
160 | * character-input streams support the reset() operation, and some support reset()
|
---|
161 | * without supporting mark().
|
---|
162 | *
|
---|
163 | * @throws IOException If the stream has not been marked, or if the mark has been invalidated,
|
---|
164 | * or if the stream does not support reset(), or if some other I/O error occurs
|
---|
165 | */
|
---|
166 | public void reset() throws IOException {
|
---|
167 | in.reset();
|
---|
168 | }
|
---|
169 |
|
---|
170 | /**
|
---|
171 | * Skip characters. This method will block until some characters are available,
|
---|
172 | * an I/O error occurs, or the end of the stream is reached.
|
---|
173 | *
|
---|
174 | * @param n The number of characters to skip
|
---|
175 | * @return The number of characters actually skipped
|
---|
176 | * @throws IllegalArgumentException If n is negative
|
---|
177 | * @throws IOException If an I/O error occurs
|
---|
178 | */
|
---|
179 | public long skip(long n) throws IOException {
|
---|
180 | return in.skip(n);
|
---|
181 | }
|
---|
182 |
|
---|
183 | /**
|
---|
184 | * Regression test for this class. If this class is working, this should
|
---|
185 | * run and print no errors.
|
---|
186 | * <P>
|
---|
187 | * This method creates a tempory file in the working directory called "test.txt".
|
---|
188 | * This file should not exist before hand, and the program should have create,
|
---|
189 | * read, write, and delete access to this file.
|
---|
190 | *
|
---|
191 | * @param args command line arguments (ignored)
|
---|
192 | */
|
---|
193 | private static void main(String[] args){
|
---|
194 | try {
|
---|
195 | File f = new File("test.txt");
|
---|
196 | if (f.exists()){
|
---|
197 | throw new IOException(f + " already exists. I don't want to overwrite it.");
|
---|
198 | }
|
---|
199 | StraightStreamReader in;
|
---|
200 | char[] cbuf = new char[0x1000];
|
---|
201 | int read;
|
---|
202 | int totRead;
|
---|
203 |
|
---|
204 | // write a file with all possible values of bytes
|
---|
205 | FileOutputStream out = new FileOutputStream(f);
|
---|
206 | for (int i=0x00; i<0x100; i++){
|
---|
207 | out.write(i);
|
---|
208 | }
|
---|
209 | out.close();
|
---|
210 |
|
---|
211 | // read it back using the read single character method
|
---|
212 | in = new StraightStreamReader(new FileInputStream(f));
|
---|
213 | for (int i=0x00; i<0x100; i++){
|
---|
214 | read = in.read();
|
---|
215 | if (read != i){
|
---|
216 | System.err.println("Error: " + i + " read as " + read);
|
---|
217 | }
|
---|
218 | }
|
---|
219 | in.close();
|
---|
220 |
|
---|
221 | // read as much of it back as possible with one simple buffer read.
|
---|
222 | in = new StraightStreamReader(new FileInputStream(f));
|
---|
223 | totRead = in.read(cbuf);
|
---|
224 | if (totRead != 0x100){
|
---|
225 | System.err.println("Simple buffered read did not read the full amount: 0x" + Integer.toHexString(totRead));
|
---|
226 | }
|
---|
227 | for (int i=0x00; i<totRead; i++){
|
---|
228 | if (cbuf[i] != i){
|
---|
229 | System.err.println("Error: 0x" + i + " read as 0x" + cbuf[i]);
|
---|
230 | }
|
---|
231 | }
|
---|
232 | in.close();
|
---|
233 |
|
---|
234 | // read it back using buffer read method.
|
---|
235 | in = new StraightStreamReader(new FileInputStream(f));
|
---|
236 | totRead = 0;
|
---|
237 | while (totRead <= 0x100 && (read = in.read(cbuf, totRead, 0x100 - totRead)) > 0){
|
---|
238 | totRead += read;
|
---|
239 | }
|
---|
240 | if (totRead != 0x100){
|
---|
241 | System.err.println("Not enough read. Bytes read: " + Integer.toHexString(totRead));
|
---|
242 | }
|
---|
243 | for (int i=0x00; i<totRead; i++){
|
---|
244 | if (cbuf[i] != i){
|
---|
245 | System.err.println("Error: 0x" + i + " read as 0x" + cbuf[i]);
|
---|
246 | }
|
---|
247 | }
|
---|
248 | in.close();
|
---|
249 |
|
---|
250 | // read it back using an offset buffer read method.
|
---|
251 | in = new StraightStreamReader(new FileInputStream(f));
|
---|
252 | totRead = 0;
|
---|
253 | while (totRead <= 0x100 && (read = in.read(cbuf, totRead+0x123, 0x100 - totRead)) > 0){
|
---|
254 | totRead += read;
|
---|
255 | }
|
---|
256 | if (totRead != 0x100){
|
---|
257 | System.err.println("Not enough read. Bytes read: " + Integer.toHexString(totRead));
|
---|
258 | }
|
---|
259 | for (int i=0x00; i<totRead; i++){
|
---|
260 | if (cbuf[i+0x123] != i){
|
---|
261 | System.err.println("Error: 0x" + i + " read as 0x" + cbuf[i+0x123]);
|
---|
262 | }
|
---|
263 | }
|
---|
264 | in.close();
|
---|
265 |
|
---|
266 | // read it back using a partial offset buffer read method.
|
---|
267 | in = new StraightStreamReader(new FileInputStream(f));
|
---|
268 | totRead = 0;
|
---|
269 | while (totRead <= 0x100 && (read = in.read(cbuf, totRead+0x123, 7)) > 0){
|
---|
270 | totRead += read;
|
---|
271 | }
|
---|
272 | if (totRead != 0x100){
|
---|
273 | System.err.println("Not enough read. Bytes read: " + Integer.toHexString(totRead));
|
---|
274 | }
|
---|
275 | for (int i=0x00; i<totRead; i++){
|
---|
276 | if (cbuf[i+0x123] != i){
|
---|
277 | System.err.println("Error: 0x" + i + " read as 0x" + cbuf[i+0x123]);
|
---|
278 | }
|
---|
279 | }
|
---|
280 | in.close();
|
---|
281 |
|
---|
282 | f.delete();
|
---|
283 | } catch (IOException x){
|
---|
284 | System.err.println(x.getMessage());
|
---|
285 | }
|
---|
286 | }
|
---|
287 | }
|
---|