← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/jflex/gutsy

« back to all changes in this revision

Viewing changes to examples/binary/StraightStreamReader.java

  • Committer: Bazaar Package Importer
  • Author(s): Takashi Okamoto
  • Date: 2002-02-16 13:38:21 UTC
  • Revision ID: james.westby@ubuntu.com-20020216133821-5wsdprpt9xl7ondr
Tags: upstream-1.3.5
Import upstream version 1.3.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/binary/StraightStreamReader.java
 
1
/*
 
2
 * An InputStreamReader that does no character encoding translations.
 
3
 * Copyright (C) 2001 Stephen Ostermiller <utils@Ostermiller.com>
 
4
 *
 
5
 * Changes: (2001 by Gerwin Klein <lsf@jflex.de>)
 
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
}