laminar reliable packet loss

main.rs

extern crate laminar;

use std::thread;
use laminar::{Socket, Packet, SocketEvent};

fn main() {

    // create the socket
    let server = thread::spawn(move || {
        let (mut socket, _, packet_receiver) = Socket::bind("127.0.0.1:12346").unwrap();
        let _poll = thread::spawn(move || socket.start_polling());
        let mut count = 0;
        loop {
            let result = packet_receiver.recv();
            match result {
                Ok(socket_event) => {
                    match socket_event {
                        SocketEvent::Packet(_packet) => {
                            count += 1;
                        },
                        SocketEvent::Connect(_connect_event) => { /* a client connected */ },
                        SocketEvent::Timeout(_timeout_event) => { /* a client timed out */ },
                    }
                }
                Err(e) => {
                    println!("Something went wrong when receiving, error: {:?}", e);
                }
            }
            println!("received {}", count);
        }
    });
    thread::sleep(std::time::Duration::from_secs(1));
    let client = thread::spawn(move || {
        let (mut socket, packet_sender, _) = Socket::bind("127.0.0.1:12345").unwrap();
        let _poll = thread::spawn(move || socket.start_polling());
        // our data
        let bytes = vec![4,5,6];
        // You can create packets with different reliabilities
        let reliable = Packet::reliable_unordered("127.0.0.1:12346".parse().unwrap(), bytes);
        // send the packets
        for _ in 0..1000 {
            println!("sending");
            packet_sender.send(reliable.clone()).unwrap();
            thread::sleep(std::time::Duration::from_millis(5));
        }
    });
    client.join().unwrap();
    server.join().unwrap();

}