Struct IpcReceiver

pub struct IpcReceiver<T> {
    os_receiver: OsIpcReceiver,
    phantom: PhantomData<T>,
}

Receiving end of a channel using serialized messages.

Examples

Blocking IO

let response = rx.recv().unwrap();
println!("Received data...");

Non-blocking IO

loop {
    match rx.try_recv() {
        Ok(res) => {
            // Do something interesting with your result
            println!("Received data...");
            break;
        },
        Err(_) => {
            // Do something else useful while we wait
            println!("Still waiting...");
        }
    }
}

Embedding Receivers

let (tx, rx) = ipc::channel().unwrap();
let (embedded_tx, embedded_rx) = ipc::channel().unwrap();
// Send the IpcReceiver
tx.send(embedded_rx).unwrap();
// Receive the sent IpcReceiver
let received_rx = rx.recv().unwrap();
// Receive any data sent to the received IpcReceiver
let rx_data = received_rx.recv().unwrap();

Implementation details

Each IpcReceiver is backed by the OS specific implementations of OsIpcReceiver.

Fields

os_receiver: OsIpcReceiver

phantom: PhantomData<T>

Implementations

impl<T> IpcReceiver<T>

where T: for<'de> Deserialize<'de> + Serialize,

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

Blocking receive.

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

Non-blocking receive

pub fn try_recv_timeout(&self, duration: Duration) -> Result<T, TryRecvError>

Blocks for up to the specified duration attempting to receive a message.

This may block for longer than the specified duration if the channel is busy. If your timeout exceeds the duration that your operating system can represent in milliseconds, this may block forever. At the time of writing, the smallest duration that may trigger this behavior is over 24 days.

pub fn to_opaque(self) -> OpaqueIpcReceiver

Erase the type of the channel.

Useful for adding routes to a RouterProxy.

Trait Implementations

impl<T: Debug> Debug for IpcReceiver<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for IpcReceiver<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for IpcReceiver<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.