Struct Resp3

pub struct Resp3 { /* private fields */ }

Available on crate features codec and resp3 only.

A framed codec for complete and streaming/chunked RESP3 frames.

use futures::{SinkExt, StreamExt};
use redis_protocol::{
  codec::{resp3_encode_command, Resp3},
  resp3::types::{BytesFrame, Resp3Frame, RespVersion},
};
use tokio::net::TcpStream;
use tokio_util::codec::Framed;

// send `HELLO 3 AUTH foo bar` then `GET foo`
async fn example() {
  let socket = TcpStream::connect("127.0.0.1:6379").await.unwrap();
  let mut framed = Framed::new(socket, Resp3::default());

  let hello = BytesFrame::Hello {
    version: RespVersion::RESP3,
    auth:    Some(("foo".into(), "bar".into())),
    setname: None,
  };
  // or use the shorthand, but this likely only works for simple use cases
  let get_foo = resp3_encode_command("GET foo");

  // `Framed` implements both `Sink` and `Stream`
  let _ = framed.send(hello).await.unwrap();
  let response = framed.next().await.unwrap();
  println!("HELLO response: {:?}", response);

  let _ = framed.send(get_foo).await.unwrap();
  let response = framed.next().await.unwrap();
  println!("GET foo: {:?}", response);
}

Implementations

impl Resp3

pub fn new(int_as_blobstring: bool) -> Resp3

Create a new codec with the provided flag describing whether the encoder logic should send integers as blob strings.

Trait Implementations

impl Debug for Resp3

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

Formats the value using the given formatter.

impl Decoder for Resp3

type Error = RedisProtocolError

The type of unrecoverable frame decoding errors.

type Item = BytesFrame

The type of decoded frames.

fn decode( &mut self, src: &mut BytesMut, ) -> Result<Option<Self::Item>, Self::Error>

Attempts to decode a frame from the provided buffer of bytes.

fn decode_eof( &mut self, buf: &mut BytesMut, ) -> Result<Option<Self::Item>, Self::Error>

A default method available to be called when there are no more bytes available to be read from the underlying I/O.

fn framed<T>(self, io: T) -> Framed<T, Self>

where T: AsyncRead + AsyncWrite, Self: Sized,

Provides a Stream and Sink interface for reading and writing to this Io object, using Decode and Encode to read and write the raw data.

impl Default for Resp3

fn default() -> Resp3

Returns the “default value” for a type.

impl Encoder<BorrowedFrame<'_>> for Resp3

type Error = RedisProtocolError

The type of encoding errors.

fn encode( &mut self, item: BorrowedFrame<'_>, dst: &mut BytesMut, ) -> Result<(), Self::Error>

Encodes a frame into the buffer provided.

impl Encoder<BytesFrame> for Resp3

type Error = RedisProtocolError

The type of encoding errors.

fn encode( &mut self, item: Resp3Frame, dst: &mut BytesMut, ) -> Result<(), Self::Error>

Encodes a frame into the buffer provided.