Struct vach::builder::Leaf

pub struct Leaf<'a> {
    pub id: String,
    pub content_version: u8,
    pub compress: CompressMode,
    pub flags: Flags,
    pub encrypt: bool,
    pub sign: bool,
    pub link_mode: Option<String>,
    // some fields omitted
}

A wrapper around an io::Read handle. Allows for multiple types of data implementing io::Read to be used under one structure. Also used to configure how data will be processed and embedded into an write target.

Fields

id: String

The ID under which the embedded data will be referenced

content_version: u8

The version of the content, allowing you to track obsolete data.

compress: CompressMode

How a Leaf should be compressed

flags: Flags

The flags that will go into the archive write target.

encrypt: bool

Use encryption when writing into the target.

sign: bool

Whether to include a signature with this Leaf, defaults to false If set to true then a hash generated and validated when loaded

link_mode: Option<String>

If a Leaf has a link_mode of Some(“dw”), then this leaf simply routes the data pointed by the adjacent Leaf with the ID “dw”. Use this if you want to have multiple pointers|registry entries aliasing to the same data. The handle of a link leaf stores the ID of the aliased leaf.

Implementations

impl<'a> Leaf<'a>

pub fn from_handle<H: Read + 'a>(handle: H) -> Leaf<'a>

Wrap a Leaf around the given handle. Using the Default configuration.

 use vach::prelude::Leaf;
 use std::io::Cursor;

 let leaf = Leaf::from_handle(Cursor::new(vec![]));

pub fn template(self, other: &Leaf<'_>) -> Self

Copy all fields from another Leaf, except for handle, link_mode and id Meant to be used like a setter:

use std::io::Cursor;
use vach::prelude::{Leaf, CompressMode};
let template = Leaf::default()
   .version(12)
   .compress(CompressMode::Always);

let leaf = Leaf::from_handle(Cursor::new(vec![])).template(&template);

pub fn compress(self, compress: CompressMode) -> Self

Setter used to set the CompressMode of a Leaf

use vach::prelude::{Leaf, CompressMode};

let leaf = Leaf::default().compress(CompressMode::Always);

pub fn version(self, content_version: u8) -> Self

Setter used to set the content_version of a Leaf

use vach::prelude::{Leaf};

let leaf = Leaf::default().version(2);

pub fn id(self, id: &str) -> Self

Setter used to set the id field of a Leaf

use vach::prelude::{Leaf};

let leaf = Leaf::default().id("whatzitouya");

pub fn flags(self, flags: Flags) -> Self

Setter used to set the Flags field of a Leaf

use vach::prelude::{Leaf, Flags};

let leaf = Leaf::default().flags(Flags::default());

pub fn encrypt(self, encrypt: bool) -> Self

Setter for the encrypt field

use vach::prelude::Leaf;
 let config = Leaf::default().encrypt(true);

pub fn sign(self, sign: bool) -> Self

Setter for the sign field

use vach::prelude::Leaf;
 let config = Leaf::default().sign(true);

pub fn link_mode(self, link_mode: Option<String>) -> Self

Setter for the link_mode field

use vach::prelude::Leaf;
 let config = Leaf::default().link_mode(Some("default.tx".to_string()));

Trait Implementations

impl<'a> Debug for Leaf<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Leaf<'a>

fn default() -> Leaf<'a>

The default leaf holds no bytes at all, this is expected to be used as a stencil|template.