Struct Builder 

pub struct Builder<W = Vec<u8>> { /* private fields */ }

A builder for JSON values.

The builder accumulates JSON tokens and any associated payload into an internal byte buffer. Use the add_* methods to push values (or begin_*/end_* to create containers). When finished, call finish to obtain the serialized value.

Implementations

impl Builder<Vec<u8>>

pub fn new() -> Self

Creates a new Builder.

pub fn with_capacity(capacity: usize) -> Self

Creates a new Builder with capacity.

impl<'a> Builder<&'a mut Vec<u8>>

pub fn new(buffer: &'a mut Vec<u8>) -> Self

Creates a new Builder.

impl<W: AsMut<Vec<u8>>> Builder<W>

pub fn add_null(&mut self)

Adds a null value to the builder.

pub fn add_bool(&mut self, v: bool)

Adds a boolean value to the builder.

pub fn add_u64(&mut self, v: u64)

Adds an u64 value to the builder.

pub fn add_i64(&mut self, v: i64)

Adds an i64 value to the builder.

pub fn add_f64(&mut self, v: f64)

Adds an f64 value to the builder.

pub fn add_string(&mut self, v: &str)

Adds a string value to the builder.

pub fn display(&mut self, v: impl Display)

Adds a string value that displays the given value to the builder.

pub fn begin_array(&mut self)

Begins an array.

The caller then needs to push the elements and call end_array to finish the array.

pub fn end_array(&mut self)

Ends an array.

pub fn begin_object(&mut self)

Begins an object.

The caller then needs to push the keys and values in the following order:

key-1, value-1, key-2, value-2 ...

where each key must be a string.

Keys are allowed to be duplicated, but the last value will be used.

Finally end_object must be called to finish the object.

pub fn end_object(&mut self)

Ends an object.

Panics

Panics if:

• there is an odd number of entries pushed since the paired begin_object.
• any key is not a string.

pub fn add_value(&mut self, value: ValueRef<'_>)

Adds a JSON value to the builder.

pub fn pop(&mut self)

Pops the last value.

pub fn rollback_to(&mut self, checkpoint: &Checkpoint)

Roll back the builder state to the given checkpoint.

This restores the internal buffer and stacks to the sizes recorded in checkpoint, effectively removing any data added after the checkpoint was created.

Only data added after the checkpoint will be removed. If the builder has already popped more items than recorded in the checkpoint, or if the checkpoint does not originate from this builder, the rollback may panic or leave the builder in an inconsistent state.

The following sequence is invalid and may panic for future manipulations.

let mut builder = jsonbb::Builder::<Vec<u8>>::new();
builder.begin_array();
builder.add_u64(1);
let checkpoint = builder.checkpoint();
builder.pop();
builder.add_u64(2);
builder.rollback_to(&checkpoint);

impl<W: AsRef<[u8]>> Builder<W>

pub fn checkpoint(&self) -> Checkpoint

Creates a checkpoint of the current state.

impl Builder<Vec<u8>>

pub fn capacity(&self) -> usize

Returns the capacity of the internal buffer, in bytes.

pub fn finish(self) -> Value

Finishes building.

impl Builder<&mut Vec<u8>>

pub fn finish(self)

Finishes building.

Trait Implementations

impl<W: Clone> Clone for Builder<W>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W> Debug for Builder<W>

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

Formats the value using the given formatter.

impl Default for Builder<Vec<u8>>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, W: AsMut<Vec<u8>>> DeserializeSeed<'de> for &mut Builder<W>

type Value = ()

The type produced by using this seed.

fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>

where D: Deserializer<'de>,

Equivalent to the more common Deserialize::deserialize method, except with some initial piece of data (the seed) passed in.

impl<W: AsMut<Vec<u8>>> SerializeMap for &mut Builder<W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Serialize a map key.

fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Serialize a map value.

fn end(self) -> Result<(), Self::Error>

Finish serializing a map.

fn serialize_entry<K, V>( &mut self, key: &K, value: &V, ) -> Result<(), Self::Error>

where K: Serialize + ?Sized, V: Serialize + ?Sized,

Serialize a map entry consisting of a key and a value.

impl<W: AsMut<Vec<u8>>> SerializeSeq for &mut Builder<W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Serialize a sequence element.

fn end(self) -> Result<(), Self::Error>

Finish serializing a sequence.

impl<W: AsMut<Vec<u8>>> SerializeStruct for &mut Builder<W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_field<T>( &mut self, key: &'static str, value: &T, ) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Serialize a struct field.

fn end(self) -> Result<(), Self::Error>

Finish serializing a struct.

fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error>

Indicate that a struct field has been skipped.

impl<W: AsMut<Vec<u8>>> SerializeStructVariant for &mut Builder<W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_field<T>( &mut self, key: &'static str, value: &T, ) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Serialize a struct variant field.

fn end(self) -> Result<(), Self::Error>

Finish serializing a struct variant.

fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error>

Indicate that a struct variant field has been skipped.

impl<W: AsMut<Vec<u8>>> SerializeTuple for &mut Builder<W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Serialize a tuple element.

fn end(self) -> Result<(), Self::Error>

Finish serializing a tuple.

impl<W: AsMut<Vec<u8>>> SerializeTupleStruct for &mut Builder<W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Serialize a tuple struct field.

fn end(self) -> Result<(), Self::Error>

Finish serializing a tuple struct.

impl<W: AsMut<Vec<u8>>> SerializeTupleVariant for &mut Builder<W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Serialize a tuple variant field.

fn end(self) -> Result<(), Self::Error>

Finish serializing a tuple variant.

impl<W: AsMut<Vec<u8>>> Serializer for &mut Builder<W>

Jsonbb is a data format.

type Ok = ()

The output type produced by this Serializer during successful serialization. Most serializers that produce text or binary output should set Ok = () and serialize into an io::Write or buffer contained within the Serializer instance. Serializers that build in-memory data structures may be simplified by using Ok to propagate the data structure around.

type Error = Error

The error type when some error occurs during serialization.

type SerializeSeq = &mut Builder<W>

Type returned from serialize_seq for serializing the content of the sequence.

type SerializeTuple = &mut Builder<W>

Type returned from serialize_tuple for serializing the content of the tuple.

type SerializeTupleStruct = &mut Builder<W>

Type returned from serialize_tuple_struct for serializing the content of the tuple struct.

type SerializeTupleVariant = &mut Builder<W>

Type returned from serialize_tuple_variant for serializing the content of the tuple variant.

type SerializeMap = &mut Builder<W>

Type returned from serialize_map for serializing the content of the map.

type SerializeStruct = &mut Builder<W>

Type returned from serialize_struct for serializing the content of the struct.

type SerializeStructVariant = &mut Builder<W>

Type returned from serialize_struct_variant for serializing the content of the struct variant.

fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>

Serialize a bool value.

fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>

Serialize an i8 value.

fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>

Serialize an i16 value.

fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>

Serialize an i32 value.

fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>

Serialize an i64 value.

fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>

Serialize an i128 value.

fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>

Serialize a u8 value.

fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>

Serialize a u16 value.

fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>

Serialize a u32 value.

fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>

Serialize a u64 value.

fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>

Serialize a u128 value.

fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>

Serialize an f32 value.

fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>

Serialize an f64 value.

fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>

Serialize a character.

fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>

Serialize a &str.

fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>

Serialize a chunk of raw byte data.

fn serialize_none(self) -> Result<Self::Ok, Self::Error>

Serialize a None value.

fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>

where T: Serialize + ?Sized,

Serialize a Some(T) value.

fn serialize_unit(self) -> Result<Self::Ok, Self::Error>

Serialize a () value.

fn serialize_unit_struct( self, _name: &'static str, ) -> Result<Self::Ok, Self::Error>

Serialize a unit struct like struct Unit or PhantomData<T>.

fn serialize_unit_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result<Self::Ok, Self::Error>

Serialize a unit variant like E::A in enum E { A, B }.

fn serialize_newtype_struct<T>( self, _name: &'static str, value: &T, ) -> Result<Self::Ok, Self::Error>

where T: Serialize + ?Sized,

Serialize a newtype struct like struct Millimeters(u8).

fn serialize_newtype_variant<T>( self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T, ) -> Result<Self::Ok, Self::Error>

where T: Serialize + ?Sized,

Serialize a newtype variant like E::N in enum E { N(u8) }.

fn serialize_seq( self, _len: Option<usize>, ) -> Result<Self::SerializeSeq, Self::Error>

Begin to serialize a variably sized sequence. This call must be followed by zero or more calls to serialize_element, then a call to end.

fn serialize_tuple( self, len: usize, ) -> Result<Self::SerializeTuple, Self::Error>

Begin to serialize a statically sized sequence whose length will be known at deserialization time without looking at the serialized data. This call must be followed by zero or more calls to serialize_element, then a call to end.

fn serialize_tuple_struct( self, _name: &'static str, len: usize, ) -> Result<Self::SerializeTupleStruct, Self::Error>

Begin to serialize a tuple struct like struct Rgb(u8, u8, u8). This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize, ) -> Result<Self::SerializeTupleVariant, Self::Error>

Begin to serialize a tuple variant like E::T in enum E { T(u8, u8) }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_map( self, _len: Option<usize>, ) -> Result<Self::SerializeMap, Self::Error>

Begin to serialize a map. This call must be followed by zero or more calls to serialize_key and serialize_value, then a call to end.

fn serialize_struct( self, _name: &'static str, len: usize, ) -> Result<Self::SerializeStruct, Self::Error>

Begin to serialize a struct like struct Rgb { r: u8, g: u8, b: u8 }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_struct_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize, ) -> Result<Self::SerializeStructVariant, Self::Error>

Begin to serialize a struct variant like E::S in enum E { S { r: u8, g: u8, b: u8 } }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>

where T: ?Sized + Display,

Serialize a string produced by an implementation of Display.

fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>

where I: IntoIterator, <I as IntoIterator>::Item: Serialize,

Collect an iterator as a sequence.

fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>

where K: Serialize, V: Serialize, I: IntoIterator<Item = (K, V)>,

Collect an iterator as a map.

fn is_human_readable(&self) -> bool

Determine whether Serialize implementations should serialize in human-readable form.