Struct aldrin::UnboundSender

pub struct UnboundSender<T: Serialize + ?Sized> { /* private fields */ }

A sender that is not bound to any particular client.

UnboundSenders are used to transfer senders to some other client, typically by returning them from function calls.

When creating a channel the resulting UnclaimedSender can be unbound and sent to another client.

It is worth noting that this type implements Copy and Clone. As such (and because it is not bound to any client), it will not close the sending end of a channel. This is the main difference from UnclaimedSender.

Implementations

impl<T: Serialize + ?Sized> UnboundSender<T>

pub fn bind(self, client: Handle) -> UnclaimedSender<T>

Binds the sender to a client.

See also claim to bind and claim the sender in one step.

Examples

use aldrin::{UnclaimedSender, Sender};

// Assume this sender has been returned from some function call.
// let sender: UnboundSender<u32> = ...

// Bind it to the local client. The explicit type is shown here only for the sake of the
// example.
let sender: UnclaimedSender<u32> = sender.bind(handle.clone());

// Afterwards, it can be claimed.
let sender: Sender<u32> = sender.claim().await?;

pub async fn claim(self, client: Handle) -> Result<Sender<T>, Error>

Binds the sender to a client and claims it.

This function is equivalent to sender.bind(client).claim().

See UnclaimedSender::claim for explanation of the cases in which this function can fail.

Examples

use aldrin::Sender;

// Assume this sender has been returned from some function call.
// let sender: UnboundSender<u32> = ...

// Bind it to the local client and claim it, so that it can immediately be used. The
// explicit type here is given only for the sake of the example.
let sender: Sender<u32> = sender.claim(handle.clone()).await?;

pub fn cast<U: Serialize + ?Sized>(self) -> UnboundSender<U>

Casts the item type to a different type.

Trait Implementations

impl<T: Clone + Serialize + ?Sized> Clone for UnboundSender<T>

fn clone(&self) -> UnboundSender<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Serialize + ?Sized> Debug for UnboundSender<T>

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

Formats the value using the given formatter.

impl<T: Serialize + ?Sized> Deserialize for UnboundSender<T>

fn deserialize( deserializer: Deserializer<'_, '_> ) -> Result<Self, DeserializeError>

impl<T: PartialEq + Serialize + ?Sized> PartialEq for UnboundSender<T>

fn eq(&self, other: &UnboundSender<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Serialize + ?Sized> Serialize for UnboundSender<T>

fn serialize(&self, serializer: Serializer<'_>) -> Result<(), SerializeError>

impl<T: Copy + Serialize + ?Sized> Copy for UnboundSender<T>

impl<T: Eq + Serialize + ?Sized> Eq for UnboundSender<T>

impl<T: Serialize + ?Sized> StructuralPartialEq for UnboundSender<T>