Change negotiate_ssl back to taking &self

It's not clear that &mut is necessary and it makes connection calls a
bit nicer looking.

Author: sfackler

src/io/mod.rs

@@ -23,6 +23,5 @@ pub trait NegotiateSsl {
     ///
     /// The host portion of the connection parameters is provided for hostname
     /// verification.
-    fn negotiate_ssl(&mut self, host: &str, stream: Stream)
-                     -> Result<Box<StreamWrapper>, Box<Error>>;
+    fn negotiate_ssl(&self, host: &str, stream: Stream) -> Result<Box<StreamWrapper>, Box<Error>>;
 }

src/io/openssl.rs

@@ -16,8 +16,7 @@ impl StreamWrapper for SslStream<Stream> {
 }
 
 impl NegotiateSsl for SslContext {
-    fn negotiate_ssl(&mut self, _: &str, stream: Stream)
-                     -> Result<Box<StreamWrapper>, Box<Error>> {
+    fn negotiate_ssl(&self, _: &str, stream: Stream) -> Result<Box<StreamWrapper>, Box<Error>> {
         let stream = try!(SslStream::new(self, stream));
         Ok(Box::new(stream))
     }

src/lib.rs

@@ -15,7 +15,7 @@
 //! }
 //!
 //! fn main() {
-//!     let conn = Connection::connect("postgresql://postgres@localhost", &mut SslMode::None)
+//!     let conn = Connection::connect("postgresql://postgres@localhost", &SslMode::None)
 //!             .unwrap();
 //!
 //!     conn.execute("CREATE TABLE person (
@@ -379,15 +379,15 @@ pub struct CancelData {
 /// # use postgres::{Connection, SslMode};
 /// # use std::thread;
 /// # let url = "";
-/// let conn = Connection::connect(url, &mut SslMode::None).unwrap();
+/// let conn = Connection::connect(url, &SslMode::None).unwrap();
 /// let cancel_data = conn.cancel_data();
 /// thread::spawn(move || {
 ///     conn.execute("SOME EXPENSIVE QUERY", &[]).unwrap();
 /// });
 /// # let _ =
-/// postgres::cancel_query(url, &mut SslMode::None, cancel_data);
+/// postgres::cancel_query(url, &SslMode::None, cancel_data);
 /// ```
-pub fn cancel_query<T>(params: T, ssl: &mut SslMode, data: CancelData)
+pub fn cancel_query<T>(params: T, ssl: &SslMode, data: CancelData)
                           -> result::Result<(), ConnectError>
         where T: IntoConnectParams {
     let params = try!(params.into_connect_params());
@@ -497,7 +497,7 @@ impl Drop for InnerConnection {
 }
 
 impl InnerConnection {
-    fn connect<T>(params: T, ssl: &mut SslMode) -> result::Result<InnerConnection, ConnectError>
+    fn connect<T>(params: T, ssl: &SslMode) -> result::Result<InnerConnection, ConnectError>
             where T: IntoConnectParams {
         let params = try!(params.into_connect_params());
         let stream = try!(priv_io::initialize_stream(&params, ssl));
@@ -986,15 +986,15 @@ impl Connection {
     /// # use postgres::{Connection, SslMode, ConnectError};
     /// # fn f() -> Result<(), ConnectError> {
     /// let url = "postgresql://postgres:hunter2@localhost:2994/foodb";
-    /// let conn = try!(Connection::connect(url, &mut SslMode::None));
+    /// let conn = try!(Connection::connect(url, &SslMode::None));
     /// # Ok(()) };
     /// ```
     ///
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode, ConnectError};
     /// # fn f() -> Result<(), ConnectError> {
     /// let url = "postgresql://postgres@%2Frun%2Fpostgres";
-    /// let conn = try!(Connection::connect(url, &mut SslMode::None));
+    /// let conn = try!(Connection::connect(url, &SslMode::None));
     /// # Ok(()) };
     /// ```
     ///
@@ -1014,10 +1014,10 @@ impl Connection {
     ///     database: None,
     ///     options: vec![],
     /// };
-    /// let conn = try!(Connection::connect(params, &mut SslMode::None));
+    /// let conn = try!(Connection::connect(params, &SslMode::None));
     /// # Ok(()) };
     /// ```
-    pub fn connect<T>(params: T, ssl: &mut SslMode) -> result::Result<Connection, ConnectError>
+    pub fn connect<T>(params: T, ssl: &SslMode) -> result::Result<Connection, ConnectError>
             where T: IntoConnectParams {
         InnerConnection::connect(params, ssl).map(|conn| {
             Connection { conn: RefCell::new(conn) }
@@ -1049,7 +1049,7 @@ impl Connection {
     ///
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
-    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
     /// let maybe_stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1");
     /// let stmt = match maybe_stmt {
     ///     Ok(stmt) => stmt,
@@ -1072,7 +1072,7 @@ impl Connection {
     /// # use postgres::{Connection, SslMode};
     /// # fn f() -> postgres::Result<()> {
     /// # let x = 10i32;
-    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
     /// let stmt = try!(conn.prepare_cached("SELECT foo FROM bar WHERE baz = $1"));
     /// for row in try!(stmt.query(&[&x])) {
     ///     println!("foo: {}", row.get::<_, String>(0));
@@ -1111,7 +1111,7 @@ impl Connection {
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
     /// # fn foo() -> Result<(), postgres::Error> {
-    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
     /// let trans = try!(conn.transaction());
     /// try!(trans.execute("UPDATE foo SET bar = 10", &[]));
     /// // ...
@@ -1499,7 +1499,7 @@ impl<'conn> Statement<'conn> {
     ///
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
-    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
     /// # let bar = 1i32;
     /// # let baz = true;
     /// let stmt = conn.prepare("UPDATE foo SET bar = $1 WHERE baz = $2").unwrap();
@@ -1558,7 +1558,7 @@ impl<'conn> Statement<'conn> {
     ///
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
-    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
     /// let stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1").unwrap();
     /// # let baz = true;
     /// let rows = match stmt.query(&[&baz]) {
@@ -1872,7 +1872,7 @@ impl<'a> Row<'a> {
     ///
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
-    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
     /// # let stmt = conn.prepare("").unwrap();
     /// # let mut result = stmt.query(&[]).unwrap();
     /// # let row = result.iter().next().unwrap();

src/priv_io.rs

@@ -118,14 +118,14 @@ fn open_socket(params: &ConnectParams) -> Result<InternalStream, ConnectError> {
     }
 }
 
-pub fn initialize_stream(params: &ConnectParams, ssl: &mut SslMode)
+pub fn initialize_stream(params: &ConnectParams, ssl: &SslMode)
                             -> Result<Box<StreamWrapper>, ConnectError> {
     let mut socket = Stream(try!(open_socket(params)));
 
     let (ssl_required, negotiator) = match *ssl {
         SslMode::None => return Ok(Box::new(socket)),
-        SslMode::Prefer(ref mut negotiator) => (false, negotiator),
-        SslMode::Require(ref mut negotiator) => (true, negotiator),
+        SslMode::Prefer(ref negotiator) => (false, negotiator),
+        SslMode::Require(ref negotiator) => (true, negotiator),
     };
 
     try!(socket.write_message(&SslRequest { code: message::SSL_CODE }));

src/types/slice.rs

@@ -16,7 +16,7 @@ use types::IsNull;
 /// ```rust,no_run
 /// # fn foo() -> postgres::Result<()> {
 /// # use postgres::{Connection, SslMode, Slice};
-/// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
+/// # let conn = Connection::connect("", &SslMode::None).unwrap();
 /// let values = &[1i32, 2, 3, 4, 5, 6];
 /// let stmt = try!(conn.prepare("SELECT * FROM foo WHERE id = ANY($1)"));
 /// for row in &try!(stmt.query(&[&Slice(values)])) {