Struct DynSender 

pub struct DynSender<A, W = ()> { /* private fields */ }

A wrapper around a Box<dyn DynSends> that allows for type-checked conversions.

Any sender can be converted into a DynSender, as long as the protocol it sends implements DynFromInto and marker traits AsSet. This conversion is type-checked, so that it is impossible to create DynSenders that send messages not accepted by the protocol.

Sending

A DynSender automatically implements Sends<M> for all messages M accepted by the protocol. This means that you can just use a DynSender instead of a statically typed sender in most cases. If you need to send a message that is not accepted by the protocol, you can use the dyn_{...}-send methods, which return an error if the message is not accepted.

Generics

The parameter A specifies the accepted messages of the dynamic sender. It can be specified using the Set or the DynSender macros:

• DynSender<Set![]> == DynSender![]
• DynSender<Set![Msg1, Msg2]> == DynSender![Msg1, Msg2]

Unchecked methods

The unchecked methods, not marked unsafe, allow creating of DynSenders that send messages not accepted by the protocol. Only use these methods if you are sure that the protocol accepts the messages you send. If you are not sure, use the try_transform methods instead, which return an error if the protocol does not accept the messages.

Implementations

impl<A, W> DynSender<A, W>

pub fn new<S>(sender: S) -> Self

where S: SendsProtocol + DynSends<With = W>, A: SubsetOf<S::Protocol>,

Create a new DynSender from a statically typed sender.

pub fn new_unchecked<S>(sender: S) -> Self

where S: DynSends<With = W>,

Create a new DynSender from a statically typed sender, without checking if the protocol accepts the messages.

pub fn transform<A2>(self) -> DynSender<A2, W>

where A2: SubsetOf<A>,

Transform the DynSender into a DynSender that accepts a subset of the messages.

pub fn try_transform<A2>(self) -> Result<DynSender<A2, W>, Self>

where A2: Members, W: 'static, A: 'static,

Attempt to transform the DynSender into a DynSender that accepts a subset of the messages, failing if the protocol does not accept the messages.

pub fn transform_unchecked<A2>(self) -> DynSender<A2, W>

Transform the DynSender into a DynSender that accepts a subset of the messages, without checking if the protocol accepts the messages.

pub fn from_boxed_unchecked(sender: Box<dyn DynSends<With = W>>) -> Self

Convert a Box<dyn DynSends> into a DynSender, without checking if the protocol accepts the messages.

pub fn into_boxed_sender(self) -> Box<dyn DynSends<With = W>>

Convert into a Box<dyn DynSends>.

pub fn downcast_ref<S>(&self) -> Option<&S>

where S: IsSender<With = W> + 'static, W: 'static,

Downcast the inner sender to a statically typed sender.

Trait Implementations

impl<A, W: 'static> Clone for DynSender<A, W>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A, W: Debug> Debug for DynSender<A, W>

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

Formats the value using the given formatter.

impl<A, W> DynSends for DynSender<A, W>

where A: 'static, W: 'static,

fn dyn_send_boxed_msg_with( &self, msg: BoxedMsg<Self::With>, ) -> BoxFuture<'_, Result<(), DynSendError<BoxedMsg<Self::With>>>>

fn dyn_send_boxed_msg_blocking_with( &self, msg: BoxedMsg<Self::With>, ) -> Result<(), DynSendError<BoxedMsg<Self::With>>>

fn dyn_try_send_boxed_msg_with( &self, msg: BoxedMsg<Self::With>, ) -> Result<(), DynTrySendError<BoxedMsg<Self::With>>>

fn members(&self) -> &'static [TypeId]

fn clone_boxed(&self) -> Box<dyn DynSends<With = Self::With>>

fn as_any(&self) -> &dyn Any

impl<A, W> IsSender for DynSender<A, W>

type With = W

The value that must be passed along when sending a message.

fn is_closed(&self) -> bool

Returns true if the channel is closed.

fn capacity(&self) -> Option<usize>

Returns the capacity of the channel, if it is bounded.

fn len(&self) -> usize

Returns the number of messages in the channel.

fn receiver_count(&self) -> usize

Returns the number of receivers in the channel.

fn sender_count(&self) -> usize

Returns the number of senders in the channel.

impl<A, W, M> Sends<M> for DynSender<A, W>

where A: Contains<M>, M: Send + 'static, W: Send + 'static,

fn send_msg_with( this: &Self, msg: M, with: Self::With, ) -> impl Future<Output = Result<(), SendError<(M, Self::With)>>> + Send

fn try_send_msg_with( this: &Self, msg: M, with: Self::With, ) -> Result<(), TrySendError<(M, Self::With)>>

fn send_msg_blocking_with( this: &Self, msg: M, with: Self::With, ) -> Result<(), SendError<(M, Self::With)>>