Struct kf_socket::InnerKfStream

pub struct InnerKfStream<S>(_);

inner kf stream which is generic over stream

Implementations

impl<S> InnerKfStream<S> where
    S: AsyncRead + AsyncWrite + Unpin, 

pub fn get_mut_tcp_stream(
    &mut self
) -> &mut SplitStream<Framed<Compat<S>, KfCodec>>

pub fn request_stream<R>(
    &mut self
) -> impl Stream<Item = Result<RequestMessage<R>, KfSocketError>> + '_ where
    RequestMessage<R>: KfDecoder + Debug, 

as server, get stream of request coming from client

pub async fn next_request_item<'_, R>(
    &'_ mut self
) -> Option<Result<RequestMessage<R>, KfSocketError>> where
    RequestMessage<R>: KfDecoder + Debug, 

as server, get next request from client

pub async fn next_response<'_, '_, R>(
    &'_ mut self,
    req_msg: &'_ RequestMessage<R>
) -> Result<ResponseMessage<R::Response>, KfSocketError> where
    R: Request, 

as client, get next response from server

pub fn api_stream<R, A>(
    &mut self
) -> impl Stream<Item = Result<R, KfSocketError>> + '_ where
    R: KfRequestMessage<ApiKey = A>,
    A: KfDecoder + Debug, 

as server, get api request (PublicRequest, InternalRequest, etc)

pub async fn next_api_item<'_, R, A>(
    &'_ mut self
) -> Option<Result<R, KfSocketError>> where
    R: KfRequestMessage<ApiKey = A>,
    A: KfDecoder + Debug, 

pub fn response_stream<'a, R>(
    &'a mut self,
    req_msg: RequestMessage<R>
) -> impl Stream<Item = R::Response> + 'a where
    R: Request, 

Trait Implementations

impl<S: Debug> Debug for InnerKfStream<S>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<S> From<SplitStream<Framed<Compat<S>, KfCodec>>> for InnerKfStream<S>

fn from(stream: SplitStream<Framed<Compat<S>, KfCodec>>) -> Self

Performs the conversion.