Struct dyer::affix::AffixBuilder

pub struct AffixBuilder { /* fields omitted */ }

Serve as an media to create an instance of Affix

This type can be used to construct an instance or Affix through a builder-like pattern.

Implementations

impl AffixBuilder

pub fn new() -> Self

Create an instance of AffixBuilder that used to build a Affix
Same as Affix::builder()

Examples

let affix = AffixBuilder::new()
    .body(());

pub fn header_ref(&self) -> &HeaderMap<HeaderValue>

get shared reference to header of AffixBuilder Same as Affix::headers(...)

Examples

let affix = AffixBuilder::new()
    .header("accept", "*/*")    
    .body(());
assert_eq!(affix.header_ref()["accept"], "*/*");

pub fn header_mut(&mut self) -> &mut HeaderMap<HeaderValue>

get mutable reference to header of AffixBuilder

Examples

let affix = AffixBuilder::new()
    .header("accept", "*/*")    
    .body(());
affix.header_mut().insert("accept", "text/html");
assert_eq!(affix.header_ref()["accept"], "text/html");

pub fn header<K, V>(self, key: K, value: V) -> Self where
    HeaderName: TryFrom<K>,
    <HeaderName as TryFrom<K>>::Error: Into<Error>,
    HeaderValue: TryFrom<V>,
    <HeaderValue as TryFrom<V>>::Error: Into<Error>, 

set the headers of Affix

Examples

let affix = AffixBuilder::new()
    .header("accept", "*/*")
    .body(());
assert_eq!(affix.header_ref()["accept"], "*/*");

pub fn extensions_ref(&self) -> &Extensions

get shared reference to meta extensions of Affix

Examples

struct S {}
let affix = AffixBuilder::new()
    .body(());
assert!(affix.extensions().get::<S>().is_none());

pub fn extension_mut(&mut self) -> &mut Extensions

get mutable reference to extensions of Affix

Examples

struct S {}
let affix = Affix::builder()
    .body(());
let s = S {};
affix.extensions_mut().insert(s);
assert_eq!(affix.extensions().get::<S>(), Some(&s));

pub fn extensions<S>(self, extension: S) -> Self where
    S: Any + Send + Sync + 'static, 

set the extensions of Affix

Examples

let affix = AffixBuilder::new()
    .extensions(vec![1,2,3])
    .body(());
assert_eq!(affix.extensions_ref(), &vec![1,2,3]);

pub fn exts_ref(&self) -> &Extensions

get shared reference to exts of AffixBuilder Same as Affix::exts(...)

Examples

struct S {}
let affix = AffixBuilder::new()
    .parser(parser_fn)
    .body(());
let s = S {};
affix.exts_mut.insert(s);
assert_eq!(affix.exts_ref().get::<S>(), &s);

pub fn exts_mut(&mut self) -> &mut Extensions

get mutable reference to exts of AffixBuilder

Examples

let affix = AffixBuilder::new()
    .body(());
affix.exts_mut().insert(vec![1,2,3]);
assert_eq!(affix.exts_ref().get::<Vec<_>>(), vec![1,2,3]);

pub fn exts<S>(self, exts: S) -> Self where
    S: Any + Send + Sync + 'static, 

set the exts of Affix

Examples

let Affix = AffixBuilder::new()
    .exts(vec![1,2,3])
    .body(());
assert_eq!(Affix.exts_ref(), &vec![1,2,3]);

pub fn info_ref(&self) -> &Info

get shared reference to info of Affix same as Affix::info(...)

Examples

let affix = Affix::builder()
    .body(());
assert_eq!(affix.info_ref().unique, true);

pub fn info_mut(&mut self) -> &mut Info

get mutable reference to info of Affix same as Affix::info_mut(...)

Examples

let info = Info::default();
info.unique = false;
let affix = Affix::builder()
    .body(());
affix.info_mut() = info;
assert_eq!(affix.info_ref().unique, false);

pub fn info<S>(self, info: Info) -> Self

set the info of Affix

Examples

let affix = affixBuilder::new()
    .body(());
assert_eq!(affix.info_ref().unique, true);

pub fn body(self, body: Body) -> Result<Affix>

Take this AffixBuilder and combine the body to create a Affix

Examples

let _ = AffixBuilder::new()
    .body(());

pub fn meta_ref(&self) -> &MetaAffix

get shared reference to meta of Affix,

Examples

let affix = Affix::builder()    
    .body(());
assert_eq!(affix.meta_ref().rank, 0);

pub fn meta(self, meta: MetaAffix) -> Self

set the meta of Affix

Examples

let meta = MetaAffix::new();
let affix = AffixBuilder::new()
    .meta(meta)    
    .body(());