1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Reliudp: A custom Reliable UDP protocol for Rust
//!
//! # Examples
//! 
//! ## Server
//!
//! ```rust,no-run
//! extern crate reliudp;
//! use std::sync::Arc;
//! 
//! fn generate_really_big_message(i: u8) -> Arc<[u8]> {
//!     let really_big_message: Vec<u8> = (0..2000).map(|_v| i).collect();
//!     let really_big_message: Arc<[u8]> = Arc::from(really_big_message.into_boxed_slice());
//!     really_big_message
//! }
//! 
//! fn main() -> Result<(), Box<::std::error::Error>> {
//!     let mut server = reliudp::RUdpServer::new("0.0.0.0:61244").expect("Failed to create server");
//! 
//!     let mut n = 0;
//!     for i in 0u64.. {
//!         server.next_tick()?;
//!         for server_event in server.drain_events() {
//!             println!("Server: Incoming event {:?}", server_event);
//!         }
//! 
//!         if i % 300 == 0 {
//!             let big_message = generate_really_big_message(n);
//!             println!("Sending (n={:?}) {:?} bytes to all {:?} remotes", n, big_message.as_ref().len(), server.remotes_len());
//!             if n % 2 == 0 {
//!                 server.send_data(&big_message, reliudp::MessageType::KeyMessage);
//!             } else {
//!                 server.send_data(&big_message, reliudp::MessageType::Forgettable);
//!             }
//!             n += 1;
//!         }
//!         
//!         ::std::thread::sleep(::std::time::Duration::from_millis(5));
//!     }
//!     Ok(())
//! }
//! ```
//!
//! ## Client
//!
//! ```rust,no-run
//! extern crate reliudp;
//! use reliudp::SocketEvent;
//! 
//! fn main() -> Result<(), Box<::std::error::Error>> {
//!     let mut client = reliudp::RUdpSocket::connect("91.121.135.70:61244").expect("Failed to create client");
//!     for i in 0.. {
//!         client.next_tick()?;
//!         for client_event in client.drain_events() {
//!             if let SocketEvent::Data(d) = client_event {
//!                 println!("Client: Incoming {:?} bytes (n={:?}) at frame {:?}", d.len(), d[0], i);
//!             } else {
//!                 println!("Client: Incoming event {:?} at frame {:?}", client_event, i);
//!             }
//!         }
//! 
//!         ::std::thread::sleep(::std::time::Duration::from_millis(5));
//!     }
//!     Ok(())
//! }
//! ```

extern crate fnv;

extern crate itertools;

extern crate crc;
extern crate byteorder;

extern crate hex;

/// TODO: reorganize stuff.
/// Stuff is working, but it's really not well organized at all. A refactor will be needed
/// (at least name-wise, but also to define precisely which module has which limits and which role)

mod misc;
mod consts;
mod fragment_combiner;
mod fragment_generator;
mod fragment;
mod udp_packet;
mod rudp;
mod udp_packet_handler;
mod rudp_server;
mod ack;
mod sent_data_tracker;
mod ping_handler;

pub use rudp::*;
pub use rudp_server::*;