Package io.vertx.mutiny.core.datagram

Class DatagramSocket

java.lang.Object

io.vertx.mutiny.core.datagram.DatagramSocket

All Implemented Interfaces:

Measured, ReadStream<DatagramPacket>, StreamBase

public class DatagramSocket
extends Object
implements ReadStream<DatagramPacket>, Measured

A datagram socket can be used to send DatagramPacket's to remote datagram servers and receive DatagramPackets .

Usually you use a datagram socket to send UDP over the wire. UDP is connection-less which means you are not connected to the remote peer in a persistent way. Because of this you have to supply the address and port of the remote peer when sending data.

You can send data to ipv4 or ipv6 addresses, which also include multicast addresses.

Please consult the documentation for more information on datagram sockets.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields

Modifier and Type	Field	Description
static TypeArg<DatagramSocket>	__TYPE_ARG

Constructor Summary

Constructors

Constructor	Description
DatagramSocket(io.vertx.core.datagram.DatagramSocket delegate)

Method Summary

Modifier and Type	Method	Description
io.smallrye.mutiny.Uni<DatagramSocket>	blockMulticastGroup(String multicastAddress, String sourceToBlock)	Block the given address for the given multicast address and notifies the once the operation completes.
io.smallrye.mutiny.Uni<DatagramSocket>	blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock)	Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.
DatagramSocket	blockMulticastGroupAndAwait(String multicastAddress, String sourceToBlock)	Blocking variant of blockMulticastGroup(String,String).
DatagramSocket	blockMulticastGroupAndAwait(String multicastAddress, String networkInterface, String sourceToBlock)	Blocking variant of blockMulticastGroup(String,String,String).
io.smallrye.mutiny.Uni<Void>	close()	Closes the DatagramSocket implementation asynchronous and notifies the handler once done.
Void	closeAndAwait()	Blocking variant of close().
void	closeAndForget()	Variant of close() that ignores the result of the operation.
DatagramSocket	endHandler(Consumer<Void> endHandler)
boolean	equals(Object o)
DatagramSocket	exceptionHandler(Consumer<Throwable> handler)
DatagramSocket	fetch(long amount)
io.vertx.core.datagram.DatagramSocket	getDelegate()
DatagramSocket	handler(Consumer<DatagramPacket> handler)
int	hashCode()
boolean	isMetricsEnabled()
io.smallrye.mutiny.Uni<DatagramSocket>	listen(int port, String host)	Start listening on the given port and host.
DatagramSocket	listenAndAwait(int port, String host)	Blocking variant of listen(int,String).
io.smallrye.mutiny.Uni<DatagramSocket>	listenMulticastGroup(String multicastAddress)	Joins a multicast group and listens for packets send to it.
io.smallrye.mutiny.Uni<DatagramSocket>	listenMulticastGroup(String multicastAddress, String networkInterface, String source)	Joins a multicast group and listens for packets send to it on the given network interface.
DatagramSocket	listenMulticastGroupAndAwait(String multicastAddress)	Blocking variant of listenMulticastGroup(String).
DatagramSocket	listenMulticastGroupAndAwait(String multicastAddress, String networkInterface, String source)	Blocking variant of listenMulticastGroup(String,String,String).
SocketAddress	localAddress()
static DatagramSocket	newInstance(io.vertx.core.datagram.DatagramSocket arg)
DatagramSocket	pause()
Pipe<DatagramPacket>	pipe()
io.smallrye.mutiny.Uni<Void>	pipeTo(WriteStream<DatagramPacket> dst)	Pipe this ReadStream to the WriteStream.
Void	pipeToAndAwait(WriteStream<DatagramPacket> dst)	Blocking variant of io.vertx.mutiny.core.streams.ReadStream#pipeTo(io.vertx.mutiny.core.streams.WriteStream).
void	pipeToAndForget(WriteStream<DatagramPacket> dst)	Variant of io.vertx.mutiny.core.streams.ReadStream#pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
DatagramSocket	resume()
io.smallrye.mutiny.Uni<DatagramSocket>	send(Buffer packet, int port, String host)	Write the given Buffer to the SocketAddress.
io.smallrye.mutiny.Uni<DatagramSocket>	send(String str, int port, String host)	Write the given String to the SocketAddress using UTF8 encoding.
io.smallrye.mutiny.Uni<DatagramSocket>	send(String str, String enc, int port, String host)	Write the given String to the SocketAddress using the given encoding.
DatagramSocket	sendAndAwait(Buffer packet, int port, String host)	Blocking variant of send(io.vertx.mutiny.core.buffer.Buffer,int,String).
DatagramSocket	sendAndAwait(String str, int port, String host)	Blocking variant of send(String,int,String).
DatagramSocket	sendAndAwait(String str, String enc, int port, String host)	Blocking variant of send(String,String,int,String).
WriteStream<Buffer>	sender(int port, String host)
Iterable<DatagramPacket>	toBlockingIterable()
Stream<DatagramPacket>	toBlockingStream()
io.smallrye.mutiny.Multi<DatagramPacket>	toMulti()
String	toString()
io.smallrye.mutiny.Uni<DatagramSocket>	unlistenMulticastGroup(String multicastAddress)	Leaves a multicast group and stops listening for packets send to it.
io.smallrye.mutiny.Uni<DatagramSocket>	unlistenMulticastGroup(String multicastAddress, String networkInterface, String source)	Leaves a multicast group and stops listening for packets send to it on the given network interface.
DatagramSocket	unlistenMulticastGroupAndAwait(String multicastAddress)	Blocking variant of unlistenMulticastGroup(String).
DatagramSocket	unlistenMulticastGroupAndAwait(String multicastAddress, String networkInterface, String source)	Blocking variant of unlistenMulticastGroup(String,String,String).

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

__TYPE_ARG

public static final TypeArg<DatagramSocket> __TYPE_ARG

Constructor Detail

DatagramSocket

public DatagramSocket(io.vertx.core.datagram.DatagramSocket delegate)

Method Detail

getDelegate

public io.vertx.core.datagram.DatagramSocket getDelegate()

Specified by:

getDelegate in interface Measured

Specified by:

getDelegate in interface ReadStream<DatagramPacket>

Specified by:

getDelegate in interface StreamBase

toString

public String toString()

Overrides:

toString in class Object

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

isMetricsEnabled

public boolean isMetricsEnabled()

Specified by:

isMetricsEnabled in interface Measured

Returns:

true if metrics are enabled

pipe

public Pipe<DatagramPacket> pipe()

Specified by:

pipe in interface ReadStream<DatagramPacket>

Returns:

a pipe

pipeTo

public io.smallrye.mutiny.Uni<Void> pipeTo(WriteStream<DatagramPacket> dst)

Pipe this ReadStream to the WriteStream.

Elements emitted by this stream will be written to the write stream until this stream ends or fails.

Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

pipeTo in interface ReadStream<DatagramPacket>

Parameters:

dst - the destination write stream

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

pipeToAndAwait

public Void pipeToAndAwait(WriteStream<DatagramPacket> dst)

Blocking variant of io.vertx.mutiny.core.streams.ReadStream#pipeTo(io.vertx.mutiny.core.streams.WriteStream).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

pipeToAndAwait in interface ReadStream<DatagramPacket>

Parameters:

dst - the destination write stream

Returns:

the Void instance produced by the operation

send

public io.smallrye.mutiny.Uni<DatagramSocket> send(Buffer packet,
                                                   int port,
                                                   String host)

Write the given Buffer to the SocketAddress. The Handler will be notified once the write completes.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

packet - the Buffer to write

port - the host port of the remote peer

host - the host address of the remote peer

Returns:

a reference to this, so the API can be used fluently

sendAndAwait

public DatagramSocket sendAndAwait(Buffer packet,
                                   int port,
                                   String host)

Blocking variant of send(io.vertx.mutiny.core.buffer.Buffer,int,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

packet - the Buffer to write

port - the host port of the remote peer

host - the host address of the remote peer

Returns:

a reference to this, so the API can be used fluently

sender

public WriteStream<Buffer> sender(int port,
                                  String host)

Parameters:

port - the port of the remote peer

host - the host address of the remote peer

Returns:

the write stream for sending packets

send

public io.smallrye.mutiny.Uni<DatagramSocket> send(String str,
                                                   int port,
                                                   String host)

Write the given String to the SocketAddress using UTF8 encoding. The will be notified once the write completes.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

str - the String to write

port - the host port of the remote peer

host - the host address of the remote peer

Returns:

a reference to this, so the API can be used fluently

sendAndAwait

public DatagramSocket sendAndAwait(String str,
                                   int port,
                                   String host)

Blocking variant of send(String,int,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

str - the String to write

port - the host port of the remote peer

host - the host address of the remote peer

Returns:

a reference to this, so the API can be used fluently

send

public io.smallrye.mutiny.Uni<DatagramSocket> send(String str,
                                                   String enc,
                                                   int port,
                                                   String host)

Write the given String to the SocketAddress using the given encoding. The will be notified once the write completes.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

str - the String to write

enc - the charset used for encoding

port - the host port of the remote peer

host - the host address of the remote peer

Returns:

a reference to this, so the API can be used fluently

sendAndAwait

public DatagramSocket sendAndAwait(String str,
                                   String enc,
                                   int port,
                                   String host)

Blocking variant of send(String,String,int,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

str - the String to write

enc - the charset used for encoding

port - the host port of the remote peer

host - the host address of the remote peer

Returns:

a reference to this, so the API can be used fluently

close

public io.smallrye.mutiny.Uni<Void> close()

Closes the DatagramSocket implementation asynchronous and notifies the handler once done.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

closeAndAwait

public Void closeAndAwait()

Blocking variant of close().

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Returns:

the Void instance produced by the operation

localAddress

public SocketAddress localAddress()

Returns:

the socket address

listenMulticastGroup

public io.smallrye.mutiny.Uni<DatagramSocket> listenMulticastGroup(String multicastAddress)

Joins a multicast group and listens for packets send to it. The is notified once the operation completes.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

multicastAddress - the address of the multicast group to join

Returns:

a reference to this, so the API can be used fluently

listenMulticastGroupAndAwait

public DatagramSocket listenMulticastGroupAndAwait(String multicastAddress)

Blocking variant of listenMulticastGroup(String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

multicastAddress - the address of the multicast group to join

Returns:

a reference to this, so the API can be used fluently

listenMulticastGroup

public io.smallrye.mutiny.Uni<DatagramSocket> listenMulticastGroup(String multicastAddress,
                                                                   String networkInterface,
                                                                   String source)

Joins a multicast group and listens for packets send to it on the given network interface. The is notified once the operation completes.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

multicastAddress - the address of the multicast group to join

networkInterface - the network interface on which to listen for packets.

source - the address of the source for which we will listen for multicast packets

Returns:

a reference to this, so the API can be used fluently

listenMulticastGroupAndAwait

public DatagramSocket listenMulticastGroupAndAwait(String multicastAddress,
                                                   String networkInterface,
                                                   String source)

Blocking variant of listenMulticastGroup(String,String,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

multicastAddress - the address of the multicast group to join

networkInterface - the network interface on which to listen for packets.

source - the address of the source for which we will listen for multicast packets

Returns:

a reference to this, so the API can be used fluently

unlistenMulticastGroup

public io.smallrye.mutiny.Uni<DatagramSocket> unlistenMulticastGroup(String multicastAddress)

Leaves a multicast group and stops listening for packets send to it. The is notified once the operation completes.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

multicastAddress - the address of the multicast group to leave

Returns:

a reference to this, so the API can be used fluently

unlistenMulticastGroupAndAwait

public DatagramSocket unlistenMulticastGroupAndAwait(String multicastAddress)

Blocking variant of unlistenMulticastGroup(String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

multicastAddress - the address of the multicast group to leave

Returns:

a reference to this, so the API can be used fluently

unlistenMulticastGroup

public io.smallrye.mutiny.Uni<DatagramSocket> unlistenMulticastGroup(String multicastAddress,
                                                                     String networkInterface,
                                                                     String source)

Leaves a multicast group and stops listening for packets send to it on the given network interface. The is notified once the operation completes.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

multicastAddress - the address of the multicast group to join

networkInterface - the network interface on which to listen for packets.

source - the address of the source for which we will listen for multicast packets

Returns:

a reference to this, so the API can be used fluently

unlistenMulticastGroupAndAwait

public DatagramSocket unlistenMulticastGroupAndAwait(String multicastAddress,
                                                     String networkInterface,
                                                     String source)

Blocking variant of unlistenMulticastGroup(String,String,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

multicastAddress - the address of the multicast group to join

networkInterface - the network interface on which to listen for packets.

source - the address of the source for which we will listen for multicast packets

Returns:

a reference to this, so the API can be used fluently

blockMulticastGroup

public io.smallrye.mutiny.Uni<DatagramSocket> blockMulticastGroup(String multicastAddress,
                                                                  String sourceToBlock)

Block the given address for the given multicast address and notifies the once the operation completes.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

multicastAddress - the address for which you want to block the source address

sourceToBlock - the source address which should be blocked. You will not receive an multicast packets for it anymore.

Returns:

a reference to this, so the API can be used fluently

blockMulticastGroupAndAwait

public DatagramSocket blockMulticastGroupAndAwait(String multicastAddress,
                                                  String sourceToBlock)

Blocking variant of blockMulticastGroup(String,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

multicastAddress - the address for which you want to block the source address

sourceToBlock - the source address which should be blocked. You will not receive an multicast packets for it anymore.

Returns:

a reference to this, so the API can be used fluently

blockMulticastGroup

public io.smallrye.mutiny.Uni<DatagramSocket> blockMulticastGroup(String multicastAddress,
                                                                  String networkInterface,
                                                                  String sourceToBlock)

Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

multicastAddress - the address for which you want to block the source address

networkInterface - the network interface on which the blocking should occur.

sourceToBlock - the source address which should be blocked. You will not receive an multicast packets for it anymore.

Returns:

a reference to this, so the API can be used fluently

blockMulticastGroupAndAwait

public DatagramSocket blockMulticastGroupAndAwait(String multicastAddress,
                                                  String networkInterface,
                                                  String sourceToBlock)

Blocking variant of blockMulticastGroup(String,String,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

multicastAddress - the address for which you want to block the source address

networkInterface - the network interface on which the blocking should occur.

sourceToBlock - the source address which should be blocked. You will not receive an multicast packets for it anymore.

Returns:

a reference to this, so the API can be used fluently

listen

public io.smallrye.mutiny.Uni<DatagramSocket> listen(int port,
                                                     String host)

Start listening on the given port and host. The handler will be called when the socket is listening.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

port - the port to listen on

host - the host to listen on

Returns:

a reference to this, so the API can be used fluently

listenAndAwait

public DatagramSocket listenAndAwait(int port,
                                     String host)

Blocking variant of listen(int,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

port - the port to listen on

host - the host to listen on

Returns:

a reference to this, so the API can be used fluently

pause

public DatagramSocket pause()

Specified by:

pause in interface ReadStream<DatagramPacket>

Returns:

a reference to this, so the API can be used fluently

resume

public DatagramSocket resume()

Specified by:

resume in interface ReadStream<DatagramPacket>

Returns:

a reference to this, so the API can be used fluently

fetch

public DatagramSocket fetch(long amount)

Specified by:

fetch in interface ReadStream<DatagramPacket>

Returns:

a reference to this, so the API can be used fluently

endHandler

public DatagramSocket endHandler(Consumer<Void> endHandler)

Specified by:

endHandler in interface ReadStream<DatagramPacket>

Returns:

a reference to this, so the API can be used fluently

handler

public DatagramSocket handler(Consumer<DatagramPacket> handler)

Specified by:

handler in interface ReadStream<DatagramPacket>

Returns:

a reference to this, so the API can be used fluently

exceptionHandler

public DatagramSocket exceptionHandler(Consumer<Throwable> handler)

Specified by:

exceptionHandler in interface ReadStream<DatagramPacket>

Specified by:

exceptionHandler in interface StreamBase

Parameters:

handler - the exception handler

Returns:

a reference to this, so the API can be used fluently

pipeToAndForget

public void pipeToAndForget(WriteStream<DatagramPacket> dst)

Variant of io.vertx.mutiny.core.streams.ReadStream#pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.

This method subscribes on the result of io.vertx.mutiny.core.streams.ReadStream#pipeTo(io.vertx.mutiny.core.streams.WriteStream), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.streams.ReadStream#pipeTo(io.vertx.mutiny.core.streams.WriteStream) but you don't need to compose it with other operations.

Parameters:

dst -

closeAndForget

public void closeAndForget()

Variant of close() that ignores the result of the operation.

This method subscribes on the result of close(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from close() but you don't need to compose it with other operations.

toMulti

public io.smallrye.mutiny.Multi<DatagramPacket> toMulti()

Specified by:

toMulti in interface ReadStream<DatagramPacket>

toBlockingIterable

public Iterable<DatagramPacket> toBlockingIterable()

toBlockingStream

public Stream<DatagramPacket> toBlockingStream()

newInstance

public static DatagramSocket newInstance(io.vertx.core.datagram.DatagramSocket arg)