Struct dyer::component::task::Task

pub struct Task { /* private fields */ }

An Task 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.

Implementations

impl Task

pub fn builder() -> TaskBuilder

create an uninitalized Task instance without set the parser as well NOTE valid only in this crate when recycling failed response Create an instance of TaskBuilder that used to build a Task

Examples

let task = Task::builder()
    .method("GET")
    .uri("https://example.com/")
    .header("accept", "*/*")
    .parser(parser_fn)
    .body(())
    .unwrap();

impl Task

pub fn get<'a, S>(uri: S) -> TaskBuilder where
    Uri: TryFrom<S>,
    <Uri as TryFrom<S>>::Error: Into<Error>, 

creates a new TaskBuilder initialized with a POST method and URI

Examples

let task = Task::get("https://example.com/")
    .parser(parser_fn)
    .body(())
    .unwrap();

pub fn post<'a, S>(uri: S) -> TaskBuilder where
    Uri: TryFrom<S>,
    <Uri as TryFrom<S>>::Error: Into<Error>, 

creates a new TaskBuilder initialized with a POST method and URI

Examples

let task = Task::post("https://example.com/")
    .parser(parser_fn)
    .body(());

pub fn put<'a, S>(uri: S) -> TaskBuilder where
    Uri: TryFrom<S>,
    <Uri as TryFrom<S>>::Error: Into<Error>, 

creates a new TaskBuilder initialized with a PUT method and URI

Examples

let task = Task::put("https://example.com/")
    .parser(parser_fn)
    .body(());

pub fn connect<'a, S>(uri: S) -> TaskBuilder where
    Uri: TryFrom<S>,
    <Uri as TryFrom<S>>::Error: Into<Error>, 

creates a new TaskBuilder initialized with a CONNECT method and URI

Examples

let task = Task::connect("https://example.com/")
    .parser(parser_fn)
    .body(());

pub fn delete<'a, S>(uri: S) -> TaskBuilder where
    Uri: TryFrom<S>,
    <Uri as TryFrom<S>>::Error: Into<Error>, 

creates a new TaskBuilder initialized with a DELETE method and URI

Examples

let request = Task::delete("https://example.com/")
    .parser(parser_fn)
    .body(());

pub fn head<'a, S>(uri: S) -> TaskBuilder where
    Uri: TryFrom<S>,
    <Uri as TryFrom<S>>::Error: Into<Error>, 

creates a new TaskBuilder initialized with a HEAD method and URI

Examples

let task = Task::head("https://example.com/")
    .parser(parser_fn)
    .body(());

pub fn options<'a, S>(uri: S) -> TaskBuilder where
    Uri: TryFrom<S>,
    <Uri as TryFrom<S>>::Error: Into<Error>, 

creates a new TaskBuilder initialized with a OPTIONS method and URI

Examples

let task = Task::options("https://example.com/")
    .parser(parser_fn)
    .body(());

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

creates a new TaskBuilder initialized with a PATCH method and URI

Examples

let task = Task::patch("https://example.com/")
    .parser(parser_fn)
    .body(());

pub fn trace<'a, S>(uri: S) -> TaskBuilder where
    Uri: TryFrom<S>,
    <Uri as TryFrom<S>>::Error: Into<Error>, 

creates a new TaskBuilder initialized with a TRACE method and URI

Examples

let task = Task::trace("https://example.com/")
    .parser(parser_fn)
    .body(());

pub fn proxy_mut(&mut self) -> Option<&mut Proxy>

Available on crate feature proxy only.

get mutable reference to proxy of Task

Examples

let mut task = Task::builder()
    .proxy("http://127.0.0.1:1088")
    .body(());
task.proxy_mut().unwrap().set_addr("http://127.0.0.1:1080");
assert!(task.proxy().unwrap().addr(), "http://127.0.0.1:1080");

pub fn proxy(&self) -> Option<&Proxy>

Available on crate feature proxy only.

get shared reference to proxy of Task

Examples

let task = Task::builder()
    .proxy("http://127.0.0.1:1088")
    .body(());
assert_eq!(task.proxy().unwrap().addr(), "http://127.0.0.1:1088" );

impl Task

pub fn uri(&self) -> &Uri

get shared reference to uri of Task

Examples

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

pub fn method(&self) -> &Method

get shared reference to method of Task

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
assert_eq!(task.method(), Method::GET);

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

get shared reference to headers of Task

Examples

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

pub fn version(&self) -> Version

get headers of Task

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
assert_eq!(task.version(), Version::HTTP_11);

pub fn exts(&self) -> &Extensions

get shared reference to exts of Task

Examples

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

pub fn extensions(&self) -> &Extensions

get shared reference to extensions of Task

Examples

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

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

get shared reference to parser of Task

Examples

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

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

get shared reference to err_parser of Task

Examples

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

pub fn rank(&self) -> i16

get the rank of Task

Examples

let task = Task::builder()
    .body(());
assert_eq!(task.rank(), 0);

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

get mutable reference to rank of Task

Examples

let task = Task::builder()
    .body(());
task.rank_mut() = 3;
assert_eq!(*task.rank_mut(), 3);

pub fn info(&self) -> &Info

get shared reference to info of Task

Examples

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

pub fn body(&self) -> &Body

get shared reference to body of Task

Examples

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

pub fn uri_mut(&mut self) -> &mut Uri

get mutable reference to uri of Task

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
let uri = "https://example.com".Into();
task.uri_mut() = uri;
assert_eq!(*task.uri(), uri);

pub fn method_mut(&mut self) -> &mut Method

get mutable reference to method of Task

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
let method = Method::POST;
task.method_mut() = method;
assert_eq!(*task.method(), method);

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

get mutable reference to headers of Task

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
task.headers_mut().insert(Method::ACCEPT, "*/*".into());
assert!(!task.headers().is_empty());

pub fn version_mut(&mut self) -> &mut Version

get mutable reference to version of Task

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
let version = Version::HTTP_3;
task.version_mut() = version;
assert_eq!(task.version(), version);

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

get mutable reference to exts of Task

Examples

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

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

get mutable reference to extensions of Task

Examples

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

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

get mutable reference to parser of Task

Examples

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

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

get mutable reference to err_parser of Task

Examples

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

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

get mutable reference to info of Task

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(());
task.info_mut().unique = false;
assert_eq!(*task.info_ref().unique, false);

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

get mutable reference to body of Task

Examples

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

pub fn into_body(self) -> Body

Consume the task and obtain the body

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(Vec::new());
let body = task.into_body()
assert_eq!(body, vec::new());

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

Convert the body of the Task with function

Examples

let task = Task::builder()
    .parser(parser_fn)
    .body(vec![1,2,3]);
let new_task = task.map(|v| v + 1 );
assert_eq!(new_task.body, vec![2,3,4]);

pub fn from_parts(
    inner: InnerTask,
    body: Body,
    metat: MetaTask,
    proxy: Option<Proxy>
) -> Self

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

Examples

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

pub fn into_parts(self) -> (InnerTask, Body, MetaTask, Option<Proxy>)

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

Examples

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

Trait Implementations

impl Debug for Task

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

Formats the value using the given formatter.

impl Default for Task

fn default() -> Task

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Task

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

Deserialize this value from the given Serde deserializer.

impl From<Task> for Couple

fn from(task: Task) -> Couple

Converts to this type from the input type.

impl From<Task> for Poly

fn from(task: Task) -> Self

Converts to this type from the input type.

impl Hash for Task

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 Task

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

Serialize this value into the given Serde serializer.

impl TryInto<Task> for Poly

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Send for Task

Safety: since *const () is a static function pointer(a usize that indicating hardware address) which is Copy so it owns the data, and no one else has it, the data can be safely transfered to another thread

impl Sync for Task

Safety: since *const () is a static function pointer(a usize that indicating hardware address) which is Copy so it owns the data, and no one else has it, the data can be safely transfered to another thread