async-transmit

Async trait for transmitting data to peers

async-transmit crate provides Transmit trait which allows value to be transmit asynchronously.

This crate relies on async-trait, the original definition of the Transmit trait is:

use async_trait::async_trait;

#[async_trait]
pub trait Transmit<I, E> {
    async fn transmit(&mut self, item: I) -> Result<(), E>
    where
        I: 'async_trait;
}

So use #[async_trait] to when implement Transmit like:

use async_transmit::*;
use async_trait::async_trait;

struct VoidTransmitter {}

#[async_trait]
impl<I, E> Transmit<I, E> for VoidTransmitter
where
    I: Send,
{
    async fn transmit(&mut self, item: I) -> Result<(), E>
    where
        I: 'async_trait,
    {
        // Do Nothing
        Ok(())
    }
}

With async-std/async-channel

If you'd like to play with async_std::channel::Sender or async_channel::Sender, use with-async-channel feature like:

[dependencies.async-transmit]
version = "0.1.0"
features = ["with-async-channel"]

Then you can use transmit() method through Transmit trait on the sender like:

use async_transmit::*;

let (mut s, r) = async_channel::unbounded::<&'static str>();

s.transmit("Hello").await?;
s.transmit("World").await?;
drop(s);
assert_eq!(Some("Hello"), r.recv().await.ok());
assert_eq!(Some("World"), r.recv().await.ok());
assert_eq!(None, r.recv().await.ok());

With tokio

If you'd like to play with tokio::sync::mpsc::Sender or tokio::sync::mpsc::UnboundedSender, use with-tokio feature like:

[dependencies.async-transmit]
version = "0.1.0"
features = ["with-tokio"]

Then you can use transmit() method through Transmit trait on the sender like:

use async_transmit::*;

let (mut s, mut r) = tokio::sync::mpsc::unbounded_channel::<&'static str>();

s.transmit("Hello").await?;
s.transmit("World").await?;
drop(s);
assert_eq!(Some("Hello"), r.recv().await);
assert_eq!(Some("World"), r.recv().await);
assert_eq!(None, r.recv().await);

With futures-rs

If you'd like to play with futures::sink::Sink, use with-sink feature like:

[dependencies.async-transmit]
version = "0.1.0"
features = ["with-sink"]

Then you can use Transmit::from_sink() to create a wrapper object which implements Transmit trait like:

use async_transmit::*;
use futures::prelude::*;

let (s, mut r) = futures::channel::mpsc::unbounded::<&'static str>();
let mut s = Transmit::from_sink(s);

s.transmit("Hello").await?;
s.transmit("World").await?;
drop(s);
assert_eq!(Some("Hello"), r.next().await);
assert_eq!(Some("World"), r.next().await);
assert_eq!(None, r.next().await);

License