Struct async_std_utp::UtpListener

pub struct UtpListener { /* fields omitted */ }

A structure representing a socket server.

Examples

use async_std_utp::{UtpListener, UtpSocket};
use async_std::{prelude::*, task};

async fn handle_client(socket: UtpSocket) {
    // ...
}

    // Create a listener
    let addr = "127.0.0.1:8080";
    let listener = UtpListener::bind(addr).await.expect("Error binding socket");
    let mut incoming = listener.incoming();
    while let Some(connection) = incoming.next().await {
        // Spawn a new handler for each new connection
        if let Ok((socket, _src)) = connection {
            task::spawn(async move { handle_client(socket) });
        }
    }

Implementations

impl UtpListener

pub async fn bind<A: ToSocketAddrs>(addr: A) -> Result<UtpListener>

Creates a new UtpListener bound to a specific address.

The resulting listener is ready for accepting connections.

The address type can be any implementer of the ToSocketAddr trait. See its documentation for concrete examples.

If more than one valid address is specified, only the first will be used.

pub async fn accept(&self) -> Result<(UtpSocket, SocketAddr)>

Accepts a new incoming connection from this listener.

This function will block the caller until a new uTP connection is established. When established, the corresponding UtpSocket and the peer’s remote address will be returned.

Notice that the resulting UtpSocket is bound to a different local port than the public listening port (which UtpListener holds). This may confuse the remote peer!

pub fn incoming(&self) -> Incoming<'_>

Returns an iterator over the connections being received by this listener.

The returned iterator will never return None.

pub fn local_addr(&self) -> Result<SocketAddr>

Returns the local socket address of this listener.

Trait Implementations

impl Clone for UtpListener

fn clone(&self) -> UtpListener

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.