Struct Channel 

pub struct Channel<'a> { /* private fields */ }

Implementations

impl<'a> Channel<'a>

pub fn join(&self) -> Result<()>

Join this channel

Examples found in repository

examples/sender.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new librecast context
    let librecast = Librecast::new()?;

    // Create a channel using the builder pattern
    let channel = librecast
        .channel_builder()
        .name("example-channel")
        .enable_raptorq()
        .enable_loopback()
        .build()?;

    // Join the channel
    channel.join()?;

    // Rate limits the channel to 100Mbps
    channel.rate_limit(104857600)?;

    // Send a message
    let data = b"Hello, Librecast!";
    channel
        .send(data)
        .expect("Failed to send data on the channel");

    // Leave the channel
    channel.leave()?;

    Ok(())
}

examples/receiver.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new librecast context
    let librecast = Librecast::new()?;

    // Create a channel using the builder pattern
    let channel = librecast
        .channel_builder()
        .name("example-channel")
        .enable_raptorq()
        .build()?;

    // Join the channel
    channel.join()?;

    // Receive a message
    let mut buffer = vec![0u8; 1024]; // Buffer to hold received data
    match channel.receive(&mut buffer) {
        Ok(size) => {
            // Process the received data
            let received_data = &buffer[..size];
            println!(
                "Received data: {:?}",
                String::from_utf8_lossy(received_data)
            );
        }
        Err(e) => {
            eprintln!("Failed to receive data: {}", e);
        }
    }

    // Leave the channel
    channel.leave()?;

    Ok(())
}

pub fn leave(&self) -> Result<()>

Leave this channel

Examples found in repository

examples/sender.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new librecast context
    let librecast = Librecast::new()?;

    // Create a channel using the builder pattern
    let channel = librecast
        .channel_builder()
        .name("example-channel")
        .enable_raptorq()
        .enable_loopback()
        .build()?;

    // Join the channel
    channel.join()?;

    // Rate limits the channel to 100Mbps
    channel.rate_limit(104857600)?;

    // Send a message
    let data = b"Hello, Librecast!";
    channel
        .send(data)
        .expect("Failed to send data on the channel");

    // Leave the channel
    channel.leave()?;

    Ok(())
}

examples/receiver.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new librecast context
    let librecast = Librecast::new()?;

    // Create a channel using the builder pattern
    let channel = librecast
        .channel_builder()
        .name("example-channel")
        .enable_raptorq()
        .build()?;

    // Join the channel
    channel.join()?;

    // Receive a message
    let mut buffer = vec![0u8; 1024]; // Buffer to hold received data
    match channel.receive(&mut buffer) {
        Ok(size) => {
            // Process the received data
            let received_data = &buffer[..size];
            println!(
                "Received data: {:?}",
                String::from_utf8_lossy(received_data)
            );
        }
        Err(e) => {
            eprintln!("Failed to receive data: {}", e);
        }
    }

    // Leave the channel
    channel.leave()?;

    Ok(())
}

pub fn rate_limit(&self, limit: u32) -> Result<()>

Rate-limit sending 104857600 for 100 Mbps

Examples found in repository

examples/sender.rs (line 22)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new librecast context
    let librecast = Librecast::new()?;

    // Create a channel using the builder pattern
    let channel = librecast
        .channel_builder()
        .name("example-channel")
        .enable_raptorq()
        .enable_loopback()
        .build()?;

    // Join the channel
    channel.join()?;

    // Rate limits the channel to 100Mbps
    channel.rate_limit(104857600)?;

    // Send a message
    let data = b"Hello, Librecast!";
    channel
        .send(data)
        .expect("Failed to send data on the channel");

    // Leave the channel
    channel.leave()?;

    Ok(())
}

pub fn send(&self, data: &[u8]) -> Result<()>

Send some multicast data

Examples found in repository

examples/sender.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new librecast context
    let librecast = Librecast::new()?;

    // Create a channel using the builder pattern
    let channel = librecast
        .channel_builder()
        .name("example-channel")
        .enable_raptorq()
        .enable_loopback()
        .build()?;

    // Join the channel
    channel.join()?;

    // Rate limits the channel to 100Mbps
    channel.rate_limit(104857600)?;

    // Send a message
    let data = b"Hello, Librecast!";
    channel
        .send(data)
        .expect("Failed to send data on the channel");

    // Leave the channel
    channel.leave()?;

    Ok(())
}

pub fn receive(&self, buffer: &mut [u8]) -> Result<usize>

Receive some multicast data

Examples found in repository

examples/receiver.rs (line 22)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new librecast context
    let librecast = Librecast::new()?;

    // Create a channel using the builder pattern
    let channel = librecast
        .channel_builder()
        .name("example-channel")
        .enable_raptorq()
        .build()?;

    // Join the channel
    channel.join()?;

    // Receive a message
    let mut buffer = vec![0u8; 1024]; // Buffer to hold received data
    match channel.receive(&mut buffer) {
        Ok(size) => {
            // Process the received data
            let received_data = &buffer[..size];
            println!(
                "Received data: {:?}",
                String::from_utf8_lossy(received_data)
            );
        }
        Err(e) => {
            eprintln!("Failed to receive data: {}", e);
        }
    }

    // Leave the channel
    channel.leave()?;

    Ok(())
}

Trait Implementations

impl<'a> Drop for Channel<'a>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.