Struct `SelectedOperation`

struct SelectedOperation<'a> { ... }

A selected operation that needs to be completed.

To complete the operation, call send or recv.

Panics

Forgetting to complete the operation is an error and might lead to deadlocks. If a SelectedOperation is dropped without completion, a panic occurs.

Implementations

`impl SelectedOperation<'_>`

fn index(self: &Self) -> usize

Returns the index of the selected operation.

Examples

use crossbeam_channel::{bounded, Select};

let (s1, r1) = bounded::<()>(0);
let (s2, r2) = bounded::<()>(0);
let (s3, r3) = bounded::<()>(1);

let mut sel = Select::new();
let oper1 = sel.send(&s1);
let oper2 = sel.recv(&r2);
let oper3 = sel.send(&s3);

// Only the last operation is ready.
let oper = sel.select();
assert_eq!(oper.index(), 2);
assert_eq!(oper.index(), oper3);

// Complete the operation.
oper.send(&s3, ()).unwrap();

fn send<T>(self: Self, s: &Sender<T>, msg: T) -> Result<(), SendError<T>>

Completes the send operation.

The passed Sender reference must be the same one that was used in Select::send when the operation was added.

Panics

Panics if an incorrect Sender reference is passed.

Examples

use crossbeam_channel::{bounded, Select, SendError};

let (s, r) = bounded::<i32>(0);
drop(r);

let mut sel = Select::new();
let oper1 = sel.send(&s);

let oper = sel.select();
assert_eq!(oper.index(), oper1);
assert_eq!(oper.send(&s, 10), Err(SendError(10)));

fn recv<T>(self: Self, r: &Receiver<T>) -> Result<T, RecvError>

Completes the receive operation.

The passed Receiver reference must be the same one that was used in Select::recv when the operation was added.

Panics

Panics if an incorrect Receiver reference is passed.

Examples

use crossbeam_channel::{bounded, Select, RecvError};

let (s, r) = bounded::<i32>(0);
drop(s);

let mut sel = Select::new();
let oper1 = sel.recv(&r);

let oper = sel.select();
assert_eq!(oper.index(), oper1);
assert_eq!(oper.recv(&r), Err(RecvError));

`impl Debug for SelectedOperation<'_>`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl Drop for SelectedOperation<'_>`

fn drop(self: &mut Self)

`impl<'a> Freeze for SelectedOperation<'a>`

`impl<'a> RefUnwindSafe for SelectedOperation<'a>`

`impl<'a> Send for SelectedOperation<'a>`

`impl<'a> Sync for SelectedOperation<'a>`

`impl<'a> Unpin for SelectedOperation<'a>`

`impl<'a> UnsafeUnpin for SelectedOperation<'a>`

`impl<'a> UnwindSafe for SelectedOperation<'a>`

`impl<T> Any for SelectedOperation<'a>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for SelectedOperation<'a>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for SelectedOperation<'a>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for SelectedOperation<'a>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for SelectedOperation<'a>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for SelectedOperation<'a>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for SelectedOperation<'a>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>