Enum rocket::outcome::Outcome [−][src]
#[must_use] pub enum Outcome<S, E, F> { Success(S), Failure(E), Forward(F), }
Expand description
An enum representing success (Success
), failure (Failure
), or
forwarding (Forward
).
See the top level documentation for detailed information.
Variants
Contains the success value.
Contains the failure error value.
Contains the value to forward on.
Implementations
Return true if this Outcome
is a Success
.
Examples
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.is_success(), true); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.is_success(), false); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.is_success(), false);
Return true if this Outcome
is a Failure
.
Examples
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.is_failure(), false); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.is_failure(), true); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.is_failure(), false);
Return true if this Outcome
is a Forward
.
Examples
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.is_forward(), false); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.is_forward(), false); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.is_forward(), true);
Converts from Outcome<S, E, F>
to Option<S>
.
Returns the Some
of the Success
if this is a Success
, otherwise
returns None
. self
is consumed, and all other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.succeeded(), Some(10)); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.succeeded(), None); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.succeeded(), None);
Converts from Outcome<S, E, F>
to Option<E>
.
Returns the Some
of the Failure
if this is a Failure
, otherwise
returns None
. self
is consumed, and all other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.failed(), None); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.failed(), Some("Hi! I'm an error.")); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.failed(), None);
Converts from Outcome<S, E, F>
to Option<F>
.
Returns the Some
of the Forward
if this is a Forward
, otherwise
returns None
. self
is consumed, and all other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.forwarded(), None); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.forwarded(), None); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.forwarded(), Some(25));
Returns a Success
value as Ok()
or value
in Err
. Converts from
Outcome<S, E, F>
to Result<S, T>
for a given T
.
Returns Ok
with the Success
value if this is a Success
, otherwise
returns an Err
with the provided value. self
is consumed, and all
other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.success_or(false), Ok(10)); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.success_or(false), Err(false)); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.success_or("whoops"), Err("whoops"));
Returns a Success
value as Ok()
or f()
in Err
. Converts from
Outcome<S, E, F>
to Result<S, T>
for a given T
produced from a
supplied function or closure.
Returns Ok
with the Success
value if this is a Success
, otherwise
returns an Err
with the result of calling f
. self
is consumed, and
all other values are discarded.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.success_or_else(|| false), Ok(10)); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.success_or_else(|| false), Err(false)); let x: Outcome<i32, &str, usize> = Forward(25); assert_eq!(x.success_or_else(|| "whoops"), Err("whoops"));
Converts from Outcome<S, E, F>
to Outcome<&S, &E, &F>
.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.as_ref(), Success(&10)); let x: Outcome<i32, &str, usize> = Failure("Hi! I'm an error."); assert_eq!(x.as_ref(), Failure(&"Hi! I'm an error."));
Converts from Outcome<S, E, F>
to Outcome<&mut S, &mut E, &mut F>
.
let mut x: Outcome<i32, &str, usize> = Success(10); if let Success(val) = x.as_mut() { *val = 20; } assert_eq!(x.unwrap(), 20);
Maps the Success
value using f
. Maps an Outcome<S, E, F>
to an
Outcome<T, E, F>
by applying the function f
to the value of type S
in self
if self
is an Outcome::Success
.
let x: Outcome<i32, &str, usize> = Success(10); let mapped = x.map(|v| if v == 10 { "10" } else { "not 10" }); assert_eq!(mapped, Success("10"));
Maps the Failure
value using f
. Maps an Outcome<S, E, F>
to an
Outcome<S, T, F>
by applying the function f
to the value of type E
in self
if self
is an Outcome::Failure
.
let x: Outcome<i32, &str, usize> = Failure("hi"); let mapped = x.map_failure(|v| if v == "hi" { 10 } else { 0 }); assert_eq!(mapped, Failure(10));
Maps the Forward
value using f
. Maps an Outcome<S, E, F>
to an
Outcome<S, E, T>
by applying the function f
to the value of type F
in self
if self
is an Outcome::Forward
.
let x: Outcome<i32, &str, usize> = Forward(5); let mapped = x.map_forward(|v| if v == 5 { "a" } else { "b" }); assert_eq!(mapped, Forward("a"));
Converts from Outcome<S, E, F>
to Outcome<T, E, F>
using f
to map
Success(S)
to Success(T)
.
If self
is not Success
, self
is returned.
Examples
let x: Outcome<i32, &str, bool> = Success(10); let mapped = x.and_then(|v| match v { 10 => Success("10"), 1 => Forward(false), _ => Failure("30") }); assert_eq!(mapped, Success("10"));
Converts from Outcome<S, E, F>
to Outcome<S, T, F>
using f
to map
Failure(E)
to Failure(T)
.
If self
is not Failure
, self
is returned.
Examples
let x: Outcome<i32, &str, bool> = Failure("hi"); let mapped = x.failure_then(|v| match v { "hi" => Failure(10), "test" => Forward(false), _ => Success(10) }); assert_eq!(mapped, Failure(10));
Converts from Outcome<S, E, F>
to Outcome<S, E, T>
using f
to map
Forward(F)
to Forward(T)
.
If self
is not Forward
, self
is returned.
Examples
let x: Outcome<i32, &str, Option<bool>> = Forward(Some(false)); let mapped = x.forward_then(|v| match v { Some(true) => Success(10), Some(false) => Forward(20), None => Failure("10") }); assert_eq!(mapped, Forward(20));
Converts Outcome<S, E, F>
to Result<S, E>
by identity mapping
Success(S)
and Failure(E)
to Result<T, E>
and mapping Forward(F)
to Result<T, E>
using f
.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.ok_map_forward(|x| Ok(x as i32 + 1)), Ok(10)); let x: Outcome<i32, &str, usize> = Failure("hello"); assert_eq!(x.ok_map_forward(|x| Ok(x as i32 + 1)), Err("hello")); let x: Outcome<i32, &str, usize> = Forward(0); assert_eq!(x.ok_map_forward(|x| Ok(x as i32 + 1)), Ok(1));
Converts Outcome<S, E, F>
to Result<S, E>
by identity mapping
Success(S)
and Forward(F)
to Result<T, F>
and mapping Failure(E)
to Result<T, F>
using f
.
let x: Outcome<i32, &str, usize> = Success(10); assert_eq!(x.ok_map_failure(|s| Ok(123)), Ok(10)); let x: Outcome<i32, &str, usize> = Failure("hello"); assert_eq!(x.ok_map_failure(|s| Ok(123)), Ok(123)); let x: Outcome<i32, &str, usize> = Forward(0); assert_eq!(x.ok_map_failure(|s| Ok(123)), Err(0));
Return the Outcome
of response to req
from responder
.
If the responder returns Ok
, an outcome of Success
is returned with
the response. If the responder returns Err
, an outcome of Failure
is
returned with the status code.
Example
use rocket::{Request, Data, route}; fn str_responder<'r>(req: &'r Request, _: Data<'r>) -> route::Outcome<'r> { route::Outcome::from(req, "Hello, world!") }
Return the Outcome
of response to req
from responder
.
If the responder returns Ok
, an outcome of Success
is returned with
the response. If the responder returns Err
, an outcome of Failure
is
returned with the status code.
Example
use rocket::{Request, Data, route}; fn str_responder<'r>(req: &'r Request, _: Data<'r>) -> route::Outcome<'r> { route::Outcome::from(req, "Hello, world!") }
Return the Outcome
of response to req
from responder
.
If the responder returns Ok
, an outcome of Success
is returned with
the response. If the responder returns Err
, an outcome of Forward
is
returned.
Example
use rocket::{Request, Data, route}; fn str_responder<'r>(req: &'r Request, data: Data<'r>) -> route::Outcome<'r> { route::Outcome::from_or_forward(req, data, "Hello, world!") }
Return an Outcome
of Failure
with the status code code
. This is
equivalent to Outcome::Failure(code)
.
This method exists to be used during manual routing.
Example
use rocket::{Request, Data, route}; use rocket::http::Status; fn bad_req_route<'r>(_: &'r Request, _: Data<'r>) -> route::Outcome<'r> { route::Outcome::failure(Status::BadRequest) }
Return an Outcome
of Forward
with the data data
. This is
equivalent to Outcome::Forward(data)
.
This method exists to be used during manual routing.
Example
use rocket::{Request, Data, route}; fn always_forward<'r>(_: &'r Request, data: Data<'r>) -> route::Outcome<'r> { route::Outcome::forward(data) }
Trait Implementations
impl<S: PartialOrd, E: PartialOrd, F: PartialOrd> PartialOrd<Outcome<S, E, F>> for Outcome<S, E, F>
[src]
impl<S: PartialOrd, E: PartialOrd, F: PartialOrd> PartialOrd<Outcome<S, E, F>> for Outcome<S, E, F>
[src]This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
Auto Trait Implementations
impl<S, E, F> RefUnwindSafe for Outcome<S, E, F> where
E: RefUnwindSafe,
F: RefUnwindSafe,
S: RefUnwindSafe,
impl<S, E, F> UnwindSafe for Outcome<S, E, F> where
E: UnwindSafe,
F: UnwindSafe,
S: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
Compare self to key
and return true
if they are equal.
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
Converts self
into a collection.
type Output = T
type Output = T
Should always be Self
pub fn vzip(self) -> V