Struct Client

Source

pub struct Client { /* private fields */ }

Implementations§

Source §

impl Client

Source

pub fn new() -> Self

Create a empty client

Examples found in repository ?

examples/event.rs (line 6)

4fn main() -> Pod {
5    let _log2 = log2::start();
6    let mut ws = ws2::Client::new();
7
8    ws.connect("ws://172.16.210.211:5600")?;
9
10    loop {
11        let event = ws.recv(0.01);
12        match event {
13            ws2::client::Event::Open(_) => {
14                info!("open");
15                if let Err(e) = ws.send("hello world") {
16                    error!("{e}");
17                }
18            }
19            ws2::client::Event::Close => {
20                info!("close");
21                break;
22            }
23            ws2::client::Event::Text(msg) => {
24                info!("{msg}");
25            }
26            ws2::client::Event::Binary(_) => {}
27            ws2::client::Event::Timeout => {}
28            ws2::client::Event::Error(error) => {
29                error!("{error}");
30            }
31        }
32    }
33
34    Ok(())
35}

Source

pub fn connect(&mut self, url: &str) -> Pod

Examples found in repository ?

examples/event.rs (line 8)

4fn main() -> Pod {
5    let _log2 = log2::start();
6    let mut ws = ws2::Client::new();
7
8    ws.connect("ws://172.16.210.211:5600")?;
9
10    loop {
11        let event = ws.recv(0.01);
12        match event {
13            ws2::client::Event::Open(_) => {
14                info!("open");
15                if let Err(e) = ws.send("hello world") {
16                    error!("{e}");
17                }
18            }
19            ws2::client::Event::Close => {
20                info!("close");
21                break;
22            }
23            ws2::client::Event::Text(msg) => {
24                info!("{msg}");
25            }
26            ws2::client::Event::Binary(_) => {}
27            ws2::client::Event::Timeout => {}
28            ws2::client::Event::Error(error) => {
29                error!("{error}");
30            }
31        }
32    }
33
34    Ok(())
35}

Source

pub fn is_open(&self) -> bool

Source

pub fn recv(&mut self, timeout: f32) -> Event

Receive the events, timeout is decimal seconds

Examples found in repository ?

examples/event.rs (line 11)

4fn main() -> Pod {
5    let _log2 = log2::start();
6    let mut ws = ws2::Client::new();
7
8    ws.connect("ws://172.16.210.211:5600")?;
9
10    loop {
11        let event = ws.recv(0.01);
12        match event {
13            ws2::client::Event::Open(_) => {
14                info!("open");
15                if let Err(e) = ws.send("hello world") {
16                    error!("{e}");
17                }
18            }
19            ws2::client::Event::Close => {
20                info!("close");
21                break;
22            }
23            ws2::client::Event::Text(msg) => {
24                info!("{msg}");
25            }
26            ws2::client::Event::Binary(_) => {}
27            ws2::client::Event::Timeout => {}
28            ws2::client::Event::Error(error) => {
29                error!("{error}");
30            }
31        }
32    }
33
34    Ok(())
35}

Source

pub fn send<M>(&self, msg: M) -> Pod
where M: Into<Message>,

Examples found in repository ?

examples/event.rs (line 15)

4fn main() -> Pod {
5    let _log2 = log2::start();
6    let mut ws = ws2::Client::new();
7
8    ws.connect("ws://172.16.210.211:5600")?;
9
10    loop {
11        let event = ws.recv(0.01);
12        match event {
13            ws2::client::Event::Open(_) => {
14                info!("open");
15                if let Err(e) = ws.send("hello world") {
16                    error!("{e}");
17                }
18            }
19            ws2::client::Event::Close => {
20                info!("close");
21                break;
22            }
23            ws2::client::Event::Text(msg) => {
24                info!("{msg}");
25            }
26            ws2::client::Event::Binary(_) => {}
27            ws2::client::Event::Timeout => {}
28            ws2::client::Event::Error(error) => {
29                error!("{error}");
30            }
31        }
32    }
33
34    Ok(())
35}

Source

pub fn close(&self)

Close the socket

Source

pub fn process<F: Handler>(&mut self, handler: &mut F, timeout: f32) -> Pod

Process events with decimal seconds timeout, or [INFINITE]

Examples found in repository ?

examples/client.rs (line 31)

24fn main() -> Pod {
25    let _log2 = log2::start();
26    let url = "wss://stream.binance.com:9443/ws/btcusdt@miniTicker";
27    let mut client = ws2::connect(url)?;
28    let mut workder = Worker {};
29
30    loop {
31        let _ = client.process(&mut workder, 0.5);
32        // do other stuff
33    }
34}