jdk-sandbox: comparison jdk/src/java.base/share/classes/java/nio/channels/Channels.java

equal deleted inserted replaced

-:654c0f23c1c0
+:2e48c9e946a7
 /*
-* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2000, 2014, 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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CharsetEncoder;
 import java.nio.charset.UnsupportedCharsetException;
 import java.nio.channels.spi.AbstractInterruptibleChannel;
+import java.util.Objects;
 import java.util.concurrent.ExecutionException;
 import sun.nio.ch.ChannelInputStream;
 import sun.nio.cs.StreamDecoder;
 import sun.nio.cs.StreamEncoder;
 /**
 * Utility methods for channels and streams.
 *
 * <p> This class defines static methods that support the interoperation of the
-* stream classes of the <tt>{@link java.io}</tt> package with the channel
+* stream classes of the {@link java.io} package with the channel classes
-* classes of this package.  </p>
+* of this package.  </p>
 *
 *
 * @author Mark Reinhold
 * @author Mike McCloskey
 * @author JSR-51 Expert Group
 * @since 1.4
 */
 public final class Channels {
-private Channels() { }              // No instantiation
+private Channels() { throw new Error("no instances"); }
-private static void checkNotNull(Object o, String name) {
-if (o == null)
-throw new NullPointerException("\"" + name + "\" is null!");
-}
 /**
 * Write all remaining bytes in buffer to the given channel.
 * If the channel is selectable then it must be configured blocking.
 */
 */
 private static void writeFully(WritableByteChannel ch, ByteBuffer bb)
 throws IOException
 {
 if (ch instanceof SelectableChannel) {
-SelectableChannel sc = (SelectableChannel)ch;
+SelectableChannel sc = (SelectableChannel) ch;
 synchronized (sc.blockingLock()) {
 if (!sc.isBlocking())
 throw new IllegalBlockingModeException();
 writeFullyImpl(ch, bb);
 }
 // -- Byte streams from channels --
 /**
 * Constructs a stream that reads bytes from the given channel.
 *
-* <p> The <tt>read</tt> methods of the resulting stream will throw an
+* <p> The {@code read} methods of the resulting stream will throw an
 * {@link IllegalBlockingModeException} if invoked while the underlying
 * channel is in non-blocking mode.  The stream will not be buffered, and
 * it will not support the {@link InputStream#mark mark} or {@link
 * InputStream#reset reset} methods.  The stream will be safe for access by
 * multiple concurrent threads.  Closing the stream will in turn cause the
 *         The channel from which bytes will be read
 *
 * @return  A new input stream
 */
 public static InputStream newInputStream(ReadableByteChannel ch) {
-checkNotNull(ch, "ch");
+Objects.requireNonNull(ch, "ch");
-return new sun.nio.ch.ChannelInputStream(ch);
+return new ChannelInputStream(ch);
 }
 /**
 * Constructs a stream that writes bytes to the given channel.
 *
-* <p> The <tt>write</tt> methods of the resulting stream will throw an
+* <p> The {@code write} methods of the resulting stream will throw an
 * {@link IllegalBlockingModeException} if invoked while the underlying
 * channel is in non-blocking mode.  The stream will not be buffered.  The
 * stream will be safe for access by multiple concurrent threads.  Closing
 * the stream will in turn cause the channel to be closed.  </p>
 *
 * @param  ch
 *         The channel to which bytes will be written
 *
 * @return  A new output stream
 */
-public static OutputStream newOutputStream(final WritableByteChannel ch) {
+public static OutputStream newOutputStream(WritableByteChannel ch) {
-checkNotNull(ch, "ch");
+Objects.requireNonNull(ch, "ch");
 return new OutputStream() {
-private ByteBuffer bb = null;
+private ByteBuffer bb;
-private byte[] bs = null;       // Invoker's previous array
+private byte[] bs;       // Invoker's previous array
-private byte[] b1 = null;
+private byte[] b1;
-public synchronized void write(int b) throws IOException {
+@Override
-if (b1 == null)
+public synchronized void write(int b) throws IOException {
-b1 = new byte[1];
+if (b1 == null)
-b1[0] = (byte)b;
+b1 = new byte[1];
-this.write(b1);
+b1[0] = (byte) b;
+this.write(b1);
+}
+@Override
+public synchronized void write(byte[] bs, int off, int len)
+throws IOException
+{
+if ((off < 0) || (off > bs.length) || (len < 0) ||
+((off + len) > bs.length) || ((off + len) < 0)) {
+throw new IndexOutOfBoundsException();
+} else if (len == 0) {
+return;
 }
+ByteBuffer bb = ((this.bs == bs)
-public synchronized void write(byte[] bs, int off, int len)
+? this.bb
-throws IOException
+: ByteBuffer.wrap(bs));
-{
+bb.limit(Math.min(off + len, bb.capacity()));
-if ((off < 0) || (off > bs.length) || (len < 0) ||
+bb.position(off);
-((off + len) > bs.length) || ((off + len) < 0)) {
+this.bb = bb;
-throw new IndexOutOfBoundsException();
+this.bs = bs;
-} else if (len == 0) {
+Channels.writeFully(ch, bb);
-return;
+}
-}
-ByteBuffer bb = ((this.bs == bs)
+@Override
-? this.bb
+public void close() throws IOException {
-: ByteBuffer.wrap(bs));
+ch.close();
-bb.limit(Math.min(off + len, bb.capacity()));
+}
-bb.position(off);
-this.bb = bb;
+};
-this.bs = bs;
-Channels.writeFully(ch, bb);
-}
-public void close() throws IOException {
-ch.close();
-}
-};
 }
 /**
 * Constructs a stream that reads bytes from the given channel.
 *
 *
 * @return  A new input stream
 *
 * @since 1.7
 */
-public static InputStream newInputStream(final AsynchronousByteChannel ch) {
+public static InputStream newInputStream(AsynchronousByteChannel ch) {
-checkNotNull(ch, "ch");
+Objects.requireNonNull(ch, "ch");
 return new InputStream() {
-private ByteBuffer bb = null;
+private ByteBuffer bb;
-private byte[] bs = null;           // Invoker's previous array
+private byte[] bs;           // Invoker's previous array
-private byte[] b1 = null;
+private byte[] b1;
 @Override
 public synchronized int read() throws IOException {
 if (b1 == null)
 b1 = new byte[1];
 return -1;
 }
 @Override
 public synchronized int read(byte[] bs, int off, int len)
 throws IOException
 {
 if ((off < 0) || (off > bs.length) || (len < 0) ||
 ((off + len) > bs.length) || ((off + len) < 0)) {
 throw new IndexOutOfBoundsException();
-} else if (len == 0)
+} else if (len == 0) {
 return 0;
+}
 ByteBuffer bb = ((this.bs == bs)
 ? this.bb
 : ByteBuffer.wrap(bs));
 bb.position(off);
 *
 * @return  A new output stream
 *
 * @since 1.7
 */
-public static OutputStream newOutputStream(final AsynchronousByteChannel ch) {
+public static OutputStream newOutputStream(AsynchronousByteChannel ch) {
-checkNotNull(ch, "ch");
+Objects.requireNonNull(ch, "ch");
 return new OutputStream() {
-private ByteBuffer bb = null;
+private ByteBuffer bb;
-private byte[] bs = null;   // Invoker's previous array
+private byte[] bs;   // Invoker's previous array
-private byte[] b1 = null;
+private byte[] b1;
 @Override
 public synchronized void write(int b) throws IOException {
 if (b1 == null)
 b1 = new byte[1];
-b1[0] = (byte)b;
+b1[0] = (byte) b;
 this.write(b1);
 }
 @Override
 public synchronized void write(byte[] bs, int off, int len)
 throws IOException
 {
 if ((off < 0) || (off > bs.length) || (len < 0) ||
 ((off + len) > bs.length) || ((off + len) < 0)) {
 throw new IndexOutOfBoundsException();
 } else if (len == 0) {
 * @param  in
 *         The stream from which bytes are to be read
 *
 * @return  A new readable byte channel
 */
-public static ReadableByteChannel newChannel(final InputStream in) {
+public static ReadableByteChannel newChannel(InputStream in) {
-checkNotNull(in, "in");
+Objects.requireNonNull(in, "in");
-if (in instanceof FileInputStream &&
+if (in.getClass() == FileInputStream.class) {
-FileInputStream.class.equals(in.getClass())) {
+return ((FileInputStream) in).getChannel();
-return ((FileInputStream)in).getChannel();
 }
 return new ReadableByteChannelImpl(in);
 }
 private static class ReadableByteChannelImpl
 extends AbstractInterruptibleChannel    // Not really interruptible
 implements ReadableByteChannel
 {
-InputStream in;
+private final InputStream in;
 private static final int TRANSFER_SIZE = 8192;
-private byte buf[] = new byte[0];
+private byte[] buf = new byte[0];
-private boolean open = true;
+private final Object readLock = new Object();
-private Object readLock = new Object();
 ReadableByteChannelImpl(InputStream in) {
 this.in = in;
 }
+@Override
 public int read(ByteBuffer dst) throws IOException {
 int len = dst.remaining();
 int totalRead = 0;
 int bytesRead = 0;
 synchronized (readLock) {
 return totalRead;
 }
 }
+@Override
 protected void implCloseChannel() throws IOException {
 in.close();
-open = false;
 }
 }
 /**
 * @param  out
 *         The stream to which bytes are to be written
 *
 * @return  A new writable byte channel
 */
-public static WritableByteChannel newChannel(final OutputStream out) {
+public static WritableByteChannel newChannel(OutputStream out) {
-checkNotNull(out, "out");
+Objects.requireNonNull(out, "out");
-if (out instanceof FileOutputStream &&
+if (out.getClass() == FileOutputStream.class) {
-FileOutputStream.class.equals(out.getClass())) {
+return ((FileOutputStream) out).getChannel();
-return ((FileOutputStream)out).getChannel();
 }
 return new WritableByteChannelImpl(out);
 }
 private static class WritableByteChannelImpl
 extends AbstractInterruptibleChannel    // Not really interruptible
 implements WritableByteChannel
 {
-OutputStream out;
+private final OutputStream out;
 private static final int TRANSFER_SIZE = 8192;
-private byte buf[] = new byte[0];
+private byte[] buf = new byte[0];
-private boolean open = true;
+private final Object writeLock = new Object();
-private Object writeLock = new Object();
 WritableByteChannelImpl(OutputStream out) {
 this.out = out;
 }
+@Override
 public int write(ByteBuffer src) throws IOException {
 int len = src.remaining();
 int totalWritten = 0;
 synchronized (writeLock) {
 while (totalWritten < len) {
 }
 return totalWritten;
 }
 }
+@Override
 protected void implCloseChannel() throws IOException {
 out.close();
-open = false;
 }
 }
 // -- Character streams from channels --
 /**
 * Constructs a reader that decodes bytes from the given channel using the
 * given decoder.
 *
 * <p> The resulting stream will contain an internal input buffer of at
-* least <tt>minBufferCap</tt> bytes.  The stream's <tt>read</tt> methods
+* least {@code minBufferCap} bytes.  The stream's {@code read} methods
 * will, as needed, fill the buffer by reading bytes from the underlying
 * channel; if the channel is in non-blocking mode when bytes are to be
 * read then an {@link IllegalBlockingModeException} will be thrown.  The
 * resulting stream will not otherwise be buffered, and it will not support
 * the {@link Reader#mark mark} or {@link Reader#reset reset} methods.
 * @param  dec
 *         The charset decoder to be used
 *
 * @param  minBufferCap
 *         The minimum capacity of the internal byte buffer,
-*         or <tt>-1</tt> if an implementation-dependent
+*         or {@code -1} if an implementation-dependent
 *         default capacity is to be used
 *
 * @return  A new reader
 */
 public static Reader newReader(ReadableByteChannel ch,
 CharsetDecoder dec,
 int minBufferCap)
 {
-checkNotNull(ch, "ch");
+Objects.requireNonNull(ch, "ch");
 return StreamDecoder.forDecoder(ch, dec.reset(), minBufferCap);
 }
 /**
 * Constructs a reader that decodes bytes from the given channel according
 * to the named charset.
 *
 * <p> An invocation of this method of the form
 *
-* <blockquote><pre>
+* <pre> {@code
-* Channels.newReader(ch, csname)</pre></blockquote>
+*     Channels.newReader(ch, csname)
+* } </pre>
 *
 * behaves in exactly the same way as the expression
 *
-* <blockquote><pre>
+* <pre> {@code
-* Channels.newReader(ch,
+*     Channels.newReader(ch, Charset.forName(csName).newDecoder(), -1)
-*                    Charset.forName(csName)
+* } </pre>
-*                        .newDecoder(),
-*                    -1);</pre></blockquote>
 *
 * @param  ch
 *         The channel from which bytes will be read
 *
 * @param  csName
 *          in this instance of the Java virtual machine
 */
 public static Reader newReader(ReadableByteChannel ch,
 String csName)
 {
-checkNotNull(csName, "csName");
+Objects.requireNonNull(csName, "csName");
 return newReader(ch, Charset.forName(csName).newDecoder(), -1);
 }
 /**
 * Constructs a writer that encodes characters using the given encoder and
 * writes the resulting bytes to the given channel.
 *
 * <p> The resulting stream will contain an internal output buffer of at
-* least <tt>minBufferCap</tt> bytes.  The stream's <tt>write</tt> methods
+* least {@code minBufferCap} bytes.  The stream's {@code write} methods
 * will, as needed, flush the buffer by writing bytes to the underlying
 * channel; if the channel is in non-blocking mode when bytes are to be
 * written then an {@link IllegalBlockingModeException} will be thrown.
 * The resulting stream will not otherwise be buffered.  Closing the stream
 * will in turn cause the channel to be closed.  </p>
 * @param  enc
 *         The charset encoder to be used
 *
 * @param  minBufferCap
 *         The minimum capacity of the internal byte buffer,
-*         or <tt>-1</tt> if an implementation-dependent
+*         or {@code -1} if an implementation-dependent
 *         default capacity is to be used
 *
 * @return  A new writer
 */
-public static Writer newWriter(final WritableByteChannel ch,
+public static Writer newWriter(WritableByteChannel ch,
-final CharsetEncoder enc,
+CharsetEncoder enc,
-final int minBufferCap)
+int minBufferCap)
 {
-checkNotNull(ch, "ch");
+Objects.requireNonNull(ch, "ch");
 return StreamEncoder.forEncoder(ch, enc.reset(), minBufferCap);
 }
 /**
 * Constructs a writer that encodes characters according to the named
 * charset and writes the resulting bytes to the given channel.
 *
 * <p> An invocation of this method of the form
-*
+* <p>
-* <blockquote><pre>
+* <pre> {@code
-* Channels.newWriter(ch, csname)</pre></blockquote>
+*     Channels.newWriter(ch, csname)
-*
+* } </pre>
 * behaves in exactly the same way as the expression
-*
+* <p>
-* <blockquote><pre>
+* <pre> {@code
-* Channels.newWriter(ch,
+*     Channels.newWriter(ch, Charset.forName(csName).newEncoder(), -1)
-*                    Charset.forName(csName)
+* } </pre>
-*                        .newEncoder(),
-*                    -1);</pre></blockquote>
 *
 * @param  ch
 *         The channel to which bytes will be written
 *
 * @param  csName
 *          in this instance of the Java virtual machine
 */
 public static Writer newWriter(WritableByteChannel ch,
 String csName)
 {
-checkNotNull(csName, "csName");
+Objects.requireNonNull(csName, "csName");
 return newWriter(ch, Charset.forName(csName).newEncoder(), -1);
 }
 }

changeset 27933	2e48c9e946a7
parent 25859	3317bb8137f4
child 28569	20682992a0ff