pub fn new() -> Self {

        Self {

            _phantom: std::marker::PhantomData,

        }

    }

    fn default() -> Self {

        Self::new()

    }

    fn decode(

        &mut self,

        src: &mut bytes::BytesMut,

    ) -> Result<Option<Self::Item>, Self::Error> {

        // check to see if you have at least 4 bytes to figure out the size

        if src.len() < 4 {

            src.reserve(4);

            return Ok(None);

        }

        let Some(mut bytz) = src.get(..4) else {

        let byte_size: u32 = WireFormat::decode(&mut bytz)?;

        if src.len() < byte_size as usize {

        }

        Frame::<P::Request>::decode(&mut src.reader())

            .map(Some)

            .map_err(|_| Error::Custom("()".to_string()))

    }

    fn encode(

        &mut self,

        item: Frame<P::Response>,

        dst: &mut bytes::BytesMut,

    ) -> Result<(), Self::Error> {

        item.encode(&mut dst.writer())

            .map_err(|_| Error::Custom("()".to_string()))

            .map(|_| ())

    }

pub async fn run<T, P>(p: &mut P, mut stream: T) -> Result<(), P::Error>

where

    T: ServiceTransport<P>,

    P: Protocol,

{

    let mut a = pin!(p);

    while let Some(Ok(frame)) = stream.next().await {

        stream.send(a.rpc(frame).await?).await?