Struct pipe_channel::Receiver

pub struct Receiver<T> { /* fields omitted */ }

The receiving half of a channel.

Methods

impl<T> Receiver<T>

pub fn recv(&mut self) -> Result<T, RecvError>

Receive data sent by the corresponding Sender.

This will block until a value is actually sent, if none is already.

Errors

If the corresponding Sender is already dropped (or gets dropped during the wait), this method will return Err(RecvError).

Examples

Success:

use std::thread;
use pipe_channel::*;

let (mut tx, mut rx) = channel();
let handle = thread::spawn(move || {
    tx.send(35).unwrap();
    tx.send(42).unwrap();
});
assert_eq!(rx.recv().unwrap(), 35);
assert_eq!(rx.recv().unwrap(), 42);
handle.join().unwrap();

Failure:

use pipe_channel::*;
use std::sync::mpsc::RecvError;
use std::mem::drop;

let (tx, mut rx) = channel::<i32>();
drop(tx);
assert_eq!(rx.recv(), Err(RecvError));

Important traits for Iter<'a, T>

impl<'a, T: 'a> Iterator for Iter<'a, T> type Item = T;

pub fn iter(&mut self) -> Iter<T>

Get an iterator over data sent through the channel.

Examples

use pipe_channel::*;
use std::mem::drop;

let (mut tx, mut rx) = channel();
for i in 0..1024 {
    tx.send(i).unwrap();
}
drop(tx);

for (i, j) in rx.iter().take(10).zip(0..10) {
    assert_eq!(i, j);
}
let v1: Vec<_> = rx.into_iter().collect();
let v2: Vec<_> = (10..1024).collect();
assert_eq!(v1, v2);

Trait Implementations

impl<T> AsRawFd for Receiver<T>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<T> Debug for Receiver<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T> Drop for Receiver<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> FromRawFd for Receiver<T>

unsafe fn from_raw_fd(fd: RawFd) -> Self

Constructs a new instance of Self from the given raw file descriptor.

impl<T> IntoIterator for Receiver<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

Important traits for IntoIter<T>

impl<T> Iterator for IntoIter<T> type Item = T;

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<'a, T: 'a> IntoIterator for &'a mut Receiver<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

Important traits for Iter<'a, T>

impl<'a, T: 'a> Iterator for Iter<'a, T> type Item = T;

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<T> IntoRawFd for Receiver<T>

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.

impl<T: Send> Send for Receiver<T>