mirror of
https://github.com/ahgamut/rust-ape-example.git
synced 2024-05-15 01:52:42 +00:00
88 lines
2.5 KiB
Rust
88 lines
2.5 KiB
Rust
// ./src/error/multiple_error_types/wrap_error.md
|
|
|
|
|
|
use std::error;
|
|
use std::error::Error;
|
|
use std::num::ParseIntError;
|
|
use std::fmt;
|
|
|
|
type Result<T> = std::result::Result<T, DoubleError>;
|
|
|
|
#[derive(Debug)]
|
|
enum DoubleError {
|
|
EmptyVec,
|
|
// We will defer to the parse error implementation for their error.
|
|
// Supplying extra info requires adding more data to the type.
|
|
Parse(ParseIntError),
|
|
}
|
|
|
|
impl fmt::Display for DoubleError {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match *self {
|
|
DoubleError::EmptyVec =>
|
|
write!(f, "please use a vector with at least one element"),
|
|
// The wrapped error contains additional information and is available
|
|
// via the source() method.
|
|
DoubleError::Parse(..) =>
|
|
write!(f, "the provided string could not be parsed as int"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl error::Error for DoubleError {
|
|
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
|
|
match *self {
|
|
DoubleError::EmptyVec => None,
|
|
// The cause is the underlying implementation error type. Is implicitly
|
|
// cast to the trait object `&error::Error`. This works because the
|
|
// underlying type already implements the `Error` trait.
|
|
DoubleError::Parse(ref e) => Some(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
// Implement the conversion from `ParseIntError` to `DoubleError`.
|
|
// This will be automatically called by `?` if a `ParseIntError`
|
|
// needs to be converted into a `DoubleError`.
|
|
impl From<ParseIntError> for DoubleError {
|
|
fn from(err: ParseIntError) -> DoubleError {
|
|
DoubleError::Parse(err)
|
|
}
|
|
}
|
|
|
|
fn double_first(vec: Vec<&str>) -> Result<i32> {
|
|
let first = vec.first().ok_or(DoubleError::EmptyVec)?;
|
|
// Here we implicitly use the `ParseIntError` implementation of `From` (which
|
|
// we defined above) in order to create a `DoubleError`.
|
|
let parsed = first.parse::<i32>()?;
|
|
|
|
Ok(2 * parsed)
|
|
}
|
|
|
|
fn print(result: Result<i32>) {
|
|
match result {
|
|
Ok(n) => println!("The first doubled is {}", n),
|
|
Err(e) => {
|
|
println!("Error: {}", e);
|
|
if let Some(source) = e.source() {
|
|
println!(" Caused by: {}", source);
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
fn part0() {
|
|
let numbers = vec!["42", "93", "18"];
|
|
let empty = vec![];
|
|
let strings = vec!["tofu", "93", "18"];
|
|
|
|
print(double_first(numbers));
|
|
print(double_first(empty));
|
|
print(double_first(strings));
|
|
}
|
|
|
|
pub fn main() {
|
|
part0();
|
|
}
|
|
|