Enum rocket::outcome::Outcome [−][src]
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));
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"));
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."));
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 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 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"));
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
.
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"));
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
.
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));
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
.
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));
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};
use rocket::handler::Outcome;
fn str_responder(req: &Request, _: Data) -> Outcome<'static> {
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};
use rocket::handler::Outcome;
fn str_responder(req: &Request, data: Data) -> Outcome<'static> {
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 where
rocket::handler::Outcome
is imported instead of rocket::Outcome
.
Example
use rocket::{Request, Data};
use rocket::handler::Outcome;
use rocket::http::Status;
fn bad_req_route(_: &Request, _: Data) -> Outcome<'static> {
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 where
rocket::handler::Outcome
is imported instead of rocket::Outcome
.
Example
use rocket::{Request, Data};
use rocket::handler::Outcome;
fn always_forward(_: &Request, data: Data) -> Outcome<'static> {
Outcome::forward(data)
}
Trait Implementations
try_trait_v2
)Constructs the type from a compatible Residual
type. Read more
try_trait_v2
)Constructs the type from a compatible Residual
type. Read more
impl<S: PartialOrd, E: PartialOrd, F: PartialOrd> PartialOrd<Outcome<S, E, F>> for Outcome<S, E, F>
impl<S: PartialOrd, E: PartialOrd, F: PartialOrd> PartialOrd<Outcome<S, E, F>> for Outcome<S, E, F>
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
type Output = A
type Output = A
try_trait_v2
)The type of the value produced by ?
when not short-circuiting.
try_trait_v2
)The type of the value passed to FromResidual::from_residual
as part of ?
when short-circuiting. Read more
try_trait_v2
)Constructs the type from its Output
type. Read more
try_trait_v2
)Used in ?
to decide whether the operator should produce a value
(because this returned ControlFlow::Continue
)
or propagate a value back to the caller
(because this returned ControlFlow::Break
). 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.