Struct Receiver 

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

Implementations

impl<T> Receiver<T>

pub fn try_recv(&self) -> Result<T, TryRecvError>

Non-blocking receive, returns Err(TryRecvError::Empty) if buffer was empty; will continue to receive pending messages from a disconnected channel until it is empty, at which point further calls to this function will return Err(TryRecvError::Disconnected).

Examples found in repository

examples/sequential-try_recv.rs (line 34)

fn recvfun (receiver : unbounded_spsc::Receiver <Mystruct>) {
  let start_time = std::time::SystemTime::now();
  loop {
    match receiver.try_recv() {
      Ok  (_m) => (),
      Err (unbounded_spsc::TryRecvError::Empty) => (),
      Err (unbounded_spsc::TryRecvError::Disconnected) => break
    }
  }
  let duration = start_time.elapsed().unwrap();
  let duration_ns
    = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos() as u64;
  println!("recvfun duration ns: {duration_ns}");
  println!("recvfun ns per message: {}", duration_ns / MESSAGE_COUNT);
  println!("buffer ending capacity: {}", receiver.capacity());
}

examples/parallel-try_recv.rs (line 49)

fn recvfun (receiver : unbounded_spsc::Receiver <Mystruct>) {
  RECEIVER_STARTED.store (true, std::sync::atomic::Ordering::SeqCst);
  // spin until sender is started
  while !SENDER_STARTED.load (std::sync::atomic::Ordering::SeqCst) {
    std::hint::spin_loop()
  }
  let start_time = std::time::SystemTime::now();
  loop {
    match receiver.try_recv() {
      Ok  (_m) => (),
      Err (unbounded_spsc::TryRecvError::Empty) => (),
      Err (unbounded_spsc::TryRecvError::Disconnected) => break
    }
  }
  let duration = start_time.elapsed().unwrap();
  let duration_ns
    = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos() as u64;
  println!("recvfun duration ns: {duration_ns}");
  println!("recvfun ns per message: {}", duration_ns / MESSAGE_COUNT);
  println!("buffer ending capacity: {}", receiver.capacity());
}

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

Block waiting if no messages are pending in the buffer.

Examples found in repository

examples/sequential-recv.rs (line 33)

fn recvfun (receiver : unbounded_spsc::Receiver <Mystruct>) {
  let start_time = std::time::SystemTime::now();
  while let Ok (_m) = receiver.recv() { }
  let duration = start_time.elapsed().unwrap();
  let duration_ns = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos()
    as u64;
  println!("recvfun duration ns: {duration_ns}");
  println!("recvfun ns per message: {}", duration_ns / MESSAGE_COUNT);
  println!("buffer ending capacity: {}", receiver.capacity());
}

examples/parallel-recv.rs (line 48)

fn recvfun (receiver : unbounded_spsc::Receiver <Mystruct>) {
  RECEIVER_STARTED.store (true, std::sync::atomic::Ordering::SeqCst);
  // spin until sender is started
  while !SENDER_STARTED.load (std::sync::atomic::Ordering::SeqCst) {
    std::hint::spin_loop()
  }
  let start_time = std::time::SystemTime::now();
  while let Ok (_m) = receiver.recv() { }
  let duration = start_time.elapsed().unwrap();
  let duration_ns = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos()
    as u64;
  println!("recvfun duration ns: {duration_ns}");
  println!("recvfun ns per message: {}", duration_ns / MESSAGE_COUNT);
  println!("buffer ending capacity: {}", receiver.capacity());
}

pub fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError>

pub const fn iter(&self) -> Iter<'_, T>

pub const fn try_iter(&self) -> TryIter<'_, T>

pub fn capacity(&self) -> usize

Examples found in repository

examples/sequential-recv.rs (line 39)

fn recvfun (receiver : unbounded_spsc::Receiver <Mystruct>) {
  let start_time = std::time::SystemTime::now();
  while let Ok (_m) = receiver.recv() { }
  let duration = start_time.elapsed().unwrap();
  let duration_ns = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos()
    as u64;
  println!("recvfun duration ns: {duration_ns}");
  println!("recvfun ns per message: {}", duration_ns / MESSAGE_COUNT);
  println!("buffer ending capacity: {}", receiver.capacity());
}

examples/sequential-try_recv.rs (line 45)

fn recvfun (receiver : unbounded_spsc::Receiver <Mystruct>) {
  let start_time = std::time::SystemTime::now();
  loop {
    match receiver.try_recv() {
      Ok  (_m) => (),
      Err (unbounded_spsc::TryRecvError::Empty) => (),
      Err (unbounded_spsc::TryRecvError::Disconnected) => break
    }
  }
  let duration = start_time.elapsed().unwrap();
  let duration_ns
    = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos() as u64;
  println!("recvfun duration ns: {duration_ns}");
  println!("recvfun ns per message: {}", duration_ns / MESSAGE_COUNT);
  println!("buffer ending capacity: {}", receiver.capacity());
}

examples/parallel-recv.rs (line 54)

fn recvfun (receiver : unbounded_spsc::Receiver <Mystruct>) {
  RECEIVER_STARTED.store (true, std::sync::atomic::Ordering::SeqCst);
  // spin until sender is started
  while !SENDER_STARTED.load (std::sync::atomic::Ordering::SeqCst) {
    std::hint::spin_loop()
  }
  let start_time = std::time::SystemTime::now();
  while let Ok (_m) = receiver.recv() { }
  let duration = start_time.elapsed().unwrap();
  let duration_ns = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos()
    as u64;
  println!("recvfun duration ns: {duration_ns}");
  println!("recvfun ns per message: {}", duration_ns / MESSAGE_COUNT);
  println!("buffer ending capacity: {}", receiver.capacity());
}

examples/parallel-try_recv.rs (line 60)

fn recvfun (receiver : unbounded_spsc::Receiver <Mystruct>) {
  RECEIVER_STARTED.store (true, std::sync::atomic::Ordering::SeqCst);
  // spin until sender is started
  while !SENDER_STARTED.load (std::sync::atomic::Ordering::SeqCst) {
    std::hint::spin_loop()
  }
  let start_time = std::time::SystemTime::now();
  loop {
    match receiver.try_recv() {
      Ok  (_m) => (),
      Err (unbounded_spsc::TryRecvError::Empty) => (),
      Err (unbounded_spsc::TryRecvError::Disconnected) => break
    }
  }
  let duration = start_time.elapsed().unwrap();
  let duration_ns
    = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos() as u64;
  println!("recvfun duration ns: {duration_ns}");
  println!("recvfun ns per message: {}", duration_ns / MESSAGE_COUNT);
  println!("buffer ending capacity: {}", receiver.capacity());
}

Trait Implementations

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.

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.

impl<'a, T> IntoIterator for &'a 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?

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

Creates an iterator from a value.

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?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.