Struct StreamedFrame

pub struct StreamedFrame<T: Resp3Frame> {
    pub kind: FrameKind,
    /* private fields */
}

Available on crate feature resp3 only.

A helper struct for reading and managing streaming data types.

use redis_protocol::resp3::decode::streaming;

fn example() {
  // decode the streamed array `[1,2]` one element at a time
  let parts: Vec<Vec<u8>> = vec![
    "*?\r\n".into(),
    ":1\r\n".into(),
    ":2\r\n".into(),
    ".\r\n".into(),
  ];

  let (frame, _) = streaming::decode(&parts[0]).unwrap().unwrap();
  assert!(frame.is_streaming());
  let mut streaming = frame.into_streaming_frame().unwrap();
  println!("Reading streaming {:?}", streaming.kind);

  let (frame, _) = streaming::decode(&parts[1]).unwrap().unwrap();
  assert!(frame.is_complete());
  // add frames to the buffer until we reach the terminating byte sequence
  streaming.add_frame(frame.into_complete_frame().unwrap());

  let (frame, _) = streaming::decode(&parts[2]).unwrap().unwrap();
  assert!(frame.is_complete());
  streaming.add_frame(frame.into_complete_frame().unwrap());

  let (frame, _) = streaming::decode(&parts[3]).unwrap().unwrap();
  assert!(frame.is_complete());
  streaming.add_frame(frame.into_complete_frame().unwrap());

  assert!(streaming.is_finished());
  // convert the buffer into one frame
  let result = streaming.take().unwrap();

  println!("{:?}", result); // OwnedFrame::Array { data: [1, 2], attributes: None }
}

Fields

kind: FrameKind

The data type being streamed.

Implementations

impl<T: Resp3Frame> StreamedFrame<T>

pub fn new(kind: FrameKind) -> Self

Create a new StreamedFrame from the first section of data in a streaming response.

pub fn add_attributes( &mut self, attributes: T::Attributes, ) -> Result<(), RedisProtocolError>

Add the provided attributes to the frame buffer.

pub fn take(&mut self) -> Result<T, RedisProtocolError>

Convert the internal buffer into one frame matching self.kind, clearing the internal buffer.

pub fn add_frame(&mut self, frame: T)

Add a frame to the internal buffer.

pub fn is_finished(&self) -> bool

Whether the last frame represents the terminating sequence at the end of a frame stream.

Trait Implementations

impl<T: Debug + Resp3Frame> Debug for StreamedFrame<T>

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

Formats the value using the given formatter.

impl<T: PartialEq + Resp3Frame> PartialEq for StreamedFrame<T>

fn eq(&self, other: &StreamedFrame<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + Resp3Frame> Eq for StreamedFrame<T>

impl<T: Resp3Frame> StructuralPartialEq for StreamedFrame<T>