ssdp 0.1.5

An asynchronous abstraction for discovering devices and services on a network.
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

use std::convert::{From};
use std::error::{Error};
use std::fmt::{self, Display, Formatter};
use std::marker::{Reflect};

/// Result that can return a T or an SSDPError.
pub type SSDPResult<T> = Result<T, SSDPError>;

/// Enumerates all errors that can occur when dealing with an SSDP message.
#[derive(Debug)]
pub enum SSDPError {
    /// Message is not valid HTTP.
    ///
    /// Message is supplied as a list of bytes.
    InvalidHttp(Vec<u8>),
    /// Message did not specify HTTP/1.1 as version.
    InvalidHttpVersion,
    /// Message consists of an error code.
    ///
    /// Error code is supplied.
    ResponseCode(u16),
    /// Method supplied is not a valid SSDP method.
    ///
    /// Method received is supplied.
    InvalidMethod(String),
    /// Uri supplied is not a valid SSDP uri.
    ///
    /// URI received is supplied.
    InvalidUri(String),
    /// Header is missing from the message.
    ///
    /// Expected header is supplied.
    MissingHeader(&'static str),
    /// Header has an invalid value.
    ///
    /// Header name with error message are supplied.
    InvalidHeader(&'static str, &'static str),
    /// Some other error occurred.
    Other(Box<Error>)
}

impl Display for SSDPError {
    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
        match *self {
            SSDPError::InvalidHttp(ref n) => {
                let http_str = String::from_utf8_lossy(n);
                
                f.write_fmt(format_args!("Invalid Http: {}", http_str))
            },
            SSDPError::InvalidHttpVersion => {
                f.write_str("Invalid Http Version")
            },
            SSDPError::ResponseCode(n) => {
                f.write_fmt(format_args!("Response Code: {}", n))
            },
            SSDPError::InvalidMethod(ref n) => {
                f.write_fmt(format_args!("Invalid Method: {}", n))
            },
            SSDPError::InvalidUri(ref n) => {
                f.write_fmt(format_args!("Invalid URI: {}", n))
            },
            SSDPError::MissingHeader(n) => {
                f.write_fmt(format_args!("Missing Header: {}", n))
            },
            SSDPError::InvalidHeader(name, value) => {
                f.write_fmt(format_args!("Invalid Header: {}: {}", name, value))
            },
            SSDPError::Other(ref n) => {
                f.write_fmt(format_args!("Other: {}", n.description()))
            }
        }
    }
}

impl<T> From<T> for SSDPError where T: Error + 'static {
    fn from(err: T) -> SSDPError {
        SSDPError::Other(Box::new(err) as Box<Error>)
    }
}

/// Basic type implementing the Error trait.
#[derive(Debug)]
pub struct MsgError {
    desc: &'static str
}

impl MsgError {
    pub fn new(desc: &'static str) -> MsgError {
        MsgError{ desc: desc }
    }
}

impl Reflect for MsgError { }

impl Error for MsgError {
    fn description(&self) -> &str {
        self.desc
    }
}

impl Display for MsgError {
    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
        f.write_str(self.desc)
    }
}

#[cfg(test)]
mod tests {
    use std::error::{Error};

    use super::{MsgError};

    #[test]
    fn positive_msg_error_display() {
        let error = MsgError::new("Something Happened");
        
        assert_eq!(&error.to_string()[..], "Something Happened");
    }
    
    #[test]
    fn positive_msg_error_description() {
        let error = MsgError::new("Something Happened");
        
        assert_eq!(error.description(), "Something Happened");
    }
}