Struct round_based::async_runtime::AsyncProtocol [−][src]
async-runtime
only.Executes protocol in async environment using tokio backend
In the most simple setting, you just provide protocol initial state, stream of incoming messages, and sink for outgoing messages, and you’re able to easily execute it:
fn incoming() -> impl Stream<Item=Result<Msg<M>, Error>> + FusedStream + Unpin { // ... } fn outgoing() -> impl Sink<Msg<M>, Error=Error> + Unpin { // ... } let output: State::Output = AsyncProtocol::new(State::initial(), incoming(), outgoing()) .run().await?; // ...
Note that if the protocol has some cryptographical assumptions on transport channel (e.g. messages should be ecrypted, authenticated), then stream and sink must meet these assumptions (e.g. encrypt, authenticate messages)
Implementations
impl<SM, I, O> AsyncProtocol<SM, I, O, BlindWatcher>
[src]
pub fn new(state: SM, incoming: I, outgoing: O) -> Self
[src]
Constructs new protocol executor from initial state, channels of incoming and outgoing messages
impl<SM, I, O, W> AsyncProtocol<SM, I, O, W>
[src]
pub fn set_watcher<WR>(self, watcher: WR) -> AsyncProtocol<SM, I, O, WR>
[src]
Sets new protocol watcher
Protocol watcher looks after protocol execution. See list of observable events in ProtocolWatcher trait.
Default watcher: BlindWatcher that does nothing with received events. For development purposes it’s convenient to pick StderrWatcher.
impl<SM, I, O, IErr, W> AsyncProtocol<SM, I, O, W> where
SM: StateMachine,
SM::Err: Send,
SM: Send + 'static,
I: Stream<Item = Result<Msg<SM::MessageBody>, IErr>> + FusedStream + Unpin,
O: Sink<Msg<SM::MessageBody>> + Unpin,
W: ProtocolWatcher<SM>,
[src]
SM: StateMachine,
SM::Err: Send,
SM: Send + 'static,
I: Stream<Item = Result<Msg<SM::MessageBody>, IErr>> + FusedStream + Unpin,
O: Sink<Msg<SM::MessageBody>> + Unpin,
W: ProtocolWatcher<SM>,
pub async fn run(
&mut self
) -> Result<SM::Output, Error<SM::Err, IErr, O::Error>>
[src]
&mut self
) -> Result<SM::Output, Error<SM::Err, IErr, O::Error>>
Executes the protocol
Returns protocol output or first occurred critical error
Auto Trait Implementations
impl<SM, I, O, W> RefUnwindSafe for AsyncProtocol<SM, I, O, W> where
I: RefUnwindSafe,
O: RefUnwindSafe,
SM: RefUnwindSafe,
W: RefUnwindSafe,
I: RefUnwindSafe,
O: RefUnwindSafe,
SM: RefUnwindSafe,
W: RefUnwindSafe,
impl<SM, I, O, W> Send for AsyncProtocol<SM, I, O, W> where
I: Send,
O: Send,
SM: Send,
W: Send,
I: Send,
O: Send,
SM: Send,
W: Send,
impl<SM, I, O, W> Sync for AsyncProtocol<SM, I, O, W> where
I: Sync,
O: Sync,
SM: Sync,
W: Sync,
I: Sync,
O: Sync,
SM: Sync,
W: Sync,
impl<SM, I, O, W> Unpin for AsyncProtocol<SM, I, O, W> where
I: Unpin,
O: Unpin,
SM: Unpin,
W: Unpin,
I: Unpin,
O: Unpin,
SM: Unpin,
W: Unpin,
impl<SM, I, O, W> UnwindSafe for AsyncProtocol<SM, I, O, W> where
I: UnwindSafe,
O: UnwindSafe,
SM: UnwindSafe,
W: UnwindSafe,
I: UnwindSafe,
O: UnwindSafe,
SM: UnwindSafe,
W: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,