Struct dyer::component::request::RequestBuilder

pub struct RequestBuilder { /* fields omitted */ }

An Wrapper of http::request::Builder

An HTTP request builder

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

Implementations

impl RequestBuilder

pub fn new() -> Self

Create an instance of RequestBuilder that used to build a Request
Same as Request::builder()

Examples

let request = RequestBuilder::new()
    .body(());

pub fn uri<S>(self, uri: S) -> Self where
    Uri: TryFrom<S>,
    <Uri as TryFrom<S>>::Error: Into<Error>, 

set the uri of Task, if not called, the default value is “/”

Examples

let task = TaskBuilder::new()
    .uri("https://example.com")
    .parser(parser_fn)
    .body(());

pub fn uri_ref(&self) -> &Uri

get shared reference to uri of TaskBuilder Same as Task::uri(...)

Examples

let uri = "https://example.com";
let task = TaskBuilder::new()
    .uri(uri)
    .parser(parser_fn)
    .body(());
assert_eq!(task.uri_ref(), uri);

pub fn method<S>(self, method: S) -> Self where
    Method: TryFrom<S>,
    <Method as TryFrom<S>>::Error: Into<Error>, 

set the method of Task

Examples

let method = Method::POST;
let task = TaskBuilder::new()
    .method(method)
    .parser(parser_fn)
    .body(());
assert_eq!(task.method_ref(), method);

pub fn method_ref(&self) -> &Method

get shared reference to method of TaskBuilder Same as Task::method(...)

Examples

let method = Method::POST;
let task = TaskBuilder::new()
    .method(method)
    .parser(parser_fn)
    .body(());
assert_eq!(task.method_ref(), method);

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

get shared reference to header of TaskBuilder Same as Task::headers(...)

Examples

let task = TaskBuilder::new()
    .header("accept", "*/*")
    .parser(parser_fn)
    .body(());
assert_eq!(task.header_ref()["accept"], "*/*");

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

get mutable reference to header of TaskBuilder

Examples

let task = TaskBuilder::new()
    .header("accept", "*/*")
    .parser(parser_fn)
    .body(());
task.header_mut().insert("accept", "text/html");
assert_eq!(task.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 Task

Examples

let task = TaskBuilder::new()
    .header("accept", "*/*")
    .parser(parser_fn)
    .body(());
assert_eq!(task.header_ref()["accept"], "*/*");

pub fn version(self, version: Version) -> Self

set the version of Task

Examples

let task = TaskBuilder::new()
    .version(Version::HTTP_10)
    .parser(parser_fn)
    .body(());
assert_eq!(task.version_ref(), Version::HTTP_10);

pub fn version_ref(&self) -> &Version

get shared reference to version of TaskBuilder Same as Task::version(...)

Examples

let version = Version::HTTP_10;
let task = TaskBuilder::new()
    .version(version)
    .parser(parser_fn)
    .body(());
assert_eq!(task.version_ref(), version);

pub fn body<'r, R>(self, body: Body) -> Result<Request>

Take this RequestBuilder and combine the body to create a Request

Examples

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

pub fn extensions_ref(&self) -> &Extensions

get shared reference to extensions of RequestBuilder Same as Request::extensions(...)

Examples

struct S {}
let request = RequestBuilder::new()
    .body(());
let s = S {};
request.extensions_mut.insert(s);
assert_eq!(request.extensions_ref().get::<S>(), &s);

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

get mutable reference to extensions of RequestBuilder

Examples

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

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

set the exts of Request

Examples

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

pub fn exts_ref(&self) -> &Extensions

get shared reference to exts of RequestBuilder Same as Request::exts(...)

Examples

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

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

get mutable reference to exts of RequestBuilder

Examples

let request = RequestBuilder::new()
    .body(());
request.exts_mut().insert(vec![1,2,3]);
assert_eq!(request.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 Request

Examples

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

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

set the body_fn of Request,

Examples

let task = RequestBuilder::new()
    .body_fn(body_fn)
    .body(());
assert_eq!(*Request.body_fn_ref(), body_fn);