Struct RecordBuf 

pub struct RecordBuf<'de> { /* private fields */ }

A recording which keeps borrowed data borrowed.

This is like Recording, but atoms that are delivered borrowed (see Sink::borrowed_atom) are recorded as they are and replayed or serialized borrowed, all others are recorded as owned. Strings that the format can lend from the input are not copied, but the buffer cannot outlive the input. The derive uses it to buffer values, which allows types that borrow to be deserialized from buffered values (for instance the fields of internally tagged enums that come before the tag).

Like recordings, record buffers implement Deserialize and Serialize. This makes them useful to pass values from a deserializer to a serializer, for instance to convert them from one format to another (which is what deser-transcode does):

use deser::de::{DeserializeDriver, RecordBuf};
use deser::ser::SerializeDriver;
use deser::Event;

let input = String::from("borrowed");
let mut buf = RecordBuf::new();
{
    let mut driver = DeserializeDriver::from_fn(|state| buf.recorder(state));
    driver.emit(Event::seq_start()).unwrap();
    driver.emit_borrowed(input.as_str()).unwrap();
    driver.emit(Event::SeqEnd).unwrap();
}

let mut events = Vec::new();
SerializeDriver::new(&buf)
    .drive(|event, _state| {
        events.push(event.to_static());
        Ok(())
    })
    .unwrap();
// the length of the sequence is known once it was recorded
assert_eq!(
    events,
    [
        Event::SeqStart(deser::ContainerShape::with_len(1)),
        "borrowed".into(),
        Event::SeqEnd,
    ]
);

Implementations

impl<'de> RecordBuf<'de>

pub fn new() -> RecordBuf<'de>

Creates an empty buffer.

pub fn recorder(&mut self, state: &mut State) -> SinkHandle<'_, 'de>

Returns a sink that records a value into this buffer.

A previously recorded value is discarded.

pub fn capture<'a, F>(then: F, state: &mut State) -> SinkHandle<'a, 'de>

where F: FnOnce(RecordBuf<'de>, &mut State) -> Result<(), Error> + Send + 'a, 'de: 'a,

Returns a sink that records a value and passes the buffer to a callback once the value is complete (see Recording::capture).

pub fn is_empty(&self) -> bool

Returns true if nothing was recorded.

pub fn as_str(&self) -> Option<&str>

Returns the value if the buffer is a single string.

pub fn replay<'a>( &self, sink: SinkHandle<'_, 'a>, state: &mut State, ) -> Result<(), Error>

where 'de: 'a,

Replays the recorded value into a sink.

Atoms that were delivered borrowed are replayed borrowed.

Trait Implementations

impl<'de> Clone for RecordBuf<'de>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RecordBuf<'_>

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

Formats the value using the given formatter.

impl<'de> Default for RecordBuf<'de>

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RecordBuf<'de>

Record buffers deserialize like Recordings but keep borrowed atoms borrowed.

fn deserialize_into<'out>( out: &'out mut Option<Self>, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that deserializes the value into the given slot.

fn expecting() -> Cow<'static, str>

Returns what the value expects, for error messages.

fn deserialize_atom( slot: &mut Slot<T, Self>, atom: Atom<'_>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom into the slot.

fn deserialize_borrowed_atom( slot: &mut Slot<T, Self>, atom: Atom<'de>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom that borrows from the data being deserialized into the slot.

fn describe_type(d: &mut dyn Describe)

Describes the Rust shape of the type.

fn initial_value() -> Option<T>

Provides the value of a missing struct field.

fn deserialize_update<'out>( value: &'out mut T, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that updates an existing value.

impl Serialize for RecordBuf<'_>

Record buffers serialize like Recordings, borrowed atoms are serialized without copying them.

fn serialize<'a>(value: &'a Self, state: &mut State) -> Result<Emit<'a>, Error>

Serializes the value.

fn container_shape(value: &Self) -> ContainerShape

Returns the shape of the value if it’s a map or sequence.

fn is_optional(value: &Self) -> bool

Checks if the value represents an optional value.

fn finish(value: &T, state: &mut State) -> Result<(), Error>

Invoked after the serialization finished.

fn describe(value: &T, d: &mut dyn Describe)

Describes the Rust shape of the value.