Trait cbor_data::Encoder

pub trait Encoder: Writer {
    fn encode_bool(self, value: bool) -> Self::Output { ... }
    fn encode_u64(self, value: u64) -> Self::Output { ... }
    fn encode_i64(self, value: i64) -> Self::Output { ... }
    fn encode_f64(self, value: f64) -> Self::Output { ... }
    fn encode_str(self, value: impl AsRef<str>) -> Self::Output { ... }
    fn encode_array<F>(self, f: F) -> Self::Output
    where
        F: FnMut(&mut ArrayWriter<'_>),
    { ... }
    fn encode_dict<F>(self, f: F) -> Self::Output
    where
        F: FnMut(&mut DictWriter<'_>),
    { ... }
}

High-level encoding functions to write values in their canonical format.

use cbor_data::{CborBuilder, Encoder, Writer};

let cbor = CborBuilder::default().encode_u64(12);

let array = CborBuilder::default().encode_array(|builder| {
    builder
        .encode_u64(18)
        .encode_i64(-12);
});

let array2 = CborBuilder::default().with_max_definite_size(Some(1)).write_array(None, |builder| {
    builder
        .encode_u64(18)
        .encode_i64(-12);
});

let dict = CborBuilder::default().encode_dict(|builder| {
    builder
        .with_key("a", |b| b.encode_u64(14))
        .with_key("b", |b| b.encode_i64(-1));
});

let (dict2, ret) = CborBuilder::default().write_dict_ret(None, |builder| {
    builder
        .with_key("a", |b| b.encode_u64(14))
        .with_key("b", |b| b.encode_i64(-1));
    "hello"
});
assert_eq!(ret, "hello");

Provided methods

fn encode_bool(self, value: bool) -> Self::Output

fn encode_u64(self, value: u64) -> Self::Output

Encode an unsigned integer of at most 64 bit.

Also to be used for smaller unsigned integers:

use cbor_data::{CborBuilder, Encoder};

let short = 12345u16;
let cbor = CborBuilder::default().encode_u64(short.into());

fn encode_i64(self, value: i64) -> Self::Output

Encode a signed integer of at most 64 bit.

Also to be used for smaller signed integers:

use cbor_data::{CborBuilder, Encoder};

let short = -12345i16;
let cbor = CborBuilder::default().encode_i64(short.into());

fn encode_f64(self, value: f64) -> Self::Output

Encode a floating-point number of at most 64 bit.

Also to be used for smaller formats:

use cbor_data::{CborBuilder, Encoder};

let single = -3.14f32;
let cbor = CborBuilder::default().encode_f64(single.into());

fn encode_str(self, value: impl AsRef<str>) -> Self::Output

Encode a string.

use cbor_data::{CborBuilder, Encoder};

let cbor = CborBuilder::default().encode_array(|builder| {
    builder.encode_str("hello");
    builder.encode_str(String::new());
});

fn encode_array<F>(self, f: F) -> Self::Output where
    F: FnMut(&mut ArrayWriter<'_>), 

Write an array that is then filled by the provided closure using the passed builder.

see trait Encoder for usage examples

fn encode_dict<F>(self, f: F) -> Self::Output where
    F: FnMut(&mut DictWriter<'_>), 

Write a dict that is then filled by the provided closure using the passed builder.

see trait Encoder for usage examples

Loading content...

Implementors

impl<T: Writer> Encoder for T

Loading content...