Struct dyer::component::task::TaskBuilder

pub struct TaskBuilder { /* fields omitted */ }

An Wrapper of http::request::Builder Serve as an medium to create an instance of Task

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

Implementations

impl TaskBuilder

pub fn new() -> Self

Create an instance of TaskBuilder that used to build a Task
Same as Task::builder()

Examples

let task = TaskBuilder::new()
    .method("GET")
    .uri("https://example.com/")
    .header("accept", "*/*")
    .parser(parser_fn)
    .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 exts_ref(&self) -> &Extensions

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

Examples

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

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

get mutable reference to exts of TaskBuilder

Examples

let task = TaskBuilder::new()
    .parser(parser_fn)
    .body(());
task.exts_mut().insert(vec![1,2,3]);
assert_eq!(task.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 Task

Examples

let task = TaskBuilder::new()
    .exts(vec![1,2,3])
    .parser(parser_fn)
    .body(());
assert_eq!(task.exts_ref(), &vec![1,2,3]);

pub fn extensions_ref(&self) -> &Extensions

get shared reference to extensions of Task

Examples

struct S {}
let task = TaskBuilder::new()
    .parser(parser_fn)
    .body(());
assert!(task.extensions().get::<S>().is_none());

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

set the extensions of Task

Examples

let task = TaskBuilder::new()
    .extensions(vec![1,2,3])
    .parser(parser_fn)
    .body(());
assert_eq!(task.extensions_ref(), &vec![1,2,3]);

pub fn parser_ref<E>(&self) -> fn(_: Response) -> Parsed<E> where
    E: Serialize + Clone, 

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

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
assert_eq!(*task.parser_ref(), parser_fn);

pub fn parser<E>(self, parser: fn(_: Response) -> Parsed<E>) -> Self

set the parser of Task, Note that a task must has a parser before initialized!

Examples

fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
let task = TaskBuilder::new()
    .parser(parser_fn)
    .body(());
assert_eq!(*task.parser_ref(), parser_fn);

pub fn err_parser_ref<E>(&self) -> Option<fn(_: Response) -> Parsed<E>>

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

Examples

let task = Task::builder()
    .parser(parser_fn)
    .err_parser(err_parser_fn)
    .body(());
assert_eq!(*task.err_parser_ref(), err_parser_fn);

pub fn err_parser<E>(self, parser: fn(_: Response) -> Parsed<E>) -> Self

set the err_parser of Task,

Examples

fn err_parser_fn(_: Response ) -> Parsed<E,> { todo!() }
let task = TaskBuilder::new()
    .err_parser(err_parser_fn)
    .parser(parser_fn)
    .body(());
assert_eq!(*task.err_parser_ref(), err_parser_fn);

pub fn info_ref(&self) -> &Info

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

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
assert_eq!(task.info_ref().used, &0);

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

set the info of Task

Examples

let task = TaskBuilder::new()
    .parser(parser_fn)
    .body(());
task.info_mut().id = 18908209022;
assert_eq!(task.info_ref().id, 18908209022);

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

set the info of Task

Examples

let info = Info::default();
let task = TaskBuilder::new()
    .info(info)
    .parser(parser_fn)
    .body(());
assert_eq!(task.info_ref(), &info);

pub fn body(self, body: Body, marker: String) -> Result<Task>

Take this TaskBuilder and combine the body to create a Task

Examples

let _ = TaskBuilder::new()
    .parser(parser_fn)
    .body(());

pub fn meta_ref(&self) -> &MetaTask

get shared reference to meta of Task,

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
assert!(!task.meta_ref().is_empty());

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

set the meta of Task

Examples

let meta = MetaTask::new();
let task = TaskBuilder::new()
    .meta(meta)
    .parser(parser_fn)
    .body(());