use std::io::{self, Read, Write};
use calandria::Readiness;
use mio::{Registry, Token, event::Source};
use super::{TcpTransport, tcp::TransportPhase};
use crate::{
RegisteredTransport, SlotTransport, TcpSocketPolicy, TransportBudget, TransportError,
TransportPressure, TransportProgress,
};
impl Read for TcpTransport {
fn read(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
self.stream.read(buffer)
}
}
impl Write for TcpTransport {
fn write(&mut self, buffer: &[u8]) -> io::Result<usize> {
self.stream.write(buffer)
}
fn flush(&mut self) -> io::Result<()> {
self.stream.flush()
}
}
impl SlotTransport for TcpTransport {
fn drive_establishment(
&mut self,
policy: TcpSocketPolicy,
_budget: TransportBudget,
) -> Result<TransportProgress, TransportError> {
match self.phase {
TransportPhase::Connecting => self.complete_connect(),
TransportPhase::NoDelay => self.apply_no_delay(policy),
TransportPhase::Keepalive => self.apply_keepalive(policy),
TransportPhase::Open => Ok(TransportProgress::IDLE),
}
}
fn drive_transport(
&mut self,
_budget: TransportBudget,
) -> Result<TransportProgress, TransportError> {
Ok(TransportProgress::IDLE)
}
fn begin_shutdown(
&mut self,
_budget: TransportBudget,
) -> Result<TransportProgress, TransportError> {
Ok(TransportProgress::operation())
}
fn can_establish(&self) -> bool {
Self::can_establish(self)
}
fn has_transport_work(&self) -> bool {
false
}
fn is_shutdown_complete(&self) -> bool {
true
}
fn is_open(&self) -> bool {
Self::is_open(self)
}
fn can_read(&self) -> bool {
Self::can_read(self)
}
fn can_write(&self) -> bool {
Self::can_write(self)
}
fn desired_interest(&self, has_writes: bool) -> calandria::Interest {
Self::desired_interest(self, has_writes)
}
fn pressure(&self) -> TransportPressure {
TransportPressure::ZERO
}
fn pressure_limit(&self) -> crate::TransportLimits {
crate::TransportLimits::new(calandria::RetainedBytes::ZERO)
}
fn clear_read(&mut self) {
Self::clear_read(self);
}
fn clear_write(&mut self) {
Self::clear_write(self);
}
}
impl RegisteredTransport for TcpTransport {
fn observe_readiness(&mut self, readiness: Readiness) {
self.observe(readiness);
}
}
impl Source for TcpTransport {
fn register(
&mut self,
registry: &Registry,
token: Token,
interests: mio::Interest,
) -> io::Result<()> {
self.stream.register(registry, token, interests)
}
fn reregister(
&mut self,
registry: &Registry,
token: Token,
interests: mio::Interest,
) -> io::Result<()> {
self.stream.reregister(registry, token, interests)
}
fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
self.stream.deregister(registry)
}
}