Struct dyer::component::affix::Affix

pub struct Affix { /* fields omitted */ }

generally, it provide extra infomation , meta data required by server, including User-Agent, Accept-Encoding and so on.

Implementations

impl Affix

pub fn builder() -> AffixBuilder

Create an instance of AffixBuilder that used to build a Affix

Examples

let affix = affix::builder()
    .header("accept", "*/*")    
    .body(())
    .unwrap();

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

get shared reference to headers of Affix

Examples

let affix = Affix::builder()    
    .body(());
assert!(affix.headers().is_empty());

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

get mutable reference to headers of Affix

Examples

let affix = Affix::builder()    
    .body(());
affix.headers_mut().insert(Method::ACCEPT, "*/*".into());
assert!(!affix.headers().is_empty());

pub fn exts(&self) -> &Extensions

get shared reference to exts of Affix

Examples

let affix = Affix::builder()    
    .body(());
assert!(affix.exts().is_empty());

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

get mutable reference to exts of Affix

Examples

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

pub fn rank(&self) -> i16

get the rank of Affix

Examples

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

pub fn rank_mut(&mut self) -> &mut i16

get mutable reference to rank of Affix

Examples

let affix = Affix::builder()
    .body(());
affix.rank_mut() = 3;
assert_eq!(*affix.rank(), 3);

pub fn body_mut(&mut self) -> &mut Body

get mutable reference to body of Affix

Examples

let affix = Affix::builder()
    .body(Vec::new());    
affix.body_mut().extend(vec![1,2,3]);    
assert_eq!(*affix.body().get::<Vec<i32>>, Some(&vec![1,2,3]));

pub fn body(&self) -> &Body

get shared reference to body of Affix

Examples

let affix = Affix::builder()
    .body(());    
assert!(affix.body().is_empty());

pub fn into_body(self) -> Body

Consume the affix and obtain the body

Examples

let affix = Affix::builder()
    .body(Vec::new());    
let body = affix.into_body()    
assert_eq!(body, vec::new());

pub fn map<F>(self, f: F) -> Affix where
    F: FnOnce(Body) -> Body, 

Convert the body of the Affix with function

Examples

let affix = Affix::builder()
    .body(vec![1,2,3]);
let new_affix = affix.map(|v| v + 1 );    
assert_eq!(new_affix.body, vec![2,3,4]);

pub fn from_parts(
    headers: HeaderMap<HeaderValue>,
    body: Body,
    metap: MetaAffix
) -> Self

Create new affix directly with body, inner data

Examples

let affix = affix::builder()
    .get("https://example.com")
    .body(vec![1,2,3]);    
let ( mut inner, body, meta ) = affix.into_parts();
inner.version = Version::HTTP_3;    
let new_affix = affix::from_parts(inner, body, meta);

pub fn into_parts(self) -> (InnerAffix, Body, MetaAffix)

split affix into body, inner data

Examples

let affix = affix::builder()
    .get("https://example.com")
    .body(vec![1,2,3]);    
let (_inner, _body, _meta ) = affix.into_parts();

Trait Implementations

impl Debug for Affix

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

Formats the value using the given formatter.

impl Default for Affix

fn default() -> Affix

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Affix

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<Affix> for Poly

fn from(affix: Affix) -> Self

Performs the conversion.

impl Hash for Affix

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Serialize for Affix

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl TryInto<Affix> for Poly

type Error = Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Affix, Self::Error>

Performs the conversion.