Trait yatlv::FrameBuilderLike[−][src]

pub trait FrameBuilderLike {
    fn add_data(&mut self, tag: u16, value: &[u8]);

    fn add_frame(&mut self, tag: u16) -> PacketFrameBuilder<'_>;

    fn add_child(&mut self, tag: u16) -> PacketFrameBuilder<'_> { ... }

    fn add_bool(&mut self, tag: u16, value: bool) { ... }

    fn add_u8(&mut self, tag: u16, value: u8) { ... }

    fn add_u16(&mut self, tag: u16, value: u16) { ... }

    fn add_u32(&mut self, tag: u16, value: u32) { ... }

    fn add_u64(&mut self, tag: u16, value: u64) { ... }

    fn add_str<S>(&mut self, tag: u16, value: S)
    where
        S: AsRef<str>,
    { ... }

    fn add_uuid(&mut self, tag: u16, value: &Uuid) { ... }
}
Expand description

FrameBuilderLike defines the methods common to FrameBuilder and PacketFrameBuilder.

Required methods

Add a slice of data as a field to the frame.

use yatlv::{FrameBuilder, FrameBuilderLike};
let mut data = Vec::with_capacity(100);
{
    let mut bld = FrameBuilder::new(&mut data);
    let tag = 45;
    let data = &[90, 9];
    bld.add_data(tag, data);
}
assert_eq!(&[
    1,          // frame-format
    0, 0, 0, 1, // field count
    0, 45,      // field-tag
    0, 0, 0, 2, // field-length
    90, 9       // field-value
], &data[..]);

Create a new child frame builder.

use yatlv::{FrameBuilder, FrameBuilderLike};
let mut data = Vec::with_capacity(100);
{
    let mut bld = FrameBuilder::new(&mut data);
    let tag = 45;
    let mut child_bld = bld.add_frame(45);
    let tag2 = 60;
    let data = &[90, 9];
    child_bld.add_data(60, data);
}
assert_eq!(&[
    1,           // frame-format
    0, 0, 0, 1,  // field count
    0, 45,       // field-tag
    0, 0, 0, 13, // field-length
    1,           // child frame format
    0, 0, 0, 1,  // child field count
    0, 60,       // child field-tag2
    0, 0, 0, 2,  // child field-length
    90, 9        // child field-value
], &data[..]);

Provided methods

👎 Deprecated

Use FrameBuilderLike::add_frame instead.

Add a bool flied to the frame.

use yatlv::{FrameBuilder, FrameBuilderLike};
let mut data = Vec::with_capacity(100);
{
    let mut bld = FrameBuilder::new(&mut data);
    bld.add_bool(1022, true);
    bld.add_bool(1021, false);
}
assert_eq!(&[
    1,          // frame-format
    0, 0, 0, 2, // field count = 1
    3, 254,     // tag = 1022
    0, 0, 0, 1, // field length = 2
    255,        // field value
    3, 253,     // tag = 1021
    0, 0, 0, 1, // field length = 2
    0           // field value
], &data[..]);

Add a u8 field to the frame.

use yatlv::{FrameBuilder, FrameBuilderLike};
let mut data = Vec::with_capacity(100);
{
    let mut bld = FrameBuilder::new(&mut data);
    let tag = 45;
    let data = 7;
    bld.add_u8(tag, data);
}
assert_eq!(&[
    1,          // frame-format
    0, 0, 0, 1, // field count
    0, 45,      // field-tag
    0, 0, 0, 1, // field-length
    7           // field-value
], &data[..]);

Add a u16 field to the frame.

This method will always use a two byte encoding for the value.

use yatlv::{FrameBuilder, FrameBuilderLike};
let mut data = Vec::with_capacity(100);
{
    let mut bld = FrameBuilder::new(&mut data);
    let tag = 45;
    let data = 7;
    bld.add_u16(tag, data);
}
assert_eq!(&[
    1,          // frame-format
    0, 0, 0, 1, // field count
    0, 45,      // field-tag
    0, 0, 0, 2, // field-length
    0, 7        // field-value
], &data[..]);

Add a u32 field to the frame.

use yatlv::{FrameBuilder, FrameBuilderLike};
let mut data = Vec::with_capacity(100);
{
    let mut bld = FrameBuilder::new(&mut data);
    let tag = 45;
    let data = 7;
    bld.add_u32(tag, data);
}
assert_eq!(&[
    1,          // frame-format
    0, 0, 0, 1, // field count
    0, 45,      // field-tag
    0, 0, 0, 4, // field-length
    0, 0, 0, 7  // field-value
], &data[..]);

Add a u64 field to the frame.

use yatlv::{FrameBuilder, FrameBuilderLike};
let mut data = Vec::with_capacity(100);
{
    let mut bld = FrameBuilder::new(&mut data);
    let tag = 45;
    let data = 7;
    bld.add_u64(tag, data);
}
assert_eq!(&[
    1,                     // frame-format
    0, 0, 0, 1,            // field count
    0, 45,                 // field-tag
    0, 0, 0, 8,            // field-length
    0, 0, 0, 0, 0, 0, 0, 7 // field-value
], &data[..]);

Add a str field to the frame.

use yatlv::{FrameBuilder, FrameBuilderLike};
let mut data = Vec::with_capacity(100);
{
    let mut bld = FrameBuilder::new(&mut data);
    let tag = 45;
    let data = "hello";
    bld.add_str(tag, data);
}
assert_eq!(&[
    1,                      // frame-format
    0, 0, 0, 1,             // field count
    0, 45,                  // field-tag
    0, 0, 0, 5,             // field-length
    104, 101, 108, 108, 111 // field-value
], &data[..]);

Add a uuid field to the frame.

use uuid::Uuid;
use yatlv::{FrameBuilder, FrameBuilderLike};
let mut data = Vec::with_capacity(100);
{
    let mut bld = FrameBuilder::new(&mut data);
    let tag = 45;
    let data = Uuid::parse_str("3011712a-d972-4a5d-bbf9-ec5fb7525c97").unwrap();
    bld.add_uuid(tag, &data);
}
assert_eq!(&[
    1,                      // frame-format
    0, 0, 0, 1,             // field count
    0, 45,                  // field-tag
    0, 0, 0, 16,             // field-length
    48, 17, 113, 42, 217, 114, 74, 93, 187, 249, 236, 95, 183, 82, 92, 151 // field-value
], &data[..]);

Implementors