Struct ChainedNetwork 

pub struct ChainedNetwork<H, T, F> {
    pub handler_can_send: F,
    pub handler: H,
    pub next: T,
}

A network implementation that chains two network implementations together in a composite network interface.

This allows for e.g. a network implementation that can send/receive data to/from both a UDP and a TCP network interface - or - with e.g. further chaining - from all of UDP, TCP and BTP network interfaces.

Fields

handler_can_send: F

handler: H

next: T

Implementations

impl<H, T, F> ChainedNetwork<H, T, F>

pub const fn new( handler_can_send: F, handler: H, next: T, ) -> ChainedNetwork<H, T, F>

Construct a chained handler that works as follows:

• When a packet is about to be send, the handler_can_send function is called with the destination address. If it returns true, the packet is sent via the handler network interface, otherwise it is sent via the next network interface.
• When wait_available is called, the function waits until a packet is available on either network interface.
• When recv_from is called, the function receives a packet from the first network interface that has a packet available.

pub const fn chain<H2, F2>( self, handler_can_send: F2, handler: H2, ) -> ChainedNetwork<H2, ChainedNetwork<H, T, F>, F2>

Chain itself with another handler.

The returned chained handler works as follows:

• When a packet is about to be send, the handler_can_send function is called with the destination address. If it returns true, the packet is sent via the handler network interface, otherwise it is sent via self.
• When wait_available is called, the function waits until a packet is available on either network interface.
• When recv_from is called, the function receives a packet from the first network interface that has a packet available.

Trait Implementations

impl<H, T, F> Clone for ChainedNetwork<H, T, F>

where H: Clone, T: Clone, F: Clone,

fn clone(&self) -> ChainedNetwork<H, T, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H, T, F> NetworkMulticast for ChainedNetwork<H, T, F>

where H: NetworkMulticast, T: NetworkMulticast,

async fn join(&mut self, addr: IpAddr) -> Result<(), Error>

Join a multicast group with the specified address.

async fn leave(&mut self, addr: IpAddr) -> Result<(), Error>

Leave a multicast group with the specified address.

impl<H, T, F> NetworkReceive for ChainedNetwork<H, T, F>

where H: NetworkReceive, T: NetworkReceive,

async fn wait_available(&mut self) -> Result<(), Error>

Wait until a data packet is available to be received.

async fn recv_from( &mut self, buffer: &mut [u8], ) -> Result<(usize, Address), Error>

Receive a single data packet from the network.

impl<H, T, F> NetworkSend for ChainedNetwork<H, T, F>

where H: NetworkSend, T: NetworkSend, F: Fn(&Address) -> bool,

async fn send_to(&mut self, data: &[u8], addr: Address) -> Result<(), Error>

Send a Matter packet represented as a sequence of bytes (data) to the specified address.