Struct Channel 

#[non_exhaustive]
pub struct Channel {
    pub rx: UnboundedReceiver<TransportFrame>,
    pub tx: UnboundedSender<TransportFrame>,
}

A channel endpoint representing one side of a bidirectional JSON-RPC transport.

A channel carries complete TransportFrame values across in-process components and transport adapters. Malformed wire input is an explicit frame; failures while driving a physical transport are returned by that transport’s future.

The unbounded futures::channel::mpsc pair is the intended contract: frames are never dropped and sends never wait, so the transport or component on each side applies its own backpressure. Build a channel from an existing pair with Channel::new and take it apart with Channel::into_parts or by destructuring with ...

Example

let (channel_a, _channel_b) = Channel::duplex();

UntypedRole.builder()
    .name("connection-a")
    .connect_to(channel_a)
    .await?;

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

rx: UnboundedReceiver<TransportFrame>

Receives frames from the counterpart.

tx: UnboundedSender<TransportFrame>

Sends frames to the counterpart.

Implementations

impl Channel

pub fn new( rx: UnboundedReceiver<TransportFrame>, tx: UnboundedSender<TransportFrame>, ) -> Self

Create a channel endpoint that receives frames on rx and sends them on tx.

pub fn into_parts( self, ) -> (UnboundedReceiver<TransportFrame>, UnboundedSender<TransportFrame>)

Split this endpoint into its receiving and sending halves, (rx, tx).

pub fn duplex() -> (Self, Self)

Create a pair of connected channel endpoints.

Frames sent through either endpoint are received by the other endpoint.

pub async fn bridge_with_inspection( left: Self, right: Self, left_to_right: impl FnMut(&RawJsonRpcMessage) -> Result<(), Error> + Send, right_to_left: impl FnMut(&RawJsonRpcMessage) -> Result<(), Error> + Send, ) -> Result<(), Error>

Bridge two endpoints while inspecting every valid message.

Observers are invoked in source order for each valid message. The original frame is forwarded unchanged after inspection.

Errors

Returns an observer error or an error if a destination closes before its source.

Trait Implementations

impl<R: Role> ConnectTo<R> for Channel

async fn connect_to( self, client: impl ConnectTo<R::Counterpart>, ) -> Result<(), Error>

Connect this component to another component.

fn into_channel_and_future(self) -> (Channel, Option<ConnectionDriver>)

Convert this component into a channel endpoint and optional owned driver.

impl Debug for Channel

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

Formats the value using the given formatter.