Struct LateBoundHandle 

pub struct LateBoundHandle { /* private fields */ }

A handle that can be set once after creation.

This solves the chicken-and-egg problem in bidirectional proxying where:

1. You need to pass a dispatcher to connect() for reverse-direction calls
2. But the dispatcher needs a handle that’s only available after accept_framed()

Example

// Create the late-bound handle (empty initially)
let late_bound = LateBoundHandle::new();

// Pass a forwarder using this handle to connect()
let virtual_conn = handle.connect(
    metadata,
    Some(Box::new(LateBoundForwarder::new(late_bound.clone()))),
).await?;

// Accept the other connection to get its handle
let (browser_handle, driver) = accept_framed(transport, config, dispatcher).await?;

// NOW bind the handle - any incoming calls will be forwarded
late_bound.set(browser_handle);

Implementations

impl LateBoundHandle

pub fn new() -> Self

Create a new unbound handle.

pub fn set(&self, handle: ConnectionHandle)

Bind the handle to a connection. Can only be called once.

Panics

Panics if called more than once.

pub fn get(&self) -> Option<&ConnectionHandle>

Try to get the bound handle, if set.

Trait Implementations

impl Clone for LateBoundHandle

fn clone(&self) -> LateBoundHandle

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for LateBoundHandle

fn default() -> Self

Returns the “default value” for a type.