Struct cbor_data::CborBuilder

pub struct CborBuilder<'a, O: CborOutput> { /* fields omitted */ }

Builder for a single CBOR value.

Implementations

impl<'a> CborBuilder<'a, WithOutput>

pub fn new() -> Self

Create a builder that writes into its own fresh vector.

pub fn with_scratch_space(v: &'a mut Vec<u8>) -> Self

Create a builder that clears the given vector and writes into it.

You can use this to reuse a scratch space across multiple values being built, e.g. by keeping the same vector in a thread-local variable.

impl<'a> CborBuilder<'a, NoOutput>

pub fn append_to(v: &'a mut Vec<u8>) -> Self

Append the CBOR bytes to the given vector and do not return a separate output value.

let mut v = Vec::new();
let result: () = CborBuilder::append_to(&mut v).write_pos(12, None);

assert_eq!(v, vec![12u8])

impl<'a, O: CborOutput> CborBuilder<'a, O>

pub fn with_max_definite_size(self, max_definite: Option<u64>) -> Self

Configure the limit above which indefinite size encoding will be used.

The default is 255, which is the largest size up to which definite size is at least as compact as indefinite size. Set to 23 to avoid moving bytes around when finishing the array. Set to None to always use indefinite size encoding.

Trait Implementations

impl Default for CborBuilder<'static, WithOutput>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, O: CborOutput> Writer for CborBuilder<'a, O>

type Output = O::Output

fn bytes<T>(&mut self, f: impl FnOnce(&mut Vec<u8>) -> T) -> T

fn to_output(self) -> Self::Output

fn max_definite(&self) -> Option<u64>

Configured maximum array or dict length up to which definite size encoding is used.

fn write_pos(
    self,
    value: u64,
    tags: impl IntoIterator<Item = u64>
) -> Self::Output

Write a unsigned value of up to 64 bits. Tags are from outer to inner.

fn write_neg(
    self,
    value: u64,
    tags: impl IntoIterator<Item = u64>
) -> Self::Output

Write a negative value of up to 64 bits — the represented number is -1 - value. Tags are from outer to inner.

fn write_bytes(
    self,
    value: &[u8],
    tags: impl IntoIterator<Item = u64>
) -> Self::Output

Write the given slice as a definite size byte string. Tags are from outer to inner.

fn write_str(
    self,
    value: &str,
    tags: impl IntoIterator<Item = u64>
) -> Self::Output

Write the given slice as a definite size string. Tags are from outer to inner.

fn write_bool(
    self,
    value: bool,
    tags: impl IntoIterator<Item = u64>
) -> Self::Output

Tags are from outer to inner.

fn write_null(self, tags: impl IntoIterator<Item = u64>) -> Self::Output

Tags are from outer to inner.

fn write_undefined(self, tags: impl IntoIterator<Item = u64>) -> Self::Output

Tags are from outer to inner.

fn write_lit(
    self,
    value: Literal,
    tags: impl IntoIterator<Item = u64>
) -> Self::Output

Write custom literal value — RFC 7049 §2.3 is required reading. Tags are from outer to inner.

fn write_array<F>(
    self,
    tags: impl IntoIterator<Item = u64>,
    f: F
) -> Self::Output where
    F: FnOnce(&mut ArrayWriter<'_>), 

Write a nested array using the given closure that receives an array builder. Tags are from outer to inner.

fn write_array_ret<T, F>(
    self,
    tags: impl IntoIterator<Item = u64>,
    f: F
) -> (Self::Output, T) where
    F: FnOnce(&mut ArrayWriter<'_>) -> T, 

Write a nested array using the given closure that receives an array builder. Tags are from outer to inner.

fn write_dict<F>(
    self,
    tags: impl IntoIterator<Item = u64>,
    f: F
) -> Self::Output where
    F: FnOnce(&mut DictWriter<'_>), 

Write a nested dict using the given closure that receives a dict builder. Tags are from outer to inner.

fn write_dict_ret<T, F>(
    self,
    tags: impl IntoIterator<Item = u64>,
    f: F
) -> (Self::Output, T) where
    F: FnOnce(&mut DictWriter<'_>) -> T, 

Write a nested dict using the given closure that receives a dict builder. Tags are from outer to inner.

fn write_canonical(self, bytes: &[u8]) -> Option<Self::Output>

Interpret the given bytes as a single CBOR item and write it to this builder, canonicalising its contents like CborOwned::canonical()

fn write_trusting(self, bytes: &[u8]) -> Self::Output

Assume that the given bytes are a well-formed single CBOR item and write it to this builder.