Trait VirtualTcpSocket

Source

pub trait VirtualTcpSocket:
    VirtualConnectedSocket
    + Debug
    + Send
    + Sync
    + 'static {
    // Required methods
    fn set_opt_time(
        &mut self,
        ty: TimeType,
        timeout: Option<Duration>,
    ) -> Result<()>;
    fn opt_time(&self, ty: TimeType) -> Result<Option<Duration>>;
    fn set_recv_buf_size(&mut self, size: usize) -> Result<()>;
    fn recv_buf_size(&self) -> Result<usize>;
    fn set_send_buf_size(&mut self, size: usize) -> Result<()>;
    fn send_buf_size(&self) -> Result<usize>;
    fn set_nodelay(&mut self, reuse: bool) -> Result<()>;
    fn nodelay(&self) -> Result<bool>;
    fn addr_peer(&self) -> Result<SocketAddr>;
    fn flush(&mut self) -> Result<()>;
    fn shutdown(&mut self, how: Shutdown) -> Result<()>;
}

Required Methods§

Source

fn set_opt_time( &mut self, ty: TimeType, timeout: Option<Duration>, ) -> Result<()>

Sets the timeout for a specific action on the socket

Source

fn opt_time(&self, ty: TimeType) -> Result<Option<Duration>>

Returns one of the previous set timeouts

Source

fn set_recv_buf_size(&mut self, size: usize) -> Result<()>

Sets the receive buffer size which acts as a trottle for how much data is buffered on this side of the pipe

Source

fn recv_buf_size(&self) -> Result<usize>

Size of the receive buffer that holds all data that has not yet been read

Source

fn set_send_buf_size(&mut self, size: usize) -> Result<()>

Sets the size of the send buffer which will hold the bytes of data while they are being sent over to the peer

Source

fn send_buf_size(&self) -> Result<usize>

Size of the send buffer that holds all data that is currently being transmitted.

Source

fn set_nodelay(&mut self, reuse: bool) -> Result<()>

When NO_DELAY is set the data that needs to be transmitted to the peer is sent immediately rather than waiting for a bigger batch of data, this reduces latency but increases encapsulation overhead.

Source

fn nodelay(&self) -> Result<bool>

Indicates if the NO_DELAY flag is set which means that data is immediately sent to the peer without waiting. This reduces latency but increases encapsulation overhead.

Source