Struct ThreadedSocket

pub struct ThreadedSocket<SendType: Debug, ReceiveType: Debug> {
    status: NetworkStatus,
    addr_sender: Sender<Option<Address>>,
    sender: Sender<TextOrT<SendType>>,
    status_receiver: Receiver<NetworkStatus>,
    receiver: Receiver<TextOrT<ReceiveType>>,
}

Simple poll-based wrapper around a socket (websocket or TCP) connection that runs in a separate thread

Associated methods return immediately even when (for some) the operation might not be completed. Supports normal std environments as well as WASM.

Use [ThreadedSocket::default] for a websocket, or ThreadedSocket::new to specify another socket type.

Usage

use core_pb::threaded_websocket::{TextOrT, ThreadedSocket};
use std::thread::sleep;
use std::time::Duration;
use core_pb::messages::NetworkStatus;

// initialization
// by default, doesn't connect to anything
let mut connection: ThreadedSocket<usize, usize> = ThreadedSocket::with_name("test connection".to_string());
// try to connect to an address (with infinite retries)
connection.connect(Some(([127, 0, 0, 1], 20_000)));
// wait until connected
while connection.status() != NetworkStatus::Connected {
    sleep(Duration::from_millis(100))
}
// send a message to the server (returns immediately)
connection.send(TextOrT::T(1));
connection.send(TextOrT::Text("hello".to_string()));
// wait for a message
loop {
    // note: read() never blocks, and only returns
    // some message when one is available
    if let Some(msg) = connection.read() {
        println!("Got a message: {msg:?}");
        break;
    }
    sleep(Duration::from_millis(100))
}
// stop connecting to the server
connection.connect(None);

Fields

status: NetworkStatus

addr_sender: Sender<Option<Address>>

sender: Sender<TextOrT<SendType>>

status_receiver: Receiver<NetworkStatus>

receiver: Receiver<TextOrT<ReceiveType>>

Implementations

impl<SendType: Serialize + Debug + Send + 'static, ReceiveType: DeserializeOwned + Debug + Send + 'static> ThreadedSocket<SendType, ReceiveType>

pub fn connect(&mut self, addr: Option<Address>)

Specify an address to connect to (or None to suspend current connection and future attempts)

See ThreadedSocket for full usage example

pub fn status(&mut self) -> NetworkStatus

Fetch the latest information about the status of the connection

See ThreadedSocket for full usage example

pub fn send(&self, data: TextOrT<SendType>)

Queue something to be sent to the socket

If the connection is not available, the data will be discarded

See ThreadedSocket for full usage example

pub async fn async_send(&mut self, data: TextOrT<SendType>)

Queue something to be sent to the socket (blocking await)

If the connection is not available, the data will be discarded

See ThreadedSocket for full usage example

pub fn read(&mut self) -> Option<TextOrT<ReceiveType>>

Read new data from the socket, if it is available

Expects to be called frequently

See ThreadedSocket for full usage example

pub async fn async_read( &mut self, ) -> Either<TextOrT<ReceiveType>, NetworkStatus>

Read new data from the socket (blocking await)

Expects to be called frequently

See ThreadedSocket for full usage example

pub fn new<SocketType: ThreadableSocket<SendType, ReceiveType> + 'static, Serializer: FnMut(bool, TextOrT<SendType>) -> Result<Vec<u8>, SerializeResult> + Send + 'static, SerializeResult: Debug + 'static, Deserializer: FnMut(bool, &[u8]) -> Result<Vec<TextOrT<ReceiveType>>, DeserializeResult> + Send + 'static, DeserializeResult: Debug + 'static>( name: String, addr: Option<Address>, serializer: Serializer, deserializer: Deserializer, ) -> Self

Create a new ThreadedSocket

Usage

use core_pb::threaded_websocket::ThreadedSocket;

// websocket for either std environment or WASM
// let websocket = ThreadedSocket::with_name("test connection".to_string());
// tcp socket to be supported in the future

See ThreadedSocket for full usage example

impl<SendType: Serialize + Debug + Send + 'static, ReceiveType: DeserializeOwned + Debug + Send + 'static> ThreadedSocket<SendType, ReceiveType>

pub fn with_name(name: String) -> Self

Create a new ThreadedSocket with a name for logging