Trait Source

pub unsafe trait Source: AsCommunicator {
    // Required method
    fn source_rank(&self) -> Rank;

    // Provided methods
    fn probe_with_tag(&self, tag: Tag) -> Status { ... }
    fn probe(&self) -> Status { ... }
    fn matched_probe_with_tag(&self, tag: Tag) -> (Message, Status) { ... }
    fn matched_probe(&self) -> (Message, Status) { ... }
    fn receive_with_tag<Msg>(&self, tag: Tag) -> (Msg, Status)
       where Msg: Equivalence { ... }
    fn receive<Msg>(&self) -> (Msg, Status)
       where Msg: Equivalence { ... }
    fn receive_into_with_tag<Buf>(&self, buf: &mut Buf, tag: Tag) -> Status
       where Buf: BufferMut + ?Sized { ... }
    fn receive_into<Buf>(&self, buf: &mut Buf) -> Status
       where Buf: BufferMut + ?Sized { ... }
    fn receive_vec_with_tag<Msg>(&self, tag: Tag) -> (Vec<Msg>, Status)
       where Msg: Equivalence { ... }
    fn receive_vec<Msg>(&self) -> (Vec<Msg>, Status)
       where Msg: Equivalence { ... }
    fn immediate_receive_into_with_tag<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a mut Buf,
        tag: Tag,
    ) -> Request<'a, Sc>
       where Buf: 'a + BufferMut + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_receive_into<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a mut Buf,
    ) -> Request<'a, Sc>
       where Buf: 'a + BufferMut + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_receive_with_tag<Msg>(&self, tag: Tag) -> ReceiveFuture<Msg>
       where Msg: Equivalence { ... }
    fn immediate_receive<Msg>(&self) -> ReceiveFuture<Msg>
       where Msg: Equivalence { ... }
    fn immediate_probe_with_tag(&self, tag: Tag) -> Option<Status> { ... }
    fn immediate_probe(&self) -> Option<Status> { ... }
    fn immediate_matched_probe_with_tag(
        &self,
        tag: Tag,
    ) -> Option<(Message, Status)> { ... }
    fn immediate_matched_probe(&self) -> Option<(Message, Status)> { ... }
}

Something that can be used as the source in a point to point receive operation

Examples

• A Process used as a source for a receive operation will receive data only from the identified process.
• A communicator can also be used as a source via the AnyProcess identifier.

Standard section(s)

3.2.3

Required Methods

fn source_rank(&self) -> Rank

Rank that identifies the source

Provided Methods

fn probe_with_tag(&self, tag: Tag) -> Status

Probe a source for incoming messages.

Probe Source &self for incoming messages with a certain tag.

An ordinary probe() returns a Status which allows inspection of the properties of the incoming message, but does not guarantee reception by a subsequent receive() (especially in a multi-threaded set-up). For a probe operation with stronger guarantees, see matched_probe().

Standard section(s)

3.8.1

fn probe(&self) -> Status

Probe a source for incoming messages.

Probe Source &self for incoming messages with any tag.

An ordinary probe() returns a Status which allows inspection of the properties of the incoming message, but does not guarantee reception by a subsequent receive() (especially in a multi-threaded set-up). For a probe operation with stronger guarantees, see matched_probe().

Standard section(s)

3.8.1

fn matched_probe_with_tag(&self, tag: Tag) -> (Message, Status)

Probe a source for incoming messages with guaranteed reception.

Probe Source &self for incoming messages with a certain tag.

A matched_probe() returns both a Status that describes the properties of a pending incoming message and a Message which can and must subsequently be used in a matched_receive() to receive the probed message.

Standard section(s)

3.8.2

fn matched_probe(&self) -> (Message, Status)

Probe a source for incoming messages with guaranteed reception.

Probe Source &self for incoming messages with any tag.

A matched_probe() returns both a Status that describes the properties of a pending incoming message and a Message which can and must subsequently be used in a matched_receive() to receive the probed message.

Standard section(s)

3.8.2

fn receive_with_tag<Msg>(&self, tag: Tag) -> (Msg, Status)

where Msg: Equivalence,

Receive a message containing a single instance of type Msg.

Receive a message from Source &self tagged tag containing a single instance of type Msg.

Standard section(s)

3.2.4

fn receive<Msg>(&self) -> (Msg, Status)

where Msg: Equivalence,

Receive a message containing a single instance of type Msg.

Receive a message from Source &self containing a single instance of type Msg.

Examples

extern crate mpi_fork_fnsp as mpi;
use mpi::traits::*;

let universe = mpi::initialize().unwrap();
let world = universe.world();

let x = world.any_process().receive::<f64>();

Standard section(s)

3.2.4

fn receive_into_with_tag<Buf>(&self, buf: &mut Buf, tag: Tag) -> Status

where Buf: BufferMut + ?Sized,

Receive a message into a Buffer.

Receive a message from Source &self tagged tag into Buffer buf.

Standard section(s)

3.2.4

fn receive_into<Buf>(&self, buf: &mut Buf) -> Status

where Buf: BufferMut + ?Sized,

Receive a message into a Buffer.

Receive a message from Source &self into Buffer buf.

Standard section(s)

3.2.4

Examples found in repository

examples/barrier.rs (line 15)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let receiver_rank = 0;

    if world.rank() == receiver_rank {
        let n = (world.size() - 1) as usize;
        let mut buf = vec![0u64; 2 * n];
        for x in buf[0..n].iter_mut() {
            world.any_process().receive_into(x);
        }
        world.barrier();
        for x in buf[n..2 * n].iter_mut() {
            world.any_process().receive_into(x);
        }
        println!("{:?}", buf);
        assert!(buf[0..n].iter().all(|&x| x == 1));
        assert!(buf[n..2 * n].iter().all(|&x| x == 2));
    } else {
        world.process_at_rank(0).send(&1u64);
        world.barrier();
        world.process_at_rank(0).send(&2u64);
    }
}

examples/immediate_barrier.rs (line 24)

fn main() {
    use mpi::traits::*;
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let size = world.size();
    let receiver_rank = 0;

    if world.rank() == receiver_rank {
        // receiver process
        let n = (size - 1) as usize;
        let mut buf = vec![0u64; 3 * n];
        // receive first 2 * n messages
        for x in buf[0..2 * n].iter_mut() {
            world.any_process().receive_into(x);
        }
        // signal the waiting senders that 2 * n messages have been received
        let breq = world.immediate_barrier();
        // receive remaining n messages
        for x in buf[2 * n..3 * n].iter_mut() {
            world.any_process().receive_into(x);
        }
        println!("{:?}", buf);
        // messages "1" and "2" may be interleaved, but all have to be contained within the first
        // 2 * n slots of the buffer
        assert_eq!(buf[0..2 * n].iter().filter(|&&x| x == 1).count(), n);
        assert_eq!(buf[0..2 * n].iter().filter(|&&x| x == 2).count(), n);
        // the last n slots in the buffer may only contain message "3"
        assert!(buf[2 * n..3 * n].iter().all(|&x| x == 3));
        // clean up the barrier request
        breq.wait();
    } else {
        // sender processes
        // send message "1"
        world.process_at_rank(0).send(&1u64);
        // join barrier, but do not block
        let breq = world.immediate_barrier();
        // send message "2"
        world.process_at_rank(0).send(&2u64);
        // wait for receiver process to receive the first 2 * n messages
        breq.wait();
        // send message "3"
        world.process_at_rank(0).send(&3u64);
    }
}

fn receive_vec_with_tag<Msg>(&self, tag: Tag) -> (Vec<Msg>, Status)

where Msg: Equivalence,

Receive a message containing multiple instances of type Msg into a Vec.

Receive a message from Source &self tagged tag containing multiple instances of type Msg into a Vec.

Standard section(s)

3.2.4

fn receive_vec<Msg>(&self) -> (Vec<Msg>, Status)

where Msg: Equivalence,

Receive a message containing multiple instances of type Msg into a Vec.

Receive a message from Source &self containing multiple instances of type Msg into a Vec.

Examples

See examples/send_receive.rs

Standard section(s)

3.2.4

Examples found in repository

examples/readme.rs (line 24)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let size = world.size();
    let rank = world.rank();

    let next_rank = if rank + 1 < size { rank + 1 } else { 0 };
    let previous_rank = if rank > 0 { rank - 1 } else { size - 1 };

    let msg = vec![rank, 2 * rank, 4 * rank];
    mpi::request::scope(|scope| {
        let _sreq = WaitGuard::from(
            world
                .process_at_rank(next_rank)
                .immediate_send(scope, &msg[..]),
        );

        let (msg, status) = world.any_process().receive_vec();

        println!(
            "Process {} got message {:?}.\nStatus is: {:?}",
            rank, msg, status
        );
        let x = status.source_rank();
        assert_eq!(x, previous_rank);
        assert_eq!(vec![x, 2 * x, 4 * x], msg);

        let root_rank = 0;
        let root_process = world.process_at_rank(root_rank);

        let mut a;
        if world.rank() == root_rank {
            a = vec![2, 4, 8, 16];
            println!("Root broadcasting value: {:?}.", &a[..]);
        } else {
            a = vec![0; 4];
        }
        root_process.broadcast_into(&mut a[..]);
        println!("Rank {} received value: {:?}.", world.rank(), &a[..]);
        assert_eq!(&a[..], &[2, 4, 8, 16]);
    });
}

examples/send_receive.rs (line 32)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let size = world.size();
    let rank = world.rank();

    let next_rank = if rank + 1 < size { rank + 1 } else { 0 };
    let next_process = world.process_at_rank(next_rank);
    let previous_rank = if rank > 0 { rank - 1 } else { size - 1 };
    let previous_process = world.process_at_rank(previous_rank);

    let (msg, status): (Rank, _) = p2p::send_receive(&rank, &previous_process, &next_process);
    println!(
        "Process {} got message {}.\nStatus is: {:?}",
        rank, msg, status
    );
    world.barrier();
    assert_eq!(msg, next_rank);

    if rank > 0 {
        let msg = vec![rank, rank + 1, rank - 1];
        world.process_at_rank(0).send(&msg[..]);
    } else {
        for _ in 1..size {
            let (msg, status) = world.any_process().receive_vec::<Rank>();
            println!(
                "Process {} got long message {:?}.\nStatus is: {:?}",
                rank, msg, status
            );

            let x = status.source_rank();
            let v = vec![x, x + 1, x - 1];
            assert_eq!(v, msg);
        }
    }
    world.barrier();

    let mut x = rank;
    p2p::send_receive_replace_into(&mut x, &next_process, &previous_process);
    assert_eq!(x, previous_rank);
}

fn immediate_receive_into_with_tag<'a, Sc, Buf>( &self, scope: Sc, buf: &'a mut Buf, tag: Tag, ) -> Request<'a, Sc>

where Buf: 'a + BufferMut + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) receive operation.

Initiate receiving a message matching tag into buf.

Standard section(s)

3.7.2

fn immediate_receive_into<'a, Sc, Buf>( &self, scope: Sc, buf: &'a mut Buf, ) -> Request<'a, Sc>

where Buf: 'a + BufferMut + ?Sized, Sc: Scope<'a>,

Initiate an immediate (non-blocking) receive operation.

Initiate receiving a message into buf.

Examples

See examples/immediate.rs

Standard section(s)

3.7.2

Examples found in repository

examples/buffered.rs (line 28)

fn main() {
    let mut universe = mpi::initialize().unwrap();
    // Try to attach a buffer.
    universe.set_buffer_size(BUFFER_SIZE);
    // Check buffer size matches.
    assert_eq!(universe.buffer_size(), BUFFER_SIZE);
    // Try to detach the buffer.
    universe.detach_buffer();
    // Attach another buffer.
    universe.set_buffer_size(BUFFER_SIZE);

    let world = universe.world();

    let x = vec![std::f32::consts::PI; 1024];
    let mut y = vec![0.0; 1024];
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(
            world
                .any_process()
                .immediate_receive_into(scope, &mut y[..]),
        );
        world.this_process().buffered_send(&x[..]);
    });
    assert_eq!(x, y);
}

examples/ready_send.rs (line 26)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let size = world.size();
    let rank = world.rank();

    if rank > 0 {
        let msg = rank as u8;
        world.barrier();
        world.process_at_rank(0).ready_send(&msg);
    } else {
        let mut v = vec![0u8; (size - 1) as usize];
        mpi::request::scope(|scope| {
            let reqs = v
                .iter_mut()
                .zip(1..)
                .map(|(x, i)| {
                    world
                        .process_at_rank(i as Rank)
                        .immediate_receive_into(scope, x)
                })
                .collect::<Vec<_>>();
            world.barrier();
            for req in reqs {
                req.wait();
            }
        });
        println!("Got message: {:?}", v);
        assert!(v.iter().zip(1..).all(|(x, i)| i == *x as usize));
    }
}

examples/wait_any.rs (line 36)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        if world.rank() == 0 {
            let mut requests = Vec::new();
            for i in 1..world.size() {
                requests.push(
                    world
                        .process_at_rank(i)
                        .immediate_synchronous_send(scope, &x),
                );
            }

            println!("World size {}", world.size());
            while let Some((index, _status)) = mpi::request::wait_any(&mut requests) {
                println!("Request with index {} completed", index);
            }
            println!("All requests completed");
        } else {
            let secs = time::Duration::from_secs(world.rank() as u64);

            thread::sleep(secs);

            let rreq = world.any_process().immediate_receive_into(scope, &mut y);
            rreq.wait();
            println!("Process {} received data", world.rank());
        }
    });
}

examples/immediate.rs (line 17)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        let mut sreq = world.this_process().immediate_send(scope, &x);
        let rreq = world.any_process().immediate_receive_into(scope, &mut y);
        rreq.wait();
        loop {
            match sreq.test() {
                Ok(_) => {
                    break;
                }
                Err(req) => {
                    sreq = req;
                }
            }
        }
    });
    assert_eq!(x, y);

    y = 0.0;
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(world.any_process().immediate_receive_into(scope, &mut y));
        let _sreq = WaitGuard::from(world.this_process().immediate_ready_send(scope, &x));
    });
    assert_eq!(x, y);

    assert!(world.any_process().immediate_probe().is_none());
    assert!(world.any_process().immediate_matched_probe().is_none());

    y = 0.0;
    mpi::request::scope(|scope| {
        let _sreq: WaitGuard<_> = world
            .this_process()
            .immediate_synchronous_send(scope, &x)
            .into();
        let preq = world.any_process().immediate_matched_probe();
        assert!(preq.is_some());
        let (msg, _) = preq.unwrap();
        let _rreq: WaitGuard<_> = msg.immediate_matched_receive_into(scope, &mut y).into();
    });
    assert_eq!(x, y);

    let future = world.any_process().immediate_receive();
    world.this_process().send(&x);
    let (msg, _) = future.get();
    assert_eq!(x, msg);

    let future = world.any_process().immediate_receive();
    let res = future.r#try();
    assert!(res.is_err());
    let mut future = res.err().unwrap();
    world.this_process().send(&x);
    loop {
        match future.r#try() {
            Ok((msg, _)) => {
                assert_eq!(x, msg);
                break;
            }
            Err(f) => {
                future = f;
            }
        }
    }

    mpi::request::scope(|scope| {
        let sreq = world.this_process().immediate_send(scope, &x);
        sreq.cancel();
        sreq.wait();

        let _sreq = CancelGuard::from(world.this_process().immediate_receive_into(scope, &mut y));
    });
}

fn immediate_receive_with_tag<Msg>(&self, tag: Tag) -> ReceiveFuture<Msg>

where Msg: Equivalence,

Initiate a non-blocking receive operation for messages matching tag tag.

Standard section(s)

3.7.2

fn immediate_receive<Msg>(&self) -> ReceiveFuture<Msg>

where Msg: Equivalence,

Initiate a non-blocking receive operation.

Examples

See examples/immediate.rs

Standard section(s)

3.7.2

Examples found in repository

examples/immediate.rs (line 55)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        let mut sreq = world.this_process().immediate_send(scope, &x);
        let rreq = world.any_process().immediate_receive_into(scope, &mut y);
        rreq.wait();
        loop {
            match sreq.test() {
                Ok(_) => {
                    break;
                }
                Err(req) => {
                    sreq = req;
                }
            }
        }
    });
    assert_eq!(x, y);

    y = 0.0;
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(world.any_process().immediate_receive_into(scope, &mut y));
        let _sreq = WaitGuard::from(world.this_process().immediate_ready_send(scope, &x));
    });
    assert_eq!(x, y);

    assert!(world.any_process().immediate_probe().is_none());
    assert!(world.any_process().immediate_matched_probe().is_none());

    y = 0.0;
    mpi::request::scope(|scope| {
        let _sreq: WaitGuard<_> = world
            .this_process()
            .immediate_synchronous_send(scope, &x)
            .into();
        let preq = world.any_process().immediate_matched_probe();
        assert!(preq.is_some());
        let (msg, _) = preq.unwrap();
        let _rreq: WaitGuard<_> = msg.immediate_matched_receive_into(scope, &mut y).into();
    });
    assert_eq!(x, y);

    let future = world.any_process().immediate_receive();
    world.this_process().send(&x);
    let (msg, _) = future.get();
    assert_eq!(x, msg);

    let future = world.any_process().immediate_receive();
    let res = future.r#try();
    assert!(res.is_err());
    let mut future = res.err().unwrap();
    world.this_process().send(&x);
    loop {
        match future.r#try() {
            Ok((msg, _)) => {
                assert_eq!(x, msg);
                break;
            }
            Err(f) => {
                future = f;
            }
        }
    }

    mpi::request::scope(|scope| {
        let sreq = world.this_process().immediate_send(scope, &x);
        sreq.cancel();
        sreq.wait();

        let _sreq = CancelGuard::from(world.this_process().immediate_receive_into(scope, &mut y));
    });
}

fn immediate_probe_with_tag(&self, tag: Tag) -> Option<Status>

Asynchronously probe a source for incoming messages.

Asynchronously probe Source &self for incoming messages with a certain tag.

Like Probe but returns a None immediately if there is no incoming message to be probed.

Standard section(s)

3.8.1

fn immediate_probe(&self) -> Option<Status>

Asynchronously probe a source for incoming messages.

Asynchronously probe Source &self for incoming messages with any tag.

Like Probe but returns a None immediately if there is no incoming message to be probed.

Standard section(s)

3.8.1

Examples found in repository

examples/immediate.rs (line 39)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        let mut sreq = world.this_process().immediate_send(scope, &x);
        let rreq = world.any_process().immediate_receive_into(scope, &mut y);
        rreq.wait();
        loop {
            match sreq.test() {
                Ok(_) => {
                    break;
                }
                Err(req) => {
                    sreq = req;
                }
            }
        }
    });
    assert_eq!(x, y);

    y = 0.0;
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(world.any_process().immediate_receive_into(scope, &mut y));
        let _sreq = WaitGuard::from(world.this_process().immediate_ready_send(scope, &x));
    });
    assert_eq!(x, y);

    assert!(world.any_process().immediate_probe().is_none());
    assert!(world.any_process().immediate_matched_probe().is_none());

    y = 0.0;
    mpi::request::scope(|scope| {
        let _sreq: WaitGuard<_> = world
            .this_process()
            .immediate_synchronous_send(scope, &x)
            .into();
        let preq = world.any_process().immediate_matched_probe();
        assert!(preq.is_some());
        let (msg, _) = preq.unwrap();
        let _rreq: WaitGuard<_> = msg.immediate_matched_receive_into(scope, &mut y).into();
    });
    assert_eq!(x, y);

    let future = world.any_process().immediate_receive();
    world.this_process().send(&x);
    let (msg, _) = future.get();
    assert_eq!(x, msg);

    let future = world.any_process().immediate_receive();
    let res = future.r#try();
    assert!(res.is_err());
    let mut future = res.err().unwrap();
    world.this_process().send(&x);
    loop {
        match future.r#try() {
            Ok((msg, _)) => {
                assert_eq!(x, msg);
                break;
            }
            Err(f) => {
                future = f;
            }
        }
    }

    mpi::request::scope(|scope| {
        let sreq = world.this_process().immediate_send(scope, &x);
        sreq.cancel();
        sreq.wait();

        let _sreq = CancelGuard::from(world.this_process().immediate_receive_into(scope, &mut y));
    });
}

fn immediate_matched_probe_with_tag( &self, tag: Tag, ) -> Option<(Message, Status)>

Asynchronously probe a source for incoming messages with guaranteed reception.

Asynchronously probe Source &self for incoming messages with a certain tag.

Like MatchedProbe but returns a None immediately if there is no incoming message to be probed.

Standard section(s)

3.8.2

fn immediate_matched_probe(&self) -> Option<(Message, Status)>

Asynchronously probe a source for incoming messages with guaranteed reception.

Asynchronously probe Source &self for incoming messages with any tag.

Like MatchedProbe but returns a None immediately if there is no incoming message to be probed.

Standard section(s)

3.8.2

Examples found in repository

examples/immediate.rs (line 40)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    let x = std::f32::consts::PI;
    let mut y: f32 = 0.0;

    mpi::request::scope(|scope| {
        let mut sreq = world.this_process().immediate_send(scope, &x);
        let rreq = world.any_process().immediate_receive_into(scope, &mut y);
        rreq.wait();
        loop {
            match sreq.test() {
                Ok(_) => {
                    break;
                }
                Err(req) => {
                    sreq = req;
                }
            }
        }
    });
    assert_eq!(x, y);

    y = 0.0;
    mpi::request::scope(|scope| {
        let _rreq = WaitGuard::from(world.any_process().immediate_receive_into(scope, &mut y));
        let _sreq = WaitGuard::from(world.this_process().immediate_ready_send(scope, &x));
    });
    assert_eq!(x, y);

    assert!(world.any_process().immediate_probe().is_none());
    assert!(world.any_process().immediate_matched_probe().is_none());

    y = 0.0;
    mpi::request::scope(|scope| {
        let _sreq: WaitGuard<_> = world
            .this_process()
            .immediate_synchronous_send(scope, &x)
            .into();
        let preq = world.any_process().immediate_matched_probe();
        assert!(preq.is_some());
        let (msg, _) = preq.unwrap();
        let _rreq: WaitGuard<_> = msg.immediate_matched_receive_into(scope, &mut y).into();
    });
    assert_eq!(x, y);

    let future = world.any_process().immediate_receive();
    world.this_process().send(&x);
    let (msg, _) = future.get();
    assert_eq!(x, msg);

    let future = world.any_process().immediate_receive();
    let res = future.r#try();
    assert!(res.is_err());
    let mut future = res.err().unwrap();
    world.this_process().send(&x);
    loop {
        match future.r#try() {
            Ok((msg, _)) => {
                assert_eq!(x, msg);
                break;
            }
            Err(f) => {
                future = f;
            }
        }
    }

    mpi::request::scope(|scope| {
        let sreq = world.this_process().immediate_send(scope, &x);
        sreq.cancel();
        sreq.wait();

        let _sreq = CancelGuard::from(world.this_process().immediate_receive_into(scope, &mut y));
    });
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, C> Source for AnyProcess<'a, C>

where C: 'a + Communicator,

impl<'a, C> Source for Process<'a, C>

where C: 'a + Communicator,