From f957f10b19b6355ad057158dc86608a7d23d5032 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Wed, 13 May 2015 15:02:07 -0700 Subject: [PATCH] Use a Box 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::. In the future we can add the parameter back with a default of Box to avoid forcing people to box stuff. --- src/io/mod.rs | 14 -------------- src/lib.rs | 46 ++++++++++++++++++++++------------------------ src/priv_io.rs | 5 ++--- src/types/slice.rs | 2 +- tests/test.rs | 6 +++--- 5 files changed, 28 insertions(+), 45 deletions(-) diff --git a/src/io/mod.rs b/src/io/mod.rs index 091bd159..0b38ac50 100644 --- a/src/io/mod.rs +++ b/src/io/mod.rs @@ -26,17 +26,3 @@ pub trait NegotiateSsl { fn negotiate_ssl(&mut self, host: &str, stream: Stream) -> Result, Box>; } - -/// An uninhabited type implementing `NegotiateSsl`. -/// -/// `NoSsl` cannot be instantiated, so the only `SslMode` 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> { - match *self {} - } -} diff --git a/src/lib.rs b/src/lib.rs index 4c96a4e0..4e34e83f 100644 --- a/src/lib.rs +++ b/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(params: T, ssl: &mut SslMode, data: CancelData) +pub fn cancel_query(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(¶ms, ssl)); @@ -458,13 +458,13 @@ impl IsolationLevel { } /// Specifies the SSL support requested for a new connection. -pub enum SslMode { +pub enum SslMode { /// The connection will not use SSL. None, /// The connection will use SSL if the backend supports it. - Prefer(N), + Prefer(Box), /// The connection must use SSL. - Require(N), + Require(Box), } #[derive(Clone)] @@ -497,9 +497,8 @@ impl Drop for InnerConnection { } impl InnerConnection { - fn connect(params: T, ssl: &mut SslMode) - -> result::Result - where T: IntoConnectParams, N: NegotiateSsl { + fn connect(params: T, ssl: &mut SslMode) -> result::Result + where T: IntoConnectParams { let params = try!(params.into_connect_params()); let stream = try!(priv_io::initialize_stream(¶ms, ssl)); @@ -987,7 +986,7 @@ 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(()) }; /// ``` /// @@ -995,7 +994,7 @@ impl Connection { /// # 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(params: T, ssl: &mut SslMode) - -> result::Result - where T: IntoConnectParams, N: NegotiateSsl { + pub fn connect(params: T, ssl: &mut SslMode) -> result::Result + 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(); diff --git a/src/priv_io.rs b/src/priv_io.rs index b09195a6..e9151f96 100644 --- a/src/priv_io.rs +++ b/src/priv_io.rs @@ -118,9 +118,8 @@ fn open_socket(params: &ConnectParams) -> Result { } } -pub fn initialize_stream(params: &ConnectParams, ssl: &mut SslMode) - -> Result, ConnectError> - where N: NegotiateSsl { +pub fn initialize_stream(params: &ConnectParams, ssl: &mut SslMode) + -> Result, ConnectError> { let mut socket = Stream(try!(open_socket(params))); let (ssl_required, negotiator) = match *ssl { diff --git a/src/types/slice.rs b/src/types/slice.rs index 203f1770..e62535ab 100644 --- a/src/types/slice.rs +++ b/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)])) { diff --git a/tests/test.rs b/tests/test.rs index 77c78e7e..80d838d6 100644 --- a/tests/test.rs +++ b/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]);