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
|
use hyper::method;
use rustc_serialize::{Decoder, Decodable};
use std::borrow::Cow;
use std::fmt::{Display, Formatter, Result as FmtResult};
use std::net::{SocketAddr as StdSocketAddr};
use std::ops::Deref;
use std::str::FromStr;
use url;
use datatype::Error;
/// Encapsulate a socket address for implementing additional traits.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SocketAddr(pub StdSocketAddr);
impl Decodable for SocketAddr {
fn decode<D: Decoder>(d: &mut D) -> Result<SocketAddr, D::Error> {
let addr = try!(d.read_str());
addr.parse().or_else(|err| Err(d.error(&format!("{}", err))))
}
}
impl FromStr for SocketAddr {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match StdSocketAddr::from_str(s) {
Ok(addr) => Ok(SocketAddr(addr)),
Err(err) => Err(Error::Parse(format!("couldn't parse SocketAddr: {}", err)))
}
}
}
impl Deref for SocketAddr {
type Target = StdSocketAddr;
fn deref(&self) -> &StdSocketAddr {
&self.0
}
}
impl Display for SocketAddr {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
write!(f, "{}", self.0)
}
}
/// Encapsulate a url with additional methods and traits.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Url(pub url::Url);
impl Url {
/// Append the string suffix to this URL.
pub fn join(&self, suffix: &str) -> Result<Url, Error> {
let url = try!(self.0.join(suffix));
Ok(Url(url))
}
}
impl<'a> Into<Cow<'a, Url>> for Url {
fn into(self) -> Cow<'a, Url> {
Cow::Owned(self)
}
}
impl FromStr for Url {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let url = try!(url::Url::parse(s));
Ok(Url(url))
}
}
impl Decodable for Url {
fn decode<D: Decoder>(d: &mut D) -> Result<Url, D::Error> {
let s = try!(d.read_str());
s.parse().map_err(|e: Error| d.error(&e.to_string()))
}
}
impl Deref for Url {
type Target = url::Url;
fn deref(&self) -> &url::Url {
&self.0
}
}
impl Display for Url {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
let host = self.0.host_str().unwrap_or("localhost");
if let Some(port) = self.0.port() {
write!(f, "{}://{}:{}{}", self.0.scheme(), host, port, self.0.path())
} else {
write!(f, "{}://{}{}", self.0.scheme(), host, self.0.path())
}
}
}
/// Enumerate the supported HTTP methods.
#[derive(Clone, Debug)]
pub enum Method {
Get,
Post,
Put,
}
impl Into<method::Method> for Method {
fn into(self) -> method::Method {
match self {
Method::Get => method::Method::Get,
Method::Post => method::Method::Post,
Method::Put => method::Method::Put,
}
}
}
impl<'a> Into<Cow<'a, Method>> for Method {
fn into(self) -> Cow<'a, Method> {
Cow::Owned(self)
}
}
impl Display for Method {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
let method = match *self {
Method::Get => "GET".to_string(),
Method::Post => "POST".to_string(),
Method::Put => "PUT".to_string(),
};
write!(f, "{}", method)
}
}
|
