reception

This crate provides a way of binding a TCP listener that will accept incoming WebSocket connections. Additionally it provides an abstraction layer (see Client) for serializing and deserializing well-defined models.

Examples

```rust

[derive(Debug)]

struct Model { payload: Vec, }

impl Into> for Model { fn into(self) -> Vec { self.payload } }

impl TryFrom> for Model { type Error = anyhow::Error;

fn try_from(payload: Vec<u8>) -> Result<Self, Self::Error> {
    Ok(Self { payload })
}

}

fn handleclient( client: Client>, Model, Model>, cancellationtoken: CancellationToken, ) -> Result<(), Client>, Model, Model>> { tokio::spawn(async move { let (tx, mut rx) = unboundedchannel(); let mut handle = client .spawnwithcallback(cancellationtoken, move |msg| { tx.send(msg).unwrap(); Ok(()) }) .await;

    while let Some(msg) = rx.recv().await {
        handle.send(msg).await.unwrap();
    }
});
Ok(())

}

[tokio::main(flavor = "current_thread")]

async fn main() -> Result<(), anyhow::Error> { let cancellation_token = CancellationToken::new();

let listener =
    reception::Listener::<Model, Model>::bind(Default::default(), cancellation_token.clone())
        .await?;

let handle = listener
    .spawn_with_callback(cancellation_token.clone(), move |client| {
        handle_client(client, cancellation_token.clone())
    })
    .await;

handle.await??;

Ok(())

} ```

License

See LICENSE.txt file.