Struct rubble::l2cap::L2CAPStateTx

pub struct L2CAPStateTx<'a, M: ChannelMapper, P: Producer> {
    l2cap: &'a mut L2CAPState<M>,
    tx: &'a mut P,
}

An L2CAPState with the ability to transmit packets.

Derefs to the underlying L2CAPState.

Fields

l2cap: &'a mut L2CAPState<M>

tx: &'a mut P

Implementations

impl<'a, M: ChannelMapper, P: Producer> L2CAPStateTx<'a, M, P>

pub fn process_start(&mut self, message: &[u8]) -> Consume<()>

Process the start of a new L2CAP message (or a complete, unfragmented message).

If the incoming message is unfragmented, it will be forwarded to the protocol listening on the addressed channel, and a response may be sent.

pub fn process_cont(&mut self, _data: &[u8]) -> Consume<()>

Process continuation of an L2CAP message.

This is not yet implemented and will always panic.

fn dispatch(&mut self, channel: Channel, payload: &[u8]) -> Consume<()>

Dispatches a fully reassembled L2CAP message to the protocol listening on the addressed channel.

pub fn att(&mut self) -> Option<AttributeServerTx<'_, M::AttributeProvider>>

Prepares for sending data using the Attribute Protocol.

This will reserve sufficient space in the outgoing PDU buffer to send any ATT PDU, and then return an AttributeServerTx instance that can be used to initiate an ATT-specific procedure.

Returns None if there’s not enough space in the TX packet queue to send an ATT PDU. If that happens, calling this method again at a later time (after the Link-Layer had time to transmit more packets) might succeed.

Methods from Deref<Target = L2CAPState<M>>

pub fn tx<'a, P: Producer>(
    &'a mut self,
    tx: &'a mut P
) -> L2CAPStateTx<'a, M, P>

Gives this instance the ability to transmit packets.

pub fn channel_mapper(&mut self) -> &mut M

Provides mutable access to the underlying ChannelMapper.

Trait Implementations

impl<'a, M: ChannelMapper, P: Producer> Deref for L2CAPStateTx<'a, M, P>

type Target = L2CAPState<M>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, M: ChannelMapper, P: Producer> DerefMut for L2CAPStateTx<'a, M, P>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.