encrypted-network-stream/src/stream/traits.rs

//! Stream traits
use super::*;

/// A type that implements both `AsyncWrite` and `AsyncRead`
pub trait AsyncStream: AsyncRead + AsyncWrite{}
impl<T: AsyncRead + AsyncWrite + ?Sized> AsyncStream for T{}

/// A type that can split itself into other types, and combine back from those types.
pub trait Split: Sized
{
    /// First half of the split
    type First;
    /// Second half of the split
    type Second;
    
    fn split(self) -> (Self::First, Self::Second);
    fn unsplit(a: Self::First, b: Self::Second) -> Self;
    
    #[inline(always)] fn split_reverse(self) -> (Self::Second, Self::First)
    {
	let (tx, rx) = self.split();
	(rx, tx)
    }
    #[inline(always)] fn unsplit_reverse(b: Self::Second, a: Self::First) -> Self
    {
	Self::unsplit(a, b)
    }
}
impl<T, U> Split for (T, U)
{
    type First = T;
    type Second = U;
    #[inline(always)] fn split(self) -> (Self::First, Self::Second) {
	self
    }
    #[inline(always)] fn unsplit(a: Self::First, b: Self::Second) -> Self {
	(a, b)
    }
}
//TODO: Add trait `SplitRef` for exchange, I guess?

/// Merges a Read and Write stream in an implementor of `Split`, `AsyncRead`, and `Asyncwrite`.
///
/// Used for internal of `Stream`.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(super) struct Merge<Tx, Rx>(pub Tx, pub Rx);

impl<Tx, Rx> Merge<Tx, Rx>
{
    fn rx(self: Pin<&mut Self>) -> Pin<&mut Rx>
    {
	unsafe {self.map_unchecked_mut(|this| &mut this.1)}
    }
    fn tx(self: Pin<&mut Self>) -> Pin<&mut Tx>
    {
	unsafe {self.map_unchecked_mut(|this| &mut this.0)}
    }
}

impl<Tx, Rx> Split for Merge<Tx, Rx>
{
    type First = Tx;
    type Second = Rx;

    #[inline] fn split(self) -> (Self::First, Self::Second) {
	(self.0, self.1)
    }
    #[inline] fn unsplit(a: Self::First, b: Self::Second) -> Self {
	Self(a, b)
    }
}
impl<Tx, Rx> AsyncWrite for Merge<Tx, Rx>
where Tx: AsyncWrite
{
    #[inline] fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize, io::Error>> {
	self.tx().poll_write(cx, buf)
    }
    #[inline] fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
	self.tx().poll_flush(cx)
    }
    #[inline] fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
	self.tx().poll_flush(cx)
    }
    #[inline] fn poll_write_buf<B: Buf>(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut B) -> Poll<Result<usize, io::Error>>
    where
        Self: Sized, {
	self.tx().poll_write_buf(cx, buf)
    }
}
impl<Tx, Rx> AsyncRead for Merge<Tx, Rx>
where Rx: AsyncRead
{
    #[inline] fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
	self.rx().poll_read(cx, buf)
    }
    #[inline] fn poll_read_buf<B: BufMut>(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut B) -> Poll<io::Result<usize>>
    where
        Self: Sized, {
	self.rx().poll_read_buf(cx, buf)
    }
}

/*
pub(super) enum MaybeFullWrite<'a, S: AsyncWrite>
{
    Full(&'a mut Stream<S>),
    Half(&'a mut WriteHalf<S>),
}

pub(super) enum MaybeFullRead<'a, S: AsyncRead>
{
    Full(&'a mut Stream<S>),
    Half(&'a mut ReadHalf<S>),
}

impl<'a, S: AsyncRead> AsMut<dyn AsyncRead + 'a> for MaybeFullRead<'a, S>
{
    #[inline] fn as_mut(&mut self) -> &mut (dyn AsyncRead + 'a)
    {
	self.as_dyn()
    }
}

impl<'a, S: AsyncWrite> AsMut<dyn AsyncWrite + 'a> for MaybeFullWrite<'a, S>
{
    #[inline] fn as_mut(&mut self) -> &mut (dyn AsyncWrite + 'a)
    {
	self.as_dyn()
    }
}


impl<'a, S: AsyncRead> MaybeFullRead<'a, S>
{
    #[inline(always)] fn as_dyn(&mut self) -> &mut (dyn AsyncRead + 'a)
    {
	match self {
	    Self::Full(f) => f,
	    Self::Half(h) => h,
	}
    }
}
impl<'a, S: AsyncWrite> MaybeFullWrite<'a, S>
{
    #[inline(always)] fn as_dyn(&mut self) -> &mut (dyn AsyncWrite + 'a)
    {
	match self {
	    Self::Full(f) => f,
	    Self::Half(h) => h,
	}
    }
}
*/