Source code

001/*
002 *  Licensed to the Apache Software Foundation (ASF) under one or more
003 *  contributor license agreements.  See the NOTICE file distributed with
004 *  this work for additional information regarding copyright ownership.
005 *  The ASF licenses this file to You under the Apache License, Version 2.0
006 *  (the "License"); you may not use this file except in compliance with
007 *  the License.  You may obtain a copy of the License at
008 *
009 *     http://www.apache.org/licenses/LICENSE-2.0
010 *
011 *  Unless required by applicable law or agreed to in writing, software
012 *  distributed under the License is distributed on an "AS IS" BASIS,
013 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 *  See the License for the specific language governing permissions and
015 *  limitations under the License.
016 */
017
018package org.apache.commons.io.input;
019
020import static org.apache.commons.io.IOUtils.CR;
021import static org.apache.commons.io.IOUtils.EOF;
022import static org.apache.commons.io.IOUtils.LF;
023
024import java.io.BufferedReader;
025import java.io.BufferedWriter;
026import java.io.IOException;
027import java.io.Reader;
028
029import org.apache.commons.io.IOUtils;
030
031/**
032 * Wraps an existing {@link Reader} and buffers the input <em>without any synchronization</em>. Expensive interaction with the underlying reader is minimized,
033 * since most (smaller) requests can be satisfied by accessing the buffer alone. The drawback is that some extra space is required to hold the buffer and that
034 * copying takes place when filling that buffer, but this is usually outweighed by the performance benefits.
035 * <p>
036 * A typical application pattern for the class looks like this:
037 * </p>
038 *
039 * <pre>{@code
040 * UnsynchronizedBufferedReader buf = new UnsynchronizedBufferedReader(new FileReader("file"));
041 * }</pre>
042 * <p>
043 * Provenance: Apache Harmony's java.io.BufferedReader, renamed, and modified.
044 * </p>
045 *
046 * @see BufferedReader
047 * @see BufferedWriter
048 * @since 2.17.0
049 */
050public class UnsynchronizedBufferedReader extends UnsynchronizedReader {
051
052    private static final char NUL = '\0';
053
054    private final Reader in;
055
056    /**
057     * The characters that can be read and refilled in bulk. We maintain three indices into this buffer:
058     *
059     * <pre>
060     *     { X X X X X X X X X X X X - - }
061     *           ^     ^             ^
062     *           |     |             |
063     *         mark   pos           end
064     * </pre>
065     * <p>
066     * Pos points to the next readable character. End is one greater than the last readable character. When {@code pos == end}, the buffer is empty and must be
067     * {@link #fillBuf() filled} before characters can be read.
068     * </p>
069     * <p>
070     * Mark is the value pos will be set to on calls to {@link #reset()}. Its value is in the range {@code [0...pos]}. If the mark is {@code -1}, the buffer
071     * cannot be reset.
072     * </p>
073     * <p>
074     * MarkLimit limits the distance between the mark and the pos. When this limit is exceeded, {@link #reset()} is permitted (but not required) to throw an
075     * exception. For shorter distances, {@link #reset()} shall not throw (unless the reader is closed).
076     * </p>
077     */
078    private char[] buf;
079
080    private int pos;
081
082    private int end;
083
084    private int mark = -1;
085
086    private int markLimit = -1;
087
088    /**
089     * Constructs a new BufferedReader on the Reader {@code in}. The buffer gets the default size (8 KB).
090     *
091     * @param in the Reader that is buffered.
092     */
093    public UnsynchronizedBufferedReader(final Reader in) {
094        this(in, IOUtils.DEFAULT_BUFFER_SIZE);
095    }
096
097    /**
098     * Constructs a new BufferedReader on the Reader {@code in}. The buffer size is specified by the parameter {@code size}.
099     *
100     * @param in   the Reader that is buffered.
101     * @param size the size of the buffer to allocate.
102     * @throws IllegalArgumentException if {@code size <= 0}.
103     */
104    public UnsynchronizedBufferedReader(final Reader in, final int size) {
105        if (size <= 0) {
106            throw new IllegalArgumentException("size <= 0");
107        }
108        this.in = in;
109        buf = new char[size];
110    }
111
112    /**
113     * Peeks at the next input character, refilling the buffer if necessary. If this character is a newline character ("\n"), it is discarded.
114     */
115    final void chompNewline() throws IOException {
116        if ((pos != end || fillBuf() != EOF) && buf[pos] == LF) {
117            pos++;
118        }
119    }
120
121    /**
122     * Closes this reader. This implementation closes the buffered source reader and releases the buffer. Nothing is done if this reader has already been
123     * closed.
124     *
125     * @throws IOException if an error occurs while closing this reader.
126     */
127    @Override
128    public void close() throws IOException {
129        if (!isClosed()) {
130            in.close();
131            buf = null;
132            super.close();
133        }
134    }
135
136    /**
137     * Populates the buffer with data. It is an error to call this method when the buffer still contains data; ie. if {@code pos < end}.
138     *
139     * @return the number of bytes read into the buffer, or -1 if the end of the source stream has been reached.
140     */
141    private int fillBuf() throws IOException {
142        // assert(pos == end);
143
144        if (mark == EOF || pos - mark >= markLimit) {
145            /* mark isn't set or has exceeded its limit. use the whole buffer */
146            final int result = in.read(buf, 0, buf.length);
147            if (result > 0) {
148                mark = -1;
149                pos = 0;
150                end = result;
151            }
152            return result;
153        }
154
155        if (mark == 0 && markLimit > buf.length) {
156            /* the only way to make room when mark=0 is by growing the buffer */
157            int newLength = buf.length * 2;
158            if (newLength > markLimit) {
159                newLength = markLimit;
160            }
161            final char[] newbuf = new char[newLength];
162            System.arraycopy(buf, 0, newbuf, 0, buf.length);
163            buf = newbuf;
164        } else if (mark > 0) {
165            /* make room by shifting the buffered data to left mark positions */
166            System.arraycopy(buf, mark, buf, 0, buf.length - mark);
167            pos -= mark;
168            end -= mark;
169            mark = 0;
170        }
171
172        /* Set the new position and mark position */
173        final int count = in.read(buf, pos, buf.length - pos);
174        if (count != EOF) {
175            end += count;
176        }
177        return count;
178    }
179
180    /**
181     * Sets a mark position in this reader. The parameter {@code markLimit} indicates how many characters can be read before the mark is invalidated. Calling
182     * {@link #reset()} will reposition the reader back to the marked position if {@code markLimit} has not been surpassed.
183     *
184     * @param markLimit the number of characters that can be read before the mark is invalidated.
185     * @throws IllegalArgumentException if {@code markLimit < 0}.
186     * @throws IOException              if an error occurs while setting a mark in this reader.
187     * @see #markSupported()
188     * @see #reset()
189     */
190    @Override
191    public void mark(final int markLimit) throws IOException {
192        if (markLimit < 0) {
193            throw new IllegalArgumentException();
194        }
195        checkOpen();
196        this.markLimit = markLimit;
197        mark = pos;
198    }
199
200    /**
201     * Tests whether this reader supports the {@link #mark(int)} and {@link #reset()} methods. This implementation returns {@code true}.
202     *
203     * @return {@code true} for {@code BufferedReader}.
204     * @see #mark(int)
205     * @see #reset()
206     */
207    @Override
208    public boolean markSupported() {
209        return true;
210    }
211
212    /**
213     * Returns the next character in the current reader without consuming it. So the next call to {@link #read()} will still return this value.
214     *
215     * @return the next character
216     * @throws IOException If an I/O error occurs
217     */
218    public int peek() throws IOException {
219        mark(1);
220        final int c = read();
221        reset();
222        return c;
223    }
224
225    /**
226     * Populates the buffer with the next {@code buf.length} characters in the current reader without consuming them. The next call to {@link #read()} will
227     * still return the next value.
228     *
229     * @param buf the buffer to fill for the look ahead.
230     * @return the buffer itself
231     * @throws IOException If an I/O error occurs
232     */
233    public int peek(final char[] buf) throws IOException {
234        final int n = buf.length;
235        mark(n);
236        final int c = read(buf, 0, n);
237        reset();
238        return c;
239    }
240
241    /**
242     * Reads a single character from this reader and returns it with the two higher-order bytes set to 0. If possible, BufferedReader returns a character from
243     * the buffer. If there are no characters available in the buffer, it fills the buffer and then returns a character. It returns -1 if there are no more
244     * characters in the source reader.
245     *
246     * @return the character read or -1 if the end of the source reader has been reached.
247     * @throws IOException if this reader is closed or some other I/O error occurs.
248     */
249    @Override
250    public int read() throws IOException {
251        checkOpen();
252        /* Are there buffered characters available? */
253        if (pos < end || fillBuf() != EOF) {
254            return buf[pos++];
255        }
256        return EOF;
257    }
258
259    /**
260     * Reads at most {@code length} characters from this reader and stores them at {@code offset} in the character array {@code buffer}. Returns the number of
261     * characters actually read or -1 if the end of the source reader has been reached. If all the buffered characters have been used, a mark has not been set
262     * and the requested number of characters is larger than this readers buffer size, BufferedReader bypasses the buffer and simply places the results directly
263     * into {@code buffer}.
264     *
265     * @param buffer the character array to store the characters read.
266     * @param offset the initial position in {@code buffer} to store the bytes read from this reader.
267     * @param length the maximum number of characters to read, must be non-negative.
268     * @return number of characters read or -1 if the end of the source reader has been reached.
269     * @throws IndexOutOfBoundsException if {@code offset < 0} or {@code length < 0}, or if {@code offset + length} is greater than the size of {@code buffer}.
270     * @throws IOException               if this reader is closed or some other I/O error occurs.
271     */
272    @Override
273    public int read(final char[] buffer, int offset, final int length) throws IOException {
274        checkOpen();
275        if (offset < 0 || offset > buffer.length - length || length < 0) {
276            throw new IndexOutOfBoundsException();
277        }
278        int outstanding = length;
279        while (outstanding > 0) {
280
281            /*
282             * If there are bytes in the buffer, grab those first.
283             */
284            final int available = end - pos;
285            if (available > 0) {
286                final int count = available >= outstanding ? outstanding : available;
287                System.arraycopy(buf, pos, buffer, offset, count);
288                pos += count;
289                offset += count;
290                outstanding -= count;
291            }
292
293            /*
294             * Before attempting to read from the underlying stream, make sure we really, really want to. We won't bother if we're done, or if we've already got
295             * some bytes and reading from the underlying stream would block.
296             */
297            if (outstanding == 0 || outstanding < length && !in.ready()) {
298                break;
299            }
300
301            // assert(pos == end);
302
303            /*
304             * If we're unmarked and the requested size is greater than our buffer, read the bytes directly into the caller's buffer. We don't read into smaller
305             * buffers because that could result in a many reads.
306             */
307            if ((mark == -1 || pos - mark >= markLimit) && outstanding >= buf.length) {
308                final int count = in.read(buffer, offset, outstanding);
309                if (count > 0) {
310                    outstanding -= count;
311                    mark = -1;
312                }
313
314                break; // assume the source stream gave us all that it could
315            }
316
317            if (fillBuf() == EOF) {
318                break; // source is exhausted
319            }
320        }
321
322        final int count = length - outstanding;
323        return count > 0 || count == length ? count : EOF;
324    }
325
326    /**
327     * Returns the next line of text available from this reader. A line is represented by zero or more characters followed by {@code LF}, {@code CR},
328     * {@code "\r\n"} or the end of the reader. The string does not include the newline sequence.
329     *
330     * @return the contents of the line or {@code null} if no characters were read before the end of the reader has been reached.
331     * @throws IOException if this reader is closed or some other I/O error occurs.
332     */
333    public String readLine() throws IOException {
334        checkOpen();
335        /* has the underlying stream been exhausted? */
336        if (pos == end && fillBuf() == EOF) {
337            return null;
338        }
339        for (int charPos = pos; charPos < end; charPos++) {
340            final char ch = buf[charPos];
341            if (ch > CR) {
342                continue;
343            }
344            if (ch == LF) {
345                final String res = new String(buf, pos, charPos - pos);
346                pos = charPos + 1;
347                return res;
348            }
349            if (ch == CR) {
350                final String res = new String(buf, pos, charPos - pos);
351                pos = charPos + 1;
352                if ((pos < end || fillBuf() != EOF) && buf[pos] == LF) {
353                    pos++;
354                }
355                return res;
356            }
357        }
358
359        char eol = NUL;
360        final StringBuilder result = new StringBuilder(80);
361        /* Typical Line Length */
362
363        result.append(buf, pos, end - pos);
364        while (true) {
365            pos = end;
366
367            /* Are there buffered characters available? */
368            if (eol == LF) {
369                return result.toString();
370            }
371            // attempt to fill buffer
372            if (fillBuf() == EOF) {
373                // characters or null.
374                return result.length() > 0 || eol != NUL ? result.toString() : null;
375            }
376            for (int charPos = pos; charPos < end; charPos++) {
377                final char c = buf[charPos];
378                if (eol != NUL) {
379                    if (eol == CR && c == LF) {
380                        if (charPos > pos) {
381                            result.append(buf, pos, charPos - pos - 1);
382                        }
383                        pos = charPos + 1;
384                    } else {
385                        if (charPos > pos) {
386                            result.append(buf, pos, charPos - pos - 1);
387                        }
388                        pos = charPos;
389                    }
390                    return result.toString();
391                }
392                if (c == LF || c == CR) {
393                    eol = c;
394                }
395            }
396            if (eol == NUL) {
397                result.append(buf, pos, end - pos);
398            } else {
399                result.append(buf, pos, end - pos - 1);
400            }
401        }
402    }
403
404    /**
405     * Tests whether this reader is ready to be read without blocking.
406     *
407     * @return {@code true} if this reader will not block when {@code read} is called, {@code false} if unknown or blocking will occur.
408     * @throws IOException if this reader is closed or some other I/O error occurs.
409     * @see #read()
410     * @see #read(char[], int, int)
411     * @see #readLine()
412     */
413    @Override
414    public boolean ready() throws IOException {
415        checkOpen();
416        return end - pos > 0 || in.ready();
417    }
418
419    /**
420     * Resets this reader's position to the last {@code mark()} location. Invocations of {@code read()} and {@code skip()} will occur from this new location.
421     *
422     * @throws IOException if this reader is closed or no mark has been set.
423     * @see #mark(int)
424     * @see #markSupported()
425     */
426    @Override
427    public void reset() throws IOException {
428        checkOpen();
429        if (mark == -1) {
430            throw new IOException("mark == -1");
431        }
432        pos = mark;
433    }
434
435    /**
436     * Skips {@code amount} characters in this reader. Subsequent {@code read()}s will not return these characters unless {@code reset()} is used. Skipping
437     * characters may invalidate a mark if {@code markLimit} is surpassed.
438     *
439     * @param amount the maximum number of characters to skip.
440     * @return the number of characters actually skipped.
441     * @throws IllegalArgumentException if {@code amount < 0}.
442     * @throws IOException              if this reader is closed or some other I/O error occurs.
443     * @see #mark(int)
444     * @see #markSupported()
445     * @see #reset()
446     */
447    @Override
448    public long skip(final long amount) throws IOException {
449        if (amount < 0) {
450            throw new IllegalArgumentException();
451        }
452        checkOpen();
453        if (amount < 1) {
454            return 0;
455        }
456        if (end - pos >= amount) {
457            pos += Math.toIntExact(amount);
458            return amount;
459        }
460
461        long read = end - pos;
462        pos = end;
463        while (read < amount) {
464            if (fillBuf() == EOF) {
465                return read;
466            }
467            if (end - pos >= amount - read) {
468                pos += Math.toIntExact(amount - read);
469                return amount;
470            }
471            // Couldn't get all the characters, skip what we read
472            read += end - pos;
473            pos = end;
474        }
475        return amount;
476    }
477
478}