Struct RestoreSessionBuilder 

pub struct RestoreSessionBuilder<Counterpart, Request, BlockState = NonBlocking>
where
    Counterpart: HasPeer<Agent>,
    BlockState: SessionBlockState,
{ /* private fields */ }

Stable protocol v1 builder for session/load or session/resume.

Use ConnectionTo::load_session or ConnectionTo::resume_session to construct this builder. Use the matching _from method to send an existing typed request without rebuilding it.

The BlockState parameter mirrors SessionBuilder:

• NonBlocking exposes on_session_start on each concrete operation.
• Blocking, selected with Self::block_task, exposes start_session.

Session routing is acknowledged before the request can reach the peer. Dropping a pending blocking start removes that routing and applies the standard SentRequest drop-time cancellation behavior. Error responses remove the route before later entries in the same transport frame are dispatched.

Implementations

impl<Counterpart, Request> RestoreSessionBuilder<Counterpart, Request, NonBlocking>

where Counterpart: HasPeer<Agent>,

pub fn block_task(self) -> RestoreSessionBuilder<Counterpart, Request, Blocking>

Mark this restore builder as able to block the current task.

Do not use the resulting blocking methods inside a message handler.

impl<Counterpart> RestoreSessionBuilder<Counterpart, LoadSessionRequest>

where Counterpart: HasPeer<Agent>,

pub fn on_session_start<F, Fut>(self, op: F) -> Result<(), Error>

where F: FnOnce(RestoredSession<'static, Counterpart, LoadSessionResponse>) -> Fut + Send + 'static, Fut: Future<Output = Result<(), Error>> + Send,

Restore with session/load in the background and run op once its exact response and active session are available.

This returns immediately and is safe to call from a message handler. Replay notifications can arrive before the response and are retained by the returned session.

impl<Counterpart> RestoreSessionBuilder<Counterpart, ResumeSessionRequest>

where Counterpart: HasPeer<Agent>,

pub fn on_session_start<F, Fut>(self, op: F) -> Result<(), Error>

where F: FnOnce(RestoredSession<'static, Counterpart, ResumeSessionResponse>) -> Fut + Send + 'static, Fut: Future<Output = Result<(), Error>> + Send,

Restore with session/resume in the background and run op once its exact response and active session are available.

This returns immediately and is safe to call from a message handler. The returned session receives subsequent session traffic.

impl<Counterpart> RestoreSessionBuilder<Counterpart, LoadSessionRequest, Blocking>

where Counterpart: HasPeer<Agent>,

pub async fn start_session( self, ) -> Result<RestoredSession<'static, Counterpart, LoadSessionResponse>, Error>

Publish session/load, wait on the current task, and return an ActiveSession together with the exact LoadSessionResponse.

Requires block_task. Dropping this future while it is pending cancels the request and removes the provisional session route.

impl<Counterpart> RestoreSessionBuilder<Counterpart, ResumeSessionRequest, Blocking>

where Counterpart: HasPeer<Agent>,

pub async fn start_session( self, ) -> Result<RestoredSession<'static, Counterpart, ResumeSessionResponse>, Error>

Publish session/resume, wait on the current task, and return an ActiveSession together with the exact ResumeSessionResponse.

Requires block_task. Dropping this future while it is pending cancels the request and removes the provisional session route.

Trait Implementations

impl<Counterpart, Request: Debug, BlockState> Debug for RestoreSessionBuilder<Counterpart, Request, BlockState>

where Counterpart: HasPeer<Agent> + Debug, BlockState: SessionBlockState + Debug,

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

Formats the value using the given formatter.