[−][src]Trait cbor_data::Encoder

pub trait Encoder: Sized {
    type Output;
    pub unsafe fn writer(&mut self) -> ArrayWriter<'_>;

    pub unsafe fn finish(self) -> Self::Output;

    pub fn encode_u64(self, value: u64) -> Self::Output { ... }

    pub fn encode_i64(self, value: i64) -> Self::Output { ... }

    pub fn encode_f64(self, value: f64) -> Self::Output { ... }
}

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

use cbor_data::{CborBuilder, Encoder};

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

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

let array2 = CborBuilder::default()
    .write_array(None)
    .encode_u64(18)
    .encode_i64(-12)
    .finish();

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

let dict2 = CborBuilder::default()
    .write_dict(None)
    .with_key("a").encode_u64(14)
    .with_key("b").encode_i64(-1)
    .finish();

Associated Types

type Output[src]

Loading content...

Required methods

pub unsafe fn writer(&mut self) -> ArrayWriter<'_>[src]

Safety

Internal function, do not use!

pub unsafe fn finish(self) -> Self::Output[src]

Safety

Internal function, do not use!

Loading content...

Provided methods

pub fn encode_u64(self, value: u64) -> Self::Output[src]

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());

pub fn encode_i64(self, value: i64) -> Self::Output[src]

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());

pub fn encode_f64(self, value: f64) -> Self::Output[src]

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());
Loading content...

Implementors

impl<'a> Encoder for ArrayWriter<'a>[src]

type Output = Self

impl<'a> Encoder for CborBuilder<'a>[src]

type Output = CborOwned

impl<'a> Encoder for DictValueWriter<'a>[src]

type Output = DictWriter<'a>

impl<'a, T: 'a> Encoder for ArrayBuilder<'a, T>[src]

type Output = Self

impl<'a, T: 'a> Encoder for DictValueBuilder<'a, T>[src]

type Output = DictBuilder<'a, T>

Loading content...