      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
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149

    use std::error;
    use std::fmt;
    use std::result;

    use crate::header;
    use crate::method;
    use crate::status;
    use crate::uri;

    /// A generic "error" for HTTP connections
    ///
    /// This error type is less specific than the error returned from other
    /// functions in this crate, but all other errors can be converted to this
    /// error. Consumers of this crate can typically consume and work with this form
    /// of error for conversions with the `?` operator.
    pub struct Error {
        inner: ErrorKind,
    }

    /// A `Result` typedef to use with the `http::Error` type
    pub type Result<T> = result::Result<T, Error>;

    enum ErrorKind {
        StatusCode(status::InvalidStatusCode),
        Method(method::InvalidMethod),
        Uri(uri::InvalidUri),
        UriParts(uri::InvalidUriParts),
        HeaderName(header::InvalidHeaderName),
        HeaderValue(header::InvalidHeaderValue),
    }

    impl fmt::Debug for Error {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.debug_tuple("http::Error")
                // Skip the noise of the ErrorKind enum
                .field(&self.get_ref())
                .finish()
        }
    }

    impl fmt::Display for Error {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            fmt::Display::fmt(self.get_ref(), f)
        }
    }

    impl Error {
        /// Return true if the underlying error has the same type as T.
        pub fn is<T: error::Error + 'static>(&self) -> bool {
            self.get_ref().is::<T>()
        }

        /// Return a reference to the lower level, inner error.
        pub fn get_ref(&self) -> &(dyn error::Error + 'static) {
            use self::ErrorKind::*;

            match self.inner {
                StatusCode(ref e) => e,
                Method(ref e) => e,
                Uri(ref e) => e,
                UriParts(ref e) => e,
                HeaderName(ref e) => e,
                HeaderValue(ref e) => e,
            }
        }
    }

    impl error::Error for Error {
        // Return any available cause from the inner error. Note the inner error is
        // not itself the cause.
        fn source(&self) -> Option<&(dyn error::Error + 'static)> {
            self.get_ref().source()
        }
    }

    impl From<status::InvalidStatusCode> for Error {
        fn from(err: status::InvalidStatusCode) -> Error {
            Error {
                inner: ErrorKind::StatusCode(err),
            }
        }
    }

    impl From<method::InvalidMethod> for Error {
        fn from(err: method::InvalidMethod) -> Error {
            Error {
                inner: ErrorKind::Method(err),
            }
        }
    }

    impl From<uri::InvalidUri> for Error {
        fn from(err: uri::InvalidUri) -> Error {
            Error {
                inner: ErrorKind::Uri(err),
            }
        }
    }

    impl From<uri::InvalidUriParts> for Error {
        fn from(err: uri::InvalidUriParts) -> Error {
            Error {
                inner: ErrorKind::UriParts(err),
            }
        }
    }

    impl From<header::InvalidHeaderName> for Error {
        fn from(err: header::InvalidHeaderName) -> Error {
            Error {
                inner: ErrorKind::HeaderName(err),
            }
        }
    }

    impl From<header::InvalidHeaderValue> for Error {
        fn from(err: header::InvalidHeaderValue) -> Error {
            Error {
                inner: ErrorKind::HeaderValue(err),
            }
        }
    }

    impl From<std::convert::Infallible> for Error {
        fn from(err: std::convert::Infallible) -> Error {
            match err {}
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn inner_error_is_invalid_status_code() {
            if let Err(e) = status::StatusCode::from_u16(6666) {
                let err: Error = e.into();
                let ie = err.get_ref();
                assert!(!ie.is::<header::InvalidHeaderValue>());
                assert!(ie.is::<status::InvalidStatusCode>());
                ie.downcast_ref::<status::InvalidStatusCode>().unwrap();

                assert!(!err.is::<header::InvalidHeaderValue>());
                assert!(err.is::<status::InvalidStatusCode>());
            } else {
                panic!("Bad status allowed!");
            }
        }
    }