raptorq 2.0.1

RaptorQ (RFC6330)
Documentation 
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

#[cfg(not(feature = "python"))]
use rand::seq::SliceRandom;

#[cfg(not(feature = "python"))]
use rand::Rng;

#[cfg(not(feature = "python"))]
use raptorq::{Decoder, Encoder, EncodingPacket};

#[cfg(not(feature = "python"))]
fn main() {
    // Generate some random data to send
    let mut data: Vec<u8> = vec![0; 10_000];
    for byte in data.iter_mut() {
        *byte = rand::rng().random();
    }

    // Create the Encoder, with an MTU of 1400 (common for Ethernet)
    let encoder = Encoder::with_defaults(&data, 1400);

    // Perform the encoding, and serialize to Vec<u8> for transmission
    let mut packets: Vec<Vec<u8>> = encoder
        .get_encoded_packets(15)
        .iter()
        .map(|packet| packet.serialize())
        .collect();

    // Here we simulate losing 10 of the packets randomly. Normally, you would send them over
    // (potentially lossy) network here.
    packets.shuffle(&mut rand::rng());
    // Erase 10 packets at random
    let length = packets.len();
    packets.truncate(length - 10);

    // The Decoder MUST be constructed with the configuration of the Encoder.
    // The ObjectTransmissionInformation configuration should be transmitted over a reliable
    // channel
    let mut decoder = Decoder::new(encoder.get_config());

    // Perform the decoding
    let mut result = None;
    while !packets.is_empty() {
        result = decoder.decode(EncodingPacket::deserialize(&packets.pop().unwrap()));
        if result.is_some() {
            break;
        }
    }

    // Check that even though some of the data was lost we are able to reconstruct the original message
    assert_eq!(result.unwrap(), data);
}

#[cfg(feature = "python")]
fn main() {
    panic!("This is not indented to compile for `python` feature.");
}