Struct edelcrantz::Connection

pub struct Connection<OneWay: Msg, Request: Msg, Response: Msg> { /* fields omitted */ }

Implementations

impl<OneWay: Msg, Request: Msg, Response: Msg> Connection<OneWay, Request, Response>

A connection encapsulates logic for sending and receiving a particular vocabulary of messages: one-way messages, requests, and responses. The message types may be different or all the same, and may have internal structure or be enums that have further meaning to the caller: all the connection knows is that messages of the request type will be responded-to by messages of the response type, and messages of the one-way type will not be responded to.

pub fn new<RW: AsyncReadWrite>(rw: RW) -> Self

pub fn enqueue_oneway(&mut self, oneway: OneWay) -> Result<(), Error>

Enqueue a OneWay message for sending.

pub fn enqueue_request(
    &mut self,
    req: Request
) -> impl Future<Output = Result<Response, Error>> + 'static

Enqueue a Request message for sending, and return a future that will be filled in when the response arrives.

pub async fn advance<ServeRequest, FutureResponse, ServeOneWay, '_>(
    &'_ mut self,
    srv_req: ServeRequest,
    srv_ow: ServeOneWay
) -> Result<(), Error> where
    ServeRequest: FnOnce(Request) -> FutureResponse,
    FutureResponse: Future<Output = Response> + Send + 'static,
    ServeOneWay: FnOnce(OneWay), 

Take the next available step on this connection. Either:

• Sending an enqueued envelope.
• Resolving and enqueueing the output of a request's service routine future.
• Receiving an envelope and transferring it to either a service routine or a response future created by Connection::enqueue_request.

Callers should supply a srv_req function to service request envelopes by issuing futures, and a srv_ow function to service one-way envelopes.