Use a Box<NegotiateSsl> instead of a default param

Default parameter's aren't used in type inference yet, so the old setup
would result in overly verbose things like &mut SslMode::None::<NoSsl>.
In the future we can add the parameter back with a default of
Box<NegotiateSsl> to avoid forcing people to box stuff.

Author: sfackler

src/io/mod.rs

@@ -26,17 +26,3 @@ pub trait NegotiateSsl {
     fn negotiate_ssl(&mut self, host: &str, stream: Stream)
                      -> Result<Box<StreamWrapper>, Box<Error>>;
 }
-
-/// An uninhabited type implementing `NegotiateSsl`.
-///
-/// `NoSsl` cannot be instantiated, so the only `SslMode<NoSslMode>` value that
-/// can exist is `SslMode::None`. `NoSsl` is the default value of `SslMode`'s
-/// parameter so `&mut SslMode::None` can always be passed into
-/// `Connection::connect` even if no SSL implementation is available.
-pub enum NoSsl {}
-
-impl NegotiateSsl for NoSsl {
-    fn negotiate_ssl(&mut self, _: &str, _: Stream) -> Result<Box<StreamWrapper>, Box<Error>> {
-        match *self {}
-    }
-}

src/lib.rs

@@ -15,7 +15,7 @@
 //! }
 //!
 //! fn main() {
-//!     let conn = Connection::connect("postgresql://postgres@localhost", &SslMode::None)
+//!     let conn = Connection::connect("postgresql://postgres@localhost", &mut SslMode::None)
 //!             .unwrap();
 //!
 //!     conn.execute("CREATE TABLE person (
@@ -79,7 +79,7 @@ use std::path::PathBuf;
 pub use error::{Error, ConnectError, SqlState, DbError, ErrorPosition};
 #[doc(inline)]
 pub use types::{Oid, Type, Kind, ToSql, FromSql};
-use io::{NoSsl, StreamWrapper, NegotiateSsl};
+use io::{StreamWrapper, NegotiateSsl};
 use types::IsNull;
 #[doc(inline)]
 pub use types::Slice;
@@ -379,17 +379,17 @@ pub struct CancelData {
 /// # use postgres::{Connection, SslMode};
 /// # use std::thread;
 /// # let url = "";
-/// let conn = Connection::connect(url, &SslMode::None).unwrap();
+/// let conn = Connection::connect(url, &mut SslMode::None).unwrap();
 /// let cancel_data = conn.cancel_data();
 /// thread::spawn(move || {
 ///     conn.execute("SOME EXPENSIVE QUERY", &[]).unwrap();
 /// });
 /// # let _ =
-/// postgres::cancel_query(url, &SslMode::None, cancel_data);
+/// postgres::cancel_query(url, &mut SslMode::None, cancel_data);
 /// ```
-pub fn cancel_query<T, N>(params: T, ssl: &mut SslMode<N>, data: CancelData)
+pub fn cancel_query<T>(params: T, ssl: &mut SslMode, data: CancelData)
                           -> result::Result<(), ConnectError>
-        where T: IntoConnectParams, N: NegotiateSsl {
+        where T: IntoConnectParams {
     let params = try!(params.into_connect_params());
     let mut socket = try!(priv_io::initialize_stream(&params, ssl));
 
@@ -458,13 +458,13 @@ impl IsolationLevel {
 }
 
 /// Specifies the SSL support requested for a new connection.
-pub enum SslMode<N: NegotiateSsl = NoSsl> {
+pub enum SslMode {
     /// The connection will not use SSL.
     None,
     /// The connection will use SSL if the backend supports it.
-    Prefer(N),
+    Prefer(Box<NegotiateSsl>),
     /// The connection must use SSL.
-    Require(N),
+    Require(Box<NegotiateSsl>),
 }
 
 #[derive(Clone)]
@@ -497,9 +497,8 @@ impl Drop for InnerConnection {
 }
 
 impl InnerConnection {
-    fn connect<T, N>(params: T, ssl: &mut SslMode<N>)
-                     -> result::Result<InnerConnection, ConnectError>
-            where T: IntoConnectParams, N: NegotiateSsl {
+    fn connect<T>(params: T, ssl: &mut SslMode) -> result::Result<InnerConnection, ConnectError>
+            where T: IntoConnectParams {
         let params = try!(params.into_connect_params());
         let stream = try!(priv_io::initialize_stream(&params, ssl));
 
@@ -987,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, &SslMode::None));
+    /// let conn = try!(Connection::connect(url, &mut 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, &SslMode::None));
+    /// let conn = try!(Connection::connect(url, &mut SslMode::None));
     /// # Ok(()) };
     /// ```
     ///
@@ -1015,12 +1014,11 @@ impl Connection {
     ///     database: None,
     ///     options: vec![],
     /// };
-    /// let conn = try!(Connection::connect(params, &SslMode::None));
+    /// let conn = try!(Connection::connect(params, &mut SslMode::None));
     /// # Ok(()) };
     /// ```
-    pub fn connect<T, N>(params: T, ssl: &mut SslMode<N>)
-                         -> result::Result<Connection, ConnectError>
-            where T: IntoConnectParams, N: NegotiateSsl {
+    pub fn connect<T>(params: T, ssl: &mut SslMode) -> result::Result<Connection, ConnectError>
+            where T: IntoConnectParams {
         InnerConnection::connect(params, ssl).map(|conn| {
             Connection { conn: RefCell::new(conn) }
         })
@@ -1051,7 +1049,7 @@ impl Connection {
     ///
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
-    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
     /// let maybe_stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1");
     /// let stmt = match maybe_stmt {
     ///     Ok(stmt) => stmt,
@@ -1074,7 +1072,7 @@ impl Connection {
     /// # use postgres::{Connection, SslMode};
     /// # fn f() -> postgres::Result<()> {
     /// # let x = 10i32;
-    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &mut 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));
@@ -1113,7 +1111,7 @@ impl Connection {
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
     /// # fn foo() -> Result<(), postgres::Error> {
-    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
     /// let trans = try!(conn.transaction());
     /// try!(trans.execute("UPDATE foo SET bar = 10", &[]));
     /// // ...
@@ -1501,7 +1499,7 @@ impl<'conn> Statement<'conn> {
     ///
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
-    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
     /// # let bar = 1i32;
     /// # let baz = true;
     /// let stmt = conn.prepare("UPDATE foo SET bar = $1 WHERE baz = $2").unwrap();
@@ -1560,7 +1558,7 @@ impl<'conn> Statement<'conn> {
     ///
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
-    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &mut SslMode::None).unwrap();
     /// let stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1").unwrap();
     /// # let baz = true;
     /// let rows = match stmt.query(&[&baz]) {
@@ -1874,7 +1872,7 @@ impl<'a> Row<'a> {
     ///
     /// ```rust,no_run
     /// # use postgres::{Connection, SslMode};
-    /// # let conn = Connection::connect("", &SslMode::None).unwrap();
+    /// # let conn = Connection::connect("", &mut 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,9 +118,8 @@ fn open_socket(params: &ConnectParams) -> Result<InternalStream, ConnectError> {
     }
 }
 
-pub fn initialize_stream<N>(params: &ConnectParams, ssl: &mut SslMode<N>)
-                            -> Result<Box<StreamWrapper>, ConnectError>
-        where N: NegotiateSsl {
+pub fn initialize_stream(params: &ConnectParams, ssl: &mut SslMode)
+                            -> Result<Box<StreamWrapper>, ConnectError> {
     let mut socket = Stream(try!(open_socket(params)));
 
     let (ssl_required, negotiator) = match *ssl {

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("", &SslMode::None).unwrap();
+/// # let conn = Connection::connect("", &mut 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)])) {

tests/test.rs

@@ -675,7 +675,7 @@ fn test_cancel_query() {
 fn test_require_ssl_conn() {
     let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost",
-                                                    &mut SslMode::Require(ctx)));
+                                                    &mut SslMode::Require(Box::new(ctx))));
     or_panic!(conn.execute("SELECT 1::VARCHAR", &[]));
 }
 
@@ -684,7 +684,7 @@ fn test_require_ssl_conn() {
 fn test_prefer_ssl_conn() {
     let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost",
-                                                    &mut SslMode::Prefer(ctx)));
+                                                    &mut SslMode::Prefer(Box::new(ctx))));
     or_panic!(conn.execute("SELECT 1::VARCHAR", &[]));
 }
 
@@ -837,7 +837,7 @@ fn test_copy_in_bad_type() {
 
 #[test]
 fn test_copy_in_weird_names() {
-    let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
+    let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None));
     or_panic!(conn.execute(r#"CREATE TEMPORARY TABLE "na""me" (U&" \\\+01F4A9" VARCHAR)"#, &[]));
     let stmt = or_panic!(conn.prepare_copy_in("na\"me", &[" \\💩"]));
     assert_eq!(&Type::Varchar, &stmt.column_types()[0]);