Struct mesh_channel::Sender

pub struct Sender<T>(/* private fields */);

The sending half of a channel returned by channel.

Implementations

impl<T: MeshField> Sender<T>

pub fn upcast<U: MeshField>(self) -> Sender<U>

where Self: Upcast<Sender<U>>,

Upcasts this sender to one that can send values whose encoding is a subset of T’s.

let (send, mut recv) = channel::<Option<mesh_node::message::Message>>();
let send = send.upcast::<Option<(u32, u16)>>();
send.send(None);
send.send(Some((5, 4)));
assert!(block_on(recv.recv()).unwrap().is_none());
assert!(block_on(recv.recv()).unwrap().is_some());

pub fn force_downcast<U: MeshField>(self) -> Sender<U>

where Sender<U>: Upcast<Self>,

Downcasts this sender to one that can send values whose encoding is a superset of T’s.

Although this is memory safe, it can cause the receiver to see message decoding errors.

impl<T: 'static + Send> Sender<T>

pub fn send(&self, msg: T)

Sends a message to the associated Receiver<T>.

Does not return a result, so messages can be silently dropped if the receiver has closed or failed. To detect such conditions, include another sender in the message you send so that the receiving thread can use it to send a response.

let (send, mut recv) = channel();
let (response_send, mut response_recv) = channel::<bool>();
send.send((3, response_send));
let (val, response_send) = recv.recv().await.unwrap();
response_send.send(val == 3);
assert_eq!(response_recv.recv().await.unwrap(), true);

pub fn bridge(self, recv: Receiver<T>)

Bridges this and recv together, consuming both self and recv. This makes it so that anything sent to recv will be directly sent to this channel’s peer receiver, without a separate relay step. This includes any data that was previously sent but not yet consumed.

let (outer_send, inner_recv) = channel::<u32>();
let (inner_send, mut outer_recv) = channel::<u32>();

outer_send.send(2);
inner_send.send(1);
inner_send.bridge(inner_recv);
assert_eq!(outer_recv.try_recv().unwrap(), 1);
assert_eq!(outer_recv.try_recv().unwrap(), 2);

pub fn is_closed(&self) -> bool

Returns whether the receiving side of the channel is known to be closed (or failed).

This is useful to determine if there is any point in sending more data via this port. But even if this returns false messages may still fail to reach the destination.

Trait Implementations

impl<T> Debug for Sender<T>

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

Formats the value using the given formatter.

impl<T> DefaultEncoding for Sender<T>

where T: MeshField,

type Encoding = TableEncoder

The encoding to use for the serialization.

impl<T: MeshField> From<Port> for Sender<T>

fn from(port: Port) -> Self

Converts to this type from the input type.

impl<T: MeshField> From<Sender<T>> for Port

fn from(v: Sender<T>) -> Self

Converts to this type from the input type.

impl<T: 'static + Send> RpcSend for Sender<T>

type Message = T

The message type for this sender.

fn send_rpc(&self, message: T)

Send an RPC request.

fn call<F, I, R>(&self, f: F, input: I) -> OneshotReceiver<R>

where F: FnOnce(Rpc<I, R>) -> Self::Message, R: 'static + Send,

Issues a request and returns a channel to receive the result.

fn call_failable<F, I, T, E>( &self, f: F, input: I, ) -> RpcResultReceiver<Result<T, E>>

where F: FnOnce(Rpc<I, Result<T, E>>) -> Self::Message, T: 'static + Send, E: 'static + Send,

Issues a request and returns an object to receive the result.

impl<'encoding, T> StructDecodeMetadata<'encoding, Resource> for Sender<T>

where T: MeshField,

const DECODERS: &'static [ErasedDecoderEntry] = _

The list of decoder vtables.

impl<T> StructEncodeMetadata<Resource> for Sender<T>

where T: MeshField,

const ENCODERS: &'static [ErasedEncoderEntry] = _

The list of encoder vtables.

impl<T> StructMetadata for Sender<T>

where T: MeshField,

const NUMBERS: &'static [u32] = _

The field numbers for each field.

const OFFSETS: &'static [usize] = _

The byte offset to each field within the struct.

impl<T: MeshField, U: MeshField> Downcast<Sender<U>> for Sender<T>

where (U,): Downcast<(T,)>,