Struct respite::RespReader

pub struct RespReader<Inner: AsyncRead + Unpin> { /* private fields */ }

A wrapper for AsyncRead to allow reading a RESP stream, mainly in three ways.

• Read each frame
• Read values, possibly made up of multiple frames
• Read requests like a Redis server

Implementations

impl<Inner: AsyncRead + Unpin> RespReader<Inner>

pub fn new(inner: Inner, config: RespConfig) -> Self

Create a new RespReader from a byte stream and a RespConfig.

pub async fn requests<F>(&mut self, f: F)

where F: FnMut(RespRequest),

Call f for each RespRequest received on this stream.

let input = "*2\r\n$1\r\na\r\n$1\r\nb\r\n".as_bytes();
let mut reader = RespReader::new(input, RespConfig::default());
let mut requests = Vec::new();

reader.requests(|request| { requests.push(request); }).await;

assert!(matches!(requests[0], RespRequest::Argument(_)));
assert!(matches!(requests[1], RespRequest::Argument(_)));
assert!(matches!(requests[2], RespRequest::End));

pub fn value<'life_self, 'async_recursion>( &'life_self mut self ) -> Pin<Box<dyn Future<Output = Result<Option<RespValue>, RespError>> + 'async_recursion>>

where 'life_self: 'async_recursion,

Read the next RespValue from the stream.

let input = "$3\r\nhi!\r\n".as_bytes();
let mut reader = RespReader::new(input, RespConfig::default());
let frame = reader.value().await.unwrap();
assert_eq!(frame, Some(RespValue::String("hi!".into())));

pub async fn frame(&mut self) -> Result<Option<RespFrame>, RespError>

Read the next RespFrame from the stream.

let input = "$3\r\nhi!\r\n".as_bytes();
let mut reader = RespReader::new(input, RespConfig::default());
let frame = reader.frame().await.unwrap();
assert_eq!(frame, Some(RespFrame::BlobString("hi!".into())));

Trait Implementations

impl<Inner: Debug + AsyncRead + Unpin> Debug for RespReader<Inner>

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

Formats the value using the given formatter.