archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-26 22:34:27 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8196298: Add null Reader and Writer

Browse source 
Reviewed-by: bpb, forax, smarks, alanb, rriggs
This commit is contained in:
Patrick Reinhart 2018-03-19 09:58:41 -04:00 • committed by Roger Riggs
parent ec605aa039
commit 4c7f1ac52c
4 changed files with 476 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

82
src/java.base/share/classes/java/io/Reader.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -26,6 +26,7 @@
package java.io;
import java.nio.CharBuffer;
import java.util.Objects;
/**
@ -54,6 +55,85 @@ public abstract class Reader implements Readable, Closeable {
private static final int TRANSFER_BUFFER_SIZE = 8192;
/**
* Returns a new {@code Reader} that reads no characters. The returned
* stream is initially open. The stream is closed by calling the
* {@code close()} method. Subsequent calls to {@code close()} have no
* effect.
*
* <p> While the stream is open, the {@code read()}, {@code read(char[])},
* {@code read(char[], int, int)}, {@code read(Charbuffer)}, {@code
* ready())}, {@code skip(long)}, and {@code transferTo()} methods all
* behave as if end of stream has been reached. After the stream has been
* closed, these methods all throw {@code IOException}.
*
* <p> The {@code markSupported()} method returns {@code false}. The
* {@code mark()} method does nothing, and the {@code reset()} method
* throws {@code IOException}.
*
* <p> The {@link #lock object} used to synchronize operations on the
* returned {@code Reader} is not specified.
*
* @return a {@code Reader} which reads no characters
*
* @since 11
*/
public static Reader nullReader() {
return new Reader() {
private volatile boolean closed;
private void ensureOpen() throws IOException {
if (closed) {
throw new IOException("Stream closed");
}
}
@Override
public int read() throws IOException {
ensureOpen();
return -1;
}
@Override
public int read(char[] cbuf, int off, int len) throws IOException {
Objects.checkFromIndexSize(off, len, cbuf.length);
ensureOpen();
if (len == 0) {
return 0;
}
return -1;
}
@Override
public int read(CharBuffer target) throws IOException {
Objects.requireNonNull(target);
ensureOpen();
if (target.hasRemaining()) {
return -1;
}
return 0;
}
@Override
public long skip(long n) throws IOException {
ensureOpen();
return 0L;
}
@Override
public long transferTo(Writer out) throws IOException {
Objects.requireNonNull(out);
ensureOpen();
return 0L;
}
@Override
public void close() {
closed = true;
}
};
}
/**
* The object used to synchronize operations on this stream. For
* efficiency, a character-stream object may use an object other than

89
src/java.base/share/classes/java/io/Writer.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -26,6 +26,8 @@
package java.io;
import java.util.Objects;
/**
* Abstract class for writing to character streams. The only methods that a
* subclass must implement are write(char[], int, int), flush(), and close().
@ -58,6 +60,91 @@ public abstract class Writer implements Appendable, Closeable, Flushable {
*/
private static final int WRITE_BUFFER_SIZE = 1024;
/**
* Returns a new {@code Writer} which discards all characters. The
* returned stream is initially open. The stream is closed by calling
* the {@code close()} method. Subsequent calls to {@code close()} have
* no effect.
*
* <p> While the stream is open, the {@code append(char)}, {@code
* append(CharSequence)}, {@code append(CharSequence, int, int)},
* {@code flush()}, {@code write(int)}, {@code write(char[])}, and
* {@code write(char[], int, int)} methods do nothing. After the stream
* has been closed, these methods all throw {@code IOException}.
*
* <p> The {@link #lock object} used to synchronize operations on the
* returned {@code Writer} is not specified.
*
* @return a {@code Writer} which discards all characters
*
* @since 11
*/
public static Writer nullWriter() {
return new Writer() {
private volatile boolean closed;
private void ensureOpen() throws IOException {
if (closed) {
throw new IOException("Stream closed");
}
}
@Override
public Writer append(char c) throws IOException {
ensureOpen();
return this;
}
@Override
public Writer append(CharSequence csq) throws IOException {
ensureOpen();
return this;
}
@Override
public Writer append(CharSequence csq, int start, int end) throws IOException {
ensureOpen();
if (csq != null) {
Objects.checkFromToIndex(start, end, csq.length());
}
return this;
}
@Override
public void write(int c) throws IOException {
ensureOpen();
}
@Override
public void write(char[] cbuf, int off, int len) throws IOException {
Objects.checkFromIndexSize(off, len, cbuf.length);
ensureOpen();
}
@Override
public void write(String str) throws IOException {
Objects.requireNonNull(str);
ensureOpen();
}
@Override
public void write(String str, int off, int len) throws IOException {
Objects.checkFromIndexSize(off, len, str.length());
ensureOpen();
}
@Override
public void flush() throws IOException {
ensureOpen();
}
@Override
public void close() throws IOException {
closed = true;
}
};
}
/**
* The object used to synchronize operations on this stream. For
* efficiency, a character-stream object may use an object other than