1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use std::io;
pub use error::{Error};
use std::error::Error as StdError;
use valico;

use super::backend;

pub struct ErrorResponse {
    pub error: Box<Error + Send>,
    pub response: Option<backend::Response>
}

pub struct StrictErrorResponse {
    pub error: Box<Error + Send>,
    pub response: backend::Response
}

macro_rules! error_response{
    ($error:expr) => ($crate::errors::ErrorResponse{
        error: Box::new($error) as Box<$crate::errors::Error + Send>,
        response: None
    })
}

macro_rules! error_response_boxed{
    ($error:expr) => ($crate::errors::ErrorResponse{
        error: $error,
        response: None
    })
}


macro_rules! impl_basic_err {
    ($err:ty, $code:expr) => {
        impl ::std::error::Error for $err {
            fn description(&self) -> &str {
                $code
            }
        }

        impl ::std::fmt::Display for $err {
            fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                self.description().fmt(formatter)
            }
        }
    }
}

#[derive(Debug)]
pub struct NotMatch;
impl_basic_err!(NotMatch, "NotMatch");

#[derive(Debug)]
pub struct NotFound;
impl_basic_err!(NotFound, "NotFound");

#[derive(Debug)]
pub struct QueryString;
impl_basic_err!(QueryString, "QueryString");

#[derive(Debug)]
pub struct Validation {
    pub reason: valico::ValicoErrors
}
impl_basic_err!(Validation, "Validation");

#[derive(Debug)]
pub struct Body {
    pub reason: String
}

impl Body {
    pub fn new(reason: String) -> Body {
        return Body {
            reason: reason
        }
    }
}
impl_basic_err!(Body, "Body");

#[derive(Debug)]
pub struct File(pub io::Error);
impl_basic_err!(File, "File");

#[derive(Debug)]
pub struct NotAcceptable;
impl_basic_err!(NotAcceptable, "NotAcceptable");