Struct dyer::request::Request

pub struct Request {
    pub inner: InnerRequest,
    pub body: Body,
    pub metar: MetaRequest,
    /* private fields */
}

An Wrapper of http::Request

An HTTP request consists of a head and a potentially optional body. The body component is generic, enabling arbitrary types to represent the HTTP body. For example, the body could be Vec, a Stream of byte chunks, or a value that has been deserialized. Generally, Affix and Task roughly add up to a Request,

Fields

inner: InnerRequest

body: Body

metar: MetaRequest

Implementations

impl Request

pub fn builder() -> RequestBuilder

Create an instance of RequestBuilder that used to build a Request

Examples

let request = Request::default();
    .body(());

pub fn body(&self) -> &Body

get shared reference to body of RequestBuilder

Examples

let request = Request::default();
assert!(request.body().is_none());

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

get mutable reference to body of RequestBuilder

Examples

let request = Request::default();
request.body_mut() = 3;
assert!(request.body_mut().is_none());

pub fn extensions(&self) -> &Extensions

get shared reference to extensions of RequestBuilder

Examples

struct S {}
let request = Request::default();
    .body(());
let s = S {};
request.extensions_mut.insert(s);
assert_eq!(request.extensions().get::<S>(), &s);

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

get mutable reference to extensions of RequestBuilder

Examples

let request = Request::default();
    .body(());
request.extensions_mut().insert(vec![1,2,3]);
assert_eq!(request.extensions().get::<Vec<_>>(), &vec![1,2,3]);

pub fn exts(&self) -> &Extensions

get shared reference to exts of RequestBuilder

Examples

struct S {}
let request = Request::default();
    .body(());
let s = S {};
request.exts_mut.insert(s);
assert_eq!(request.exts().get::<S>(), &s);

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

get mutable reference to exts of RequestBuilder

Examples

let request = Request::default();
    .body(());
request.exts_mut().insert(vec![1,2,3]);
assert_eq!(request.exts().get::<Vec<_>>(), &vec![1,2,3]);

pub fn body_fn(&self) -> Option<fn(_: Body) -> Body>

get shared reference to body_fn of Request

Examples

let reqeust = Request::default();
    .body_fn(body_fn)
    .body(());
assert_eq!(*reqeust.body_fn(), body_fn);

pub fn body_fn_mut(&mut self, body_fn: fn(_: Body) -> Body)

set the body_fn of Request,

Examples

let req = Request::default();
    .as_mut()
    .body_fn_mut(body_fn);
assert_eq!(*Request.body_fn(), body_fn);

pub fn info(&self) -> &Info

get shared reference to info of Request

Examples

let request = request::default();
assert_eq!(request.info().used, 0);

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

get mutable reference to info of Request

Examples

let request = request::default();
request.info_mut().unique = false;
assert_eq!(*request.info_ref().unique, false);

pub fn into_body(self) -> Body

Consume the request and obtain the body

Examples

let request = request::default();
assert!(request.into_body().is_empty());

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

Convert the body of the request with function

Examples

let request = request::default();
let new= request.map(|v| v + 1 );
assert_eq!(new.body, vec![2,3,4]);

pub fn from_parts(
    inner: InnerRequest,
    body: Body,
    metar: MetaRequest,
    proxy: Option<Proxy>
) -> Self

Create new Request directly with body, inner data (require feature proxy enabled)

Examples

let request = request::default();
let ( mut inner, body, meta ) = request.into_parts();
let _ = request::from_parts(inner, body, meta);

pub fn into_parts(self) -> (InnerRequest, Body, MetaRequest, Option<Proxy>)

split request into body, inner data, (require feature proxy enabled)

Examples

let request = request::default();
let (_inner, _body, _meta ) = request.into_parts();

pub fn from_couple(
    couple: &Couple,
    f: Option<&Box<dyn for<'c, 'd> Fn(&'c Body, Option<&'d Body>) -> Body + Send>>,
    exts_t_fn: Option<&Box<dyn for<'c, 'd> Fn(&'c Extensions, &'d Extensions) -> (Extensions, Extensions) + Send>>,
    exts_p_fn: Option<&Box<dyn for<'c, 'd> Fn(&'c Extensions, &'d Extensions) -> (Extensions, Extensions) + Send>>
) -> Self

Create new Request directly with Task and Affix(Optional)

Examples

let request = request::default();
let ( mut inner, body, meta ) = request.into_parts();
let _ = request::from_parts(inner, body, meta);

impl Request

pub fn get_id(&self) -> u64

Available on crate feature proxy only.

get the unique client id that will execute the request

pub fn get_client(&mut self) -> &'static Client

Available on crate feature proxy only.

get the client to execute the request

Trait Implementations

impl Debug for Request

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

Formats the value using the given formatter.

impl Default for Request

fn default() -> Request

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Request

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

Deserialize this value from the given Serde deserializer.

impl From<Request> for Poly

fn from(request: Request) -> Self

Converts to this type from the input type.

impl Into<(MetaRequest, Request<Body>, Extensions, Extensions)> for Request

fn into(self) -> (MetaRequest, Request<Body>, Extensions, Extensions)

transform a Request into hyper::Request

impl Serialize for Request

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

Serialize this value into the given Serde serializer.

impl TryInto<Request> for Poly

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.