jdk-sandbox: comparison src/java.base/share/classes/sun/nio/ch/DatagramSocketAdaptor.java

equal deleted inserted replaced

-:b43cc3b9ef40
+:13b67c1420b8
 /*
-* Copyright (c) 2001, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2019, 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.ByteBuffer;
 import java.nio.channels.ClosedChannelException;
 import java.nio.channels.DatagramChannel;
 import java.nio.channels.IllegalBlockingModeException;
 import java.util.Objects;
+import java.util.Set;
 // Make a datagram-socket channel look like a datagram socket.
 //
 // The methods in this class are defined in exactly the same order as in
 // java.net.DatagramSocket so as to simplify tracking future changes to that
 // class.
 //
-public class DatagramSocketAdaptor
+class DatagramSocketAdaptor
 extends DatagramSocket
 {
 // The channel being adapted
 private final DatagramChannelImpl dc;
 // Timeout "option" value for receives
 private volatile int timeout;
 // ## super will create a useless impl
-private DatagramSocketAdaptor(DatagramChannelImpl dc) throws IOException {
+private DatagramSocketAdaptor(DatagramChannelImpl dc) {
 // Invoke the DatagramSocketAdaptor(SocketAddress) constructor,
 // passing a dummy DatagramSocketImpl object to avoid any native
 // resource allocation in super class and invoking our bind method
 // before the dc field is initialized.
 super(dummyDatagramSocket);
 this.dc = dc;
 }
-public static DatagramSocket create(DatagramChannelImpl dc) {
+static DatagramSocket create(DatagramChannelImpl dc) {
-try {
+return new DatagramSocketAdaptor(dc);
-return new DatagramSocketAdaptor(dc);
-} catch (IOException x) {
-throw new Error(x);
-}
 }
 private void connectInternal(SocketAddress remote)
 throws SocketException
 {
 } catch (Exception x) {
 Net.translateToSocketException(x);
 }
 }
+@Override
 public void bind(SocketAddress local) throws SocketException {
 try {
 if (local == null)
 local = new InetSocketAddress(0);
 dc.bind(local);
 } catch (Exception x) {
 Net.translateToSocketException(x);
 }
 }
+@Override
 public void connect(InetAddress address, int port) {
 try {
 connectInternal(new InetSocketAddress(address, port));
 } catch (SocketException x) {
 // Yes, j.n.DatagramSocket really does this
 }
 }
+@Override
 public void connect(SocketAddress remote) throws SocketException {
 Objects.requireNonNull(remote, "Address can't be null");
 connectInternal(remote);
 }
+@Override
 public void disconnect() {
 try {
 dc.disconnect();
 } catch (IOException x) {
 throw new Error(x);
 }
 }
+@Override
 public boolean isBound() {
 return dc.localAddress() != null;
 }
+@Override
 public boolean isConnected() {
 return dc.remoteAddress() != null;
 }
+@Override
 public InetAddress getInetAddress() {
 InetSocketAddress remote = dc.remoteAddress();
 return (remote != null) ? remote.getAddress() : null;
 }
+@Override
 public int getPort() {
 InetSocketAddress remote = dc.remoteAddress();
 return (remote != null) ? remote.getPort() : -1;
 }
+@Override
+public SocketAddress getRemoteSocketAddress() {
+return dc.remoteAddress();
+}
+@Override
+public SocketAddress getLocalSocketAddress() {
+return dc.localAddress();
+}
+@Override
 public void send(DatagramPacket p) throws IOException {
 synchronized (dc.blockingLock()) {
 if (!dc.isBlocking())
 throw new IllegalBlockingModeException();
 try {
 throw new SocketTimeoutException();
 }
 }
 }
+@Override
 public void receive(DatagramPacket p) throws IOException {
 synchronized (dc.blockingLock()) {
 if (!dc.isBlocking())
 throw new IllegalBlockingModeException();
 try {
 Net.translateException(x);
 }
 }
 }
+@Override
 public InetAddress getLocalAddress() {
 if (isClosed())
 return null;
 InetSocketAddress local = dc.localAddress();
 if (local == null)
 }
 }
 return result;
 }
+@Override
 public int getLocalPort() {
 if (isClosed())
 return -1;
 try {
 InetSocketAddress local = dc.localAddress();
 } catch (Exception x) {
 }
 return 0;
 }
+@Override
 public void setSoTimeout(int timeout) throws SocketException {
+if (!dc.isOpen())
+throw new SocketException("Socket is closed");
+if (timeout < 0)
+throw new IllegalArgumentException("timeout < 0");
 this.timeout = timeout;
 }
+@Override
 public int getSoTimeout() throws SocketException {
+if (!dc.isOpen())
+throw new SocketException("Socket is closed");
 return timeout;
 }
 private void setBooleanOption(SocketOption<Boolean> name, boolean value)
 throws SocketException
 Net.translateToSocketException(x);
 return -1;          // keep compiler happy
 }
 }
+@Override
 public void setSendBufferSize(int size) throws SocketException {
 if (size <= 0)
 throw new IllegalArgumentException("Invalid send size");
 setIntOption(StandardSocketOptions.SO_SNDBUF, size);
 }
+@Override
 public int getSendBufferSize() throws SocketException {
 return getIntOption(StandardSocketOptions.SO_SNDBUF);
 }
+@Override
 public void setReceiveBufferSize(int size) throws SocketException {
 if (size <= 0)
 throw new IllegalArgumentException("Invalid receive size");
 setIntOption(StandardSocketOptions.SO_RCVBUF, size);
 }
+@Override
 public int getReceiveBufferSize() throws SocketException {
 return getIntOption(StandardSocketOptions.SO_RCVBUF);
 }
+@Override
 public void setReuseAddress(boolean on) throws SocketException {
 setBooleanOption(StandardSocketOptions.SO_REUSEADDR, on);
 }
+@Override
 public boolean getReuseAddress() throws SocketException {
 return getBooleanOption(StandardSocketOptions.SO_REUSEADDR);
 }
+@Override
 public void setBroadcast(boolean on) throws SocketException {
 setBooleanOption(StandardSocketOptions.SO_BROADCAST, on);
 }
+@Override
 public boolean getBroadcast() throws SocketException {
 return getBooleanOption(StandardSocketOptions.SO_BROADCAST);
 }
+@Override
 public void setTrafficClass(int tc) throws SocketException {
 setIntOption(StandardSocketOptions.IP_TOS, tc);
 }
+@Override
 public int getTrafficClass() throws SocketException {
 return getIntOption(StandardSocketOptions.IP_TOS);
 }
+@Override
 public void close() {
 try {
 dc.close();
 } catch (IOException x) {
 throw new Error(x);
 }
 }
+@Override
 public boolean isClosed() {
 return !dc.isOpen();
 }
+@Override
 public DatagramChannel getChannel() {
 return dc;
+}
+@Override
+public <T> DatagramSocket setOption(SocketOption<T> name, T value) throws IOException {
+dc.setOption(name, value);
+return this;
+}
+@Override
+public <T> T getOption(SocketOption<T> name) throws IOException {
+return dc.getOption(name);
+}
+@Override
+public Set<SocketOption<?>> supportedOptions() {
+return dc.supportedOptions();
 }
 /*
 * A dummy implementation of DatagramSocketImpl that can be passed to the
 * DatagramSocket constructor so that no native resources are allocated in

changeset 54620	13b67c1420b8
parent 49001	ce06058197a4
child 58899	5573a7098439