Struct embedded_nal_tcpextensions::BufferedStack

pub struct BufferedStack<ST: TcpClientStack, const N: usize>(_);

A wrapper around a TcpStack that provides TcpExactStack

The implementation is comparatively crude: there’s just a per-socket buffer that data is copied into on demand.

Using this is generally not recommended – TCP stacks usually have the buffers in there somewhere, and and “just” need to expose them.

Implementations

impl<ST: TcpClientStack, const N: usize> BufferedStack<ST, N>

pub fn new(wrapped: ST) -> Self

Trait Implementations

impl<ST: TcpClientStack, const N: usize> TcpClientStack for BufferedStack<ST, N>

type TcpSocket = BufferedSocket<ST::TcpSocket, N>

The type returned when we create a new TCP socket

type Error = ST::Error

The type returned when we have an error

fn socket(&mut self) -> Result<Self::TcpSocket, Self::Error>

Open a socket for usage as a TCP client.

fn connect(
    &mut self,
    socket: &mut Self::TcpSocket,
    addr: SocketAddr
) -> Result<(), Error<Self::Error>>

Connect to the given remote host and port.

fn is_connected(
    &mut self,
    socket: &Self::TcpSocket
) -> Result<bool, Self::Error>

Check if this socket is connected

fn send(
    &mut self,
    socket: &mut Self::TcpSocket,
    buffer: &[u8]
) -> Result<usize, Error<Self::Error>>

Write to the stream.

fn receive(
    &mut self,
    socket: &mut Self::TcpSocket,
    buffer: &mut [u8]
) -> Result<usize, Error<Self::Error>>

Receive data from the stream.

fn close(&mut self, socket: Self::TcpSocket) -> Result<(), Self::Error>

Close an existing TCP socket.

impl<ST: TcpClientStack, const N: usize> TcpExactStack for BufferedStack<ST, N>

const RECVBUFLEN: usize

Capacity of the connection’s TCP buffer.

const SENDBUFLEN: usize

Capacity of the connection’s TCP send buffer.

fn receive_exact(
    &mut self,
    socket: &mut Self::TcpSocket,
    buffer: &mut [u8]
) -> Result<(), Self::Error>

Receive data from the stream.

fn send_all(
    &mut self,
    socket: &mut Self::TcpSocket,
    buffer: &[u8]
) -> Result<(), Error<Self::Error>>

Send all this data to the stream.

impl<ST: TcpFullStack, const N: usize> TcpFullStack for BufferedStack<ST, N>

fn bind(
    &mut self,
    socket: &mut Self::TcpSocket,
    port: u16
) -> Result<(), Self::Error>

Create a new TCP socket and bind it to the specified local port.

fn listen(&mut self, socket: &mut Self::TcpSocket) -> Result<(), Self::Error>

Begin listening for connection requests on a previously-bound socket.

fn accept(
    &mut self,
    socket: &mut Self::TcpSocket
) -> Result<(Self::TcpSocket, SocketAddr), Error<Self::Error>>

Accept an active connection request on a listening socket.