update using ToSocketAddr

benches/client_mock_tcp.rs

@@ -8,7 +8,7 @@ extern crate test;
 use std::fmt::{mod, Show};
 use std::from_str::from_str;
 use std::io::{IoResult, MemReader};
-use std::io::net::ip::SocketAddr;
+use std::io::net::ip::{SocketAddr, ToSocketAddr};
 use std::os;
 use std::path::BytesContainer;
 
@@ -92,7 +92,7 @@ impl net::NetworkStream for MockStream {
 }
 
 impl net::NetworkConnector for MockStream {
-    fn connect(_host: &str, _port: u16, _scheme: &str) -> IoResult<MockStream> {
+    fn connect<To: ToSocketAddr>(_addr: To, _scheme: &str) -> IoResult<MockStream> {
         Ok(MockStream::new())
     }
 

src/client/request.rs

@@ -56,7 +56,7 @@ impl Request<Fresh> {
         };
         debug!("port={}", port);
 
-        let stream: S = try_io!(NetworkConnector::connect(host.as_slice(), port, url.scheme.as_slice()));
+        let stream: S = try_io!(NetworkConnector::connect((host[], port), url.scheme.as_slice()));
         let stream = ThroughWriter(BufferedWriter::new(box stream as Box<NetworkStream + Send>));
 
         let mut headers = Headers::new();

src/mock.rs

@@ -1,5 +1,5 @@
 use std::io::IoResult;
-use std::io::net::ip::SocketAddr;
+use std::io::net::ip::{SocketAddr, ToSocketAddr};
 
 use net::{NetworkStream, NetworkConnector};
 
@@ -26,7 +26,7 @@ impl NetworkStream for MockStream {
 }
 
 impl NetworkConnector for MockStream {
-    fn connect(_host: &str, _port: u16, _scheme: &str) -> IoResult<MockStream> {
+    fn connect<To: ToSocketAddr>(_addr: To, _scheme: &str) -> IoResult<MockStream> {
         Ok(MockStream)
     }
 }

src/net.rs

@@ -5,7 +5,7 @@ use std::fmt;
 use std::intrinsics::TypeId;
 use std::io::{IoResult, IoError, ConnectionAborted, InvalidInput, OtherIoError,
               Stream, Listener, Acceptor};
-use std::io::net::ip::{SocketAddr, Port};
+use std::io::net::ip::{SocketAddr, ToSocketAddr};
 use std::io::net::tcp::{TcpStream, TcpListener, TcpAcceptor};
 use std::mem::{mod, transmute, transmute_copy};
 use std::raw::{mod, TraitObject};
@@ -28,7 +28,7 @@ pub trait NetworkListener<S: NetworkStream, A: NetworkAcceptor<S>>: Listener<S,
     ///
     /// Note: This does not start listening for connections. You must call
     /// `listen()` to do that.
-    fn bind(host: &str, port: Port) -> IoResult<Self>;
+    fn bind<To: ToSocketAddr>(addr: To) -> IoResult<Self>;
 
     /// Get the address this Listener ended up listening on.
     fn socket_name(&mut self) -> IoResult<SocketAddr>;
@@ -53,7 +53,7 @@ pub trait NetworkStream: Stream + Any + Clone + Send {
 /// A connector creates a NetworkStream.
 pub trait NetworkConnector: NetworkStream {
     /// Connect to a remote address.
-    fn connect(host: &str, Port, scheme: &str) -> IoResult<Self>;
+    fn connect<To: ToSocketAddr>(addr: To, scheme: &str) -> IoResult<Self>;
 }
 
 impl fmt::Show for Box<NetworkStream + Send> {
@@ -136,9 +136,9 @@ impl Listener<HttpStream, HttpAcceptor> for HttpListener {
 
 impl NetworkListener<HttpStream, HttpAcceptor> for HttpListener {
     #[inline]
-    fn bind(host: &str, port: Port) -> IoResult<HttpListener> {
+    fn bind<To: ToSocketAddr>(addr: To) -> IoResult<HttpListener> {
         Ok(HttpListener {
-            inner: try!(TcpListener::bind(host, port))
+            inner: try!(TcpListener::bind(addr))
         })
     }
 
@@ -219,21 +219,21 @@ impl NetworkStream for HttpStream {
 }
 
 impl NetworkConnector for HttpStream {
-    fn connect(host: &str, port: Port, scheme: &str) -> IoResult<HttpStream> {
+    fn connect<To: ToSocketAddr>(addr: To, scheme: &str) -> IoResult<HttpStream> {
         match scheme {
             "http" => {
                 debug!("http scheme");
-                Ok(Http(try!(TcpStream::connect(host, port))))
+                Ok(Http(try!(TcpStream::connect(addr))))
             },
             "https" => {
                 debug!("https scheme");
-                let mut stream = try!(TcpStream::connect(host, port));
+                let mut stream = try!(TcpStream::connect(addr));
                 // we can't access the tcp stream once it's wrapped in an
                 // SslStream, so grab the ip address now, just in case.
-                let addr = try!(stream.peer_name());
+                let peer_addr = try!(stream.peer_name());
                 let context = try!(SslContext::new(Sslv23).map_err(lift_ssl_error));
                 let stream = try!(SslStream::new(&context, stream).map_err(lift_ssl_error));
-                Ok(Https(Arc::new(Mutex::new(stream)), addr))
+                Ok(Https(Arc::new(Mutex::new(stream)), peer_addr))
             },
             _ => {
                 Err(IoError {

src/server/mod.rs

@@ -60,7 +60,7 @@ impl<L: NetworkListener<S, A>, S: NetworkStream, A: NetworkAcceptor<S>> Server<L
         let mut sockets = Vec::new();
         for (ip, port) in self.pairs.into_iter() {
             debug!("binding to {}:{}", ip, port);
-            let mut listener: L = try_io!(NetworkListener::<S, A>::bind(ip.to_string().as_slice(), port));
+            let mut listener: L = try_io!(NetworkListener::<S, A>::bind((ip, port)));
 
             sockets.push(try_io!(listener.socket_name()));