Struct Network

pub struct Network<T> { /* private fields */ }

A network of processes. Each process has a mailbox and the set of addresses (senders) it needs to communicate with its neighbors.

Implementations

impl<T> Network<T>

where T: Default + Send + 'static,

pub fn new() -> Self

Examples found in repository

examples/lattice.rs (line 10)

fn main() {
    env_logger::init();

    let mut net = Network::new();

    net.add_process("a", vec!["b", "c"], |senders, _| loop {
        thread::sleep(Duration::from_secs(1));
        for (adj, s) in senders.iter() {
            info!("a is sending to {}", adj);
            s.send(("a".to_string(), ()))
                .expect("shouldn't encounter a closed channel");
        }
    });

    net.add_process("b", vec!["d"], |senders, receiver| loop {
        thread::sleep(Duration::from_secs(1));
        let (sender, _) = receiver
            .recv()
            .expect("shouldn't encounter a closed channel");
        info!("b received from {}", sender);
        for s in senders.values() {
            s.send(("b".to_string(), ()))
                .expect("shouldn't encounter a closed channel");
        }
    });

    net.add_process("c", vec!["d"], |senders, receiver| loop {
        thread::sleep(Duration::from_secs(1));
        let (sender, _) = receiver
            .recv()
            .expect("shouldn't encounter a closed channel");
        info!("c received from {}", sender);
        for s in senders.values() {
            s.send(("c".to_string(), ()))
                .expect("shouldn't encounter a closed channel");
        }
    });

    net.add_process("d", vec![], |_, receiver| loop {
        thread::sleep(Duration::from_secs(1));
        let (sender, _) = receiver
            .recv()
            .expect("shouldn't encounter a closed channel");
        info!("d received from {}", sender);
    });

    net.start_and_wait();
}

pub fn add_process<'a, F>( &'a mut self, name: &'static str, adj: Vec<&'static str>, body: F, )

where F: Fn(HashMap<String, Sender<(String, T)>>, Receiver<(String, T)>) + Send + 'static,

Adding a process to the network takes a name, its neighbors, and a closure which acts as the entire body of this process. I.e., if you want the process to run forever, that loop has to be inside the given closure.

The process’s neighbor’s addresses (the senders) and the process’s mailbox are passed into the closure. The only abstraction provided here is converting the given graph—described the process and its adjacencies—into mailboxes and addresses.

Examples found in repository

examples/lattice.rs (lines 12-19)

fn main() {
    env_logger::init();

    let mut net = Network::new();

    net.add_process("a", vec!["b", "c"], |senders, _| loop {
        thread::sleep(Duration::from_secs(1));
        for (adj, s) in senders.iter() {
            info!("a is sending to {}", adj);
            s.send(("a".to_string(), ()))
                .expect("shouldn't encounter a closed channel");
        }
    });

    net.add_process("b", vec!["d"], |senders, receiver| loop {
        thread::sleep(Duration::from_secs(1));
        let (sender, _) = receiver
            .recv()
            .expect("shouldn't encounter a closed channel");
        info!("b received from {}", sender);
        for s in senders.values() {
            s.send(("b".to_string(), ()))
                .expect("shouldn't encounter a closed channel");
        }
    });

    net.add_process("c", vec!["d"], |senders, receiver| loop {
        thread::sleep(Duration::from_secs(1));
        let (sender, _) = receiver
            .recv()
            .expect("shouldn't encounter a closed channel");
        info!("c received from {}", sender);
        for s in senders.values() {
            s.send(("c".to_string(), ()))
                .expect("shouldn't encounter a closed channel");
        }
    });

    net.add_process("d", vec![], |_, receiver| loop {
        thread::sleep(Duration::from_secs(1));
        let (sender, _) = receiver
            .recv()
            .expect("shouldn't encounter a closed channel");
        info!("d received from {}", sender);
    });

    net.start_and_wait();
}

pub fn start_and_wait(self)

Start the processes in this network. Blocks until all of the processes have finished.

Examples found in repository

examples/lattice.rs (line 53)

fn main() {
    env_logger::init();

    let mut net = Network::new();

    net.add_process("a", vec!["b", "c"], |senders, _| loop {
        thread::sleep(Duration::from_secs(1));
        for (adj, s) in senders.iter() {
            info!("a is sending to {}", adj);
            s.send(("a".to_string(), ()))
                .expect("shouldn't encounter a closed channel");
        }
    });

    net.add_process("b", vec!["d"], |senders, receiver| loop {
        thread::sleep(Duration::from_secs(1));
        let (sender, _) = receiver
            .recv()
            .expect("shouldn't encounter a closed channel");
        info!("b received from {}", sender);
        for s in senders.values() {
            s.send(("b".to_string(), ()))
                .expect("shouldn't encounter a closed channel");
        }
    });

    net.add_process("c", vec!["d"], |senders, receiver| loop {
        thread::sleep(Duration::from_secs(1));
        let (sender, _) = receiver
            .recv()
            .expect("shouldn't encounter a closed channel");
        info!("c received from {}", sender);
        for s in senders.values() {
            s.send(("c".to_string(), ()))
                .expect("shouldn't encounter a closed channel");
        }
    });

    net.add_process("d", vec![], |_, receiver| loop {
        thread::sleep(Duration::from_secs(1));
        let (sender, _) = receiver
            .recv()
            .expect("shouldn't encounter a closed channel");
        info!("d received from {}", sender);
    });

    net.start_and_wait();
}

pub fn start(self)

Start the processes in this network.

Trait Implementations

impl<T: Default> Default for Network<T>

fn default() -> Network<T>

Returns the “default value” for a type.