From f892c4b57b096af883e934fd130ea2bb63fe7036 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Mon, 22 May 2017 21:55:51 -0700 Subject: [PATCH] try! -> ? --- postgres-protocol/src/authentication/sasl.rs | 4 +- postgres-protocol/src/lib.rs | 4 +- postgres-protocol/src/message/backend.rs | 64 +++---- postgres-protocol/src/message/frontend.rs | 46 ++--- postgres-protocol/src/types.rs | 166 ++++++++++--------- 5 files changed, 144 insertions(+), 140 deletions(-) diff --git a/postgres-protocol/src/authentication/sasl.rs b/postgres-protocol/src/authentication/sasl.rs index bc300164..32b805f3 100644 --- a/postgres-protocol/src/authentication/sasl.rs +++ b/postgres-protocol/src/authentication/sasl.rs @@ -76,7 +76,7 @@ enum State { /// should be sent to the backend in a `SASLResponse` message. /// /// The server will reply with an `AuthenticationSASLFinal` message. Its contents should be passed -/// to the `finish()` method method, after which the authentication process is complete. +/// to the `finish()` method, after which the authentication process is complete. pub struct ScramSha256 { message: String, state: State, @@ -86,7 +86,7 @@ pub struct ScramSha256 { impl ScramSha256 { /// Constructs a new instance which will use the provided password for authentication. pub fn new(password: &[u8]) -> io::Result { - let mut rng = try!(OsRng::new()); + let mut rng = OsRng::new()?; let nonce = (0..NONCE_LENGTH) .map(|_| { let mut v = rng.gen_range(0x21u8, 0x7e); diff --git a/postgres-protocol/src/lib.rs b/postgres-protocol/src/lib.rs index f9d008a6..9e8707ae 100644 --- a/postgres-protocol/src/lib.rs +++ b/postgres-protocol/src/lib.rs @@ -48,8 +48,8 @@ fn write_nullable(serializer: F, buf: &mut Vec) -> Result<(), E> { let base = buf.len(); buf.extend_from_slice(&[0; 4]); - let size = match try!(serializer(buf)) { - IsNull::No => try!(i32::from_usize(buf.len() - base - 4)), + let size = match serializer(buf)? { + IsNull::No => i32::from_usize(buf.len() - base - 4)?, IsNull::Yes => -1, }; BigEndian::write_i32(&mut buf[base..], size); diff --git a/postgres-protocol/src/message/backend.rs b/postgres-protocol/src/message/backend.rs index 670d7be2..daf1eae2 100644 --- a/postgres-protocol/src/message/backend.rs +++ b/postgres-protocol/src/message/backend.rs @@ -81,9 +81,9 @@ impl Message { b'2' => Message::BindComplete, b'3' => Message::CloseComplete, b'A' => { - let process_id = try!(buf.read_i32::()); - let channel = try!(buf.read_cstr()); - let message = try!(buf.read_cstr()); + let process_id = buf.read_i32::()?; + let channel = buf.read_cstr()?; + let message = buf.read_cstr()?; Message::NotificationResponse(NotificationResponseBody { process_id: process_id, channel: channel, @@ -92,7 +92,7 @@ impl Message { } b'c' => Message::CopyDone, b'C' => { - let tag = try!(buf.read_cstr()); + let tag = buf.read_cstr()?; Message::CommandComplete(CommandCompleteBody { tag: tag }) } b'd' => { @@ -100,7 +100,7 @@ impl Message { Message::CopyData(CopyDataBody { storage: storage }) } b'D' => { - let len = try!(buf.read_u16::()); + let len = buf.read_u16::()?; let storage = buf.read_all(); Message::DataRow(DataRowBody { storage: storage, @@ -112,8 +112,8 @@ impl Message { Message::ErrorResponse(ErrorResponseBody { storage: storage }) } b'G' => { - let format = try!(buf.read_u8()); - let len = try!(buf.read_u16::()); + let format = buf.read_u8()?; + let len = buf.read_u16::()?; let storage = buf.read_all(); Message::CopyInResponse(CopyInResponseBody { format: format, @@ -122,8 +122,8 @@ impl Message { }) } b'H' => { - let format = try!(buf.read_u8()); - let len = try!(buf.read_u16::()); + let format = buf.read_u8()?; + let len = buf.read_u16::()?; let storage = buf.read_all(); Message::CopyOutResponse(CopyOutResponseBody { format: format, @@ -133,8 +133,8 @@ impl Message { } b'I' => Message::EmptyQueryResponse, b'K' => { - let process_id = try!(buf.read_i32::()); - let secret_key = try!(buf.read_i32::()); + let process_id = buf.read_i32::()?; + let secret_key = buf.read_i32::()?; Message::BackendKeyData(BackendKeyDataBody { process_id: process_id, secret_key: secret_key, @@ -146,13 +146,13 @@ impl Message { Message::NoticeResponse(NoticeResponseBody { storage: storage }) } b'R' => { - match try!(buf.read_i32::()) { + match buf.read_i32::()? { 0 => Message::AuthenticationOk, 2 => Message::AuthenticationKerberosV5, 3 => Message::AuthenticationCleartextPassword, 5 => { let mut salt = [0; 4]; - try!(buf.read_exact(&mut salt)); + buf.read_exact(&mut salt)?; Message::AuthenticationMd5Password(AuthenticationMd5PasswordBody { salt: salt, }) @@ -184,15 +184,15 @@ impl Message { } b's' => Message::PortalSuspended, b'S' => { - let name = try!(buf.read_cstr()); - let value = try!(buf.read_cstr()); + let name = buf.read_cstr()?; + let value = buf.read_cstr()?; Message::ParameterStatus(ParameterStatusBody { name: name, value: value, }) } b't' => { - let len = try!(buf.read_u16::()); + let len = buf.read_u16::()?; let storage = buf.read_all(); Message::ParameterDescription(ParameterDescriptionBody { storage: storage, @@ -200,7 +200,7 @@ impl Message { }) } b'T' => { - let len = try!(buf.read_u16::()); + let len = buf.read_u16::()?; let storage = buf.read_all(); Message::RowDescription(RowDescriptionBody { storage: storage, @@ -208,7 +208,7 @@ impl Message { }) } b'Z' => { - let status = try!(buf.read_u8()); + let status = buf.read_u8()?; Message::ReadyForQuery(ReadyForQueryBody { status: status }) } tag => { @@ -309,14 +309,14 @@ impl<'a> FallibleIterator for SaslMechanisms<'a> { #[inline] fn next(&mut self) -> io::Result> { - let value_end = try!(find_null(self.0, 0)); + let value_end = find_null(self.0, 0)?; if value_end == 0 { if self.0.len() != 1 { return Err(io::Error::new(io::ErrorKind::InvalidData, "invalid message length")); } Ok(None) } else { - let value = try!(get_str(&self.0[..value_end])); + let value = get_str(&self.0[..value_end])?; self.0 = &self.0[value_end + 1..]; Ok(Some(value)) } @@ -494,7 +494,7 @@ impl<'a> FallibleIterator for DataRowRanges<'a> { } self.remaining -= 1; - let len = try!(self.buf.read_i32::()); + let len = self.buf.read_i32::()?; if len < 0 { Ok(Some(None)) } else { @@ -536,7 +536,7 @@ impl<'a> FallibleIterator for ErrorFields<'a> { #[inline] fn next(&mut self) -> io::Result>> { - let type_ = try!(self.buf.read_u8()); + let type_ = self.buf.read_u8()?; if type_ == 0 { if self.buf.is_empty() { return Ok(None); @@ -545,8 +545,8 @@ impl<'a> FallibleIterator for ErrorFields<'a> { } } - let value_end = try!(find_null(self.buf, 0)); - let value = try!(get_str(&self.buf[..value_end])); + let value_end = find_null(self.buf, 0)?; + let value = get_str(&self.buf[..value_end])?; self.buf = &self.buf[value_end + 1..]; Ok(Some(ErrorField { @@ -715,15 +715,15 @@ impl<'a> FallibleIterator for Fields<'a> { } self.remaining -= 1; - let name_end = try!(find_null(self.buf, 0)); - let name = try!(get_str(&self.buf[..name_end])); + let name_end = find_null(self.buf, 0)?; + let name = get_str(&self.buf[..name_end])?; self.buf = &self.buf[name_end + 1..]; - let table_oid = try!(self.buf.read_u32::()); - let column_id = try!(self.buf.read_i16::()); - let type_oid = try!(self.buf.read_u32::()); - let type_size = try!(self.buf.read_i16::()); - let type_modifier = try!(self.buf.read_i32::()); - let format = try!(self.buf.read_i16::()); + let table_oid = self.buf.read_u32::()?; + let column_id = self.buf.read_i16::()?; + let type_oid = self.buf.read_u32::()?; + let type_size = self.buf.read_i16::()?; + let type_modifier = self.buf.read_i32::()?; + let format = self.buf.read_i16::()?; Ok(Some(Field { name: name, diff --git a/postgres-protocol/src/message/frontend.rs b/postgres-protocol/src/message/frontend.rs index 881e02ce..177b0f16 100644 --- a/postgres-protocol/src/message/frontend.rs +++ b/postgres-protocol/src/message/frontend.rs @@ -57,9 +57,9 @@ impl<'a> Message<'a> { values, |v, buf| match *v { Some(ref v) => { - buf.extend_from_slice(v); - Ok(IsNull::No) - } + buf.extend_from_slice(v); + Ok(IsNull::No) + } None => Ok(IsNull::Yes), }, result_formats.iter().cloned(), @@ -110,9 +110,9 @@ fn write_body(buf: &mut Vec, f: F) -> Result<(), E> let base = buf.len(); buf.extend_from_slice(&[0; 4]); - try!(f(buf)); + f(buf)?; - let size = try!(i32::from_usize(buf.len() - base)); + let size = i32::from_usize(buf.len() - base)?; BigEndian::write_i32(&mut buf[base..], size); Ok(()) } @@ -153,13 +153,13 @@ pub fn bind(portal: &str, buf.push(b'B'); write_body(buf, |buf| { - try!(buf.write_cstr(portal)); - try!(buf.write_cstr(statement)); - try!(write_counted(formats, |f, buf| buf.write_i16::(f), buf)); - try!(write_counted(values, - |v, buf| write_nullable(|buf| serializer(v, buf), buf), - buf)); - try!(write_counted(result_formats, |f, buf| buf.write_i16::(f), buf)); + buf.write_cstr(portal)?; + buf.write_cstr(statement)?; + write_counted(formats, |f, buf| buf.write_i16::(f), buf)?; + write_counted(values, + |v, buf| write_nullable(|buf| serializer(v, buf), buf), + buf)?; + write_counted(result_formats, |f, buf| buf.write_i16::(f), buf)?; Ok(()) }) @@ -175,10 +175,10 @@ fn write_counted(items: I, mut serializer: F, buf: &mut Vec) -> buf.extend_from_slice(&[0; 2]); let mut count = 0; for item in items { - try!(serializer(item, buf)); + serializer(item, buf)?; count += 1; } - let count = try!(i16::from_usize(count)); + let count = i16::from_usize(count)?; BigEndian::write_i16(&mut buf[base..], count); Ok(()) @@ -238,7 +238,7 @@ pub fn describe(variant: u8, name: &str, buf: &mut Vec) -> io::Result<()> { pub fn execute(portal: &str, max_rows: i32, buf: &mut Vec) -> io::Result<()> { buf.push(b'E'); write_body(buf, |buf| { - try!(buf.write_cstr(portal)); + buf.write_cstr(portal)?; buf.write_i32::(max_rows).unwrap(); Ok(()) }) @@ -250,9 +250,9 @@ pub fn parse(name: &str, query: &str, param_types: I, buf: &mut Vec) -> i { buf.push(b'P'); write_body(buf, |buf| { - try!(buf.write_cstr(name)); - try!(buf.write_cstr(query)); - try!(write_counted(param_types, |t, buf| buf.write_u32::(t), buf)); + buf.write_cstr(name)?; + buf.write_cstr(query)?; + write_counted(param_types, |t, buf| buf.write_u32::(t), buf)?; Ok(()) }) } @@ -273,9 +273,9 @@ pub fn query(query: &str, buf: &mut Vec) -> io::Result<()> { pub fn sasl_initial_response(mechanism: &str, data: &[u8], buf: &mut Vec) -> io::Result<()> { buf.push(b'p'); write_body(buf, |buf| { - try!(buf.write_cstr(mechanism)); - let len = try!(i32::from_usize(data.len())); - try!(buf.write_i32::(len)); + buf.write_cstr(mechanism)?; + let len = i32::from_usize(data.len())?; + buf.write_i32::(len)?; buf.extend_from_slice(data); Ok(()) }) @@ -299,8 +299,8 @@ pub fn startup_message<'a, I>(parameters: I, buf: &mut Vec) -> io::Result<() write_body(buf, |buf| { buf.write_i32::(196608).unwrap(); for (key, value) in parameters { - try!(buf.write_cstr(key.as_ref())); - try!(buf.write_cstr(value.as_ref())); + buf.write_cstr(key.as_ref())?; + buf.write_cstr(value.as_ref())?; } buf.push(0); Ok(()) diff --git a/postgres-protocol/src/types.rs b/postgres-protocol/src/types.rs index d7f2f9a2..2ce84dd7 100644 --- a/postgres-protocol/src/types.rs +++ b/postgres-protocol/src/types.rs @@ -50,7 +50,7 @@ pub fn text_to_sql(v: &str, buf: &mut Vec) { /// Deserializes a `TEXT`, `VARCHAR`, `CHAR(n)`, `NAME`, or `CITEXT` value. #[inline] pub fn text_from_sql(buf: &[u8]) -> Result<&str, StdBox> { - Ok(try!(str::from_utf8(buf))) + Ok(str::from_utf8(buf)?) } /// Serializes a `"char"` value. @@ -62,7 +62,7 @@ pub fn char_to_sql(v: i8, buf: &mut Vec) { /// Deserializes a `"char"` value. #[inline] pub fn char_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_i8()); + let v = buf.read_i8()?; if !buf.is_empty() { return Err("invalid buffer size".into()); } @@ -78,7 +78,7 @@ pub fn int2_to_sql(v: i16, buf: &mut Vec) { /// Deserializes an `INT2` value. #[inline] pub fn int2_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_i16::()); + let v = buf.read_i16::()?; if !buf.is_empty() { return Err("invalid buffer size".into()); } @@ -94,7 +94,7 @@ pub fn int4_to_sql(v: i32, buf: &mut Vec) { /// Deserializes an `INT4` value. #[inline] pub fn int4_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_i32::()); + let v = buf.read_i32::()?; if !buf.is_empty() { return Err("invalid buffer size".into()); } @@ -110,7 +110,7 @@ pub fn oid_to_sql(v: Oid, buf: &mut Vec) { /// Deserializes an `OID` value. #[inline] pub fn oid_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_u32::()); + let v = buf.read_u32::()?; if !buf.is_empty() { return Err("invalid buffer size".into()); } @@ -126,7 +126,7 @@ pub fn int8_to_sql(v: i64, buf: &mut Vec) { /// Deserializes an `INT8` value. #[inline] pub fn int8_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_i64::()); + let v = buf.read_i64::()?; if !buf.is_empty() { return Err("invalid buffer size".into()); } @@ -142,7 +142,7 @@ pub fn float4_to_sql(v: f32, buf: &mut Vec) { /// Deserializes a `FLOAT4` value. #[inline] pub fn float4_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_f32::()); + let v = buf.read_f32::()?; if !buf.is_empty() { return Err("invalid buffer size".into()); } @@ -158,7 +158,7 @@ pub fn float8_to_sql(v: f64, buf: &mut Vec) { /// Deserializes a `FLOAT8` value. #[inline] pub fn float8_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_f64::()); + let v = buf.read_f64::()?; if !buf.is_empty() { return Err("invalid buffer size".into()); } @@ -177,24 +177,26 @@ pub fn hstore_to_sql<'a, I>(values: I, buf: &mut Vec) -> Result<(), StdBox { - try!(write_pascal_string(value, buf)); + write_pascal_string(value, buf)?; } None => buf.write_i32::(-1).unwrap(), } } - let count = try!(i32::from_usize(count)); - (&mut buf[base..base + 4]).write_i32::(count).unwrap(); + let count = i32::from_usize(count)?; + (&mut buf[base..base + 4]) + .write_i32::(count) + .unwrap(); Ok(()) } fn write_pascal_string(s: &str, buf: &mut Vec) -> Result<(), StdBox> { - let size = try!(i32::from_usize(s.len())); + let size = i32::from_usize(s.len())?; buf.write_i32::(size).unwrap(); buf.extend_from_slice(s.as_bytes()); Ok(()) @@ -204,15 +206,15 @@ fn write_pascal_string(s: &str, buf: &mut Vec) -> Result<(), StdBox(mut buf: &'a [u8]) -> Result, StdBox> { - let count = try!(buf.read_i32::()); + let count = buf.read_i32::()?; if count < 0 { return Err("invalid entry count".into()); } Ok(HstoreEntries { - remaining: count, - buf: buf, - }) + remaining: count, + buf: buf, + }) } /// A fallible iterator over `HSTORE` entries. @@ -236,20 +238,20 @@ impl<'a> FallibleIterator for HstoreEntries<'a> { self.remaining -= 1; - let key_len = try!(self.buf.read_i32::()); + let key_len = self.buf.read_i32::()?; if key_len < 0 { return Err("invalid key length".into()); } let (key, buf) = self.buf.split_at(key_len as usize); - let key = try!(str::from_utf8(key)); + let key = str::from_utf8(key)?; self.buf = buf; - let value_len = try!(self.buf.read_i32::()); + let value_len = self.buf.read_i32::()?; let value = if value_len < 0 { None } else { let (value, buf) = self.buf.split_at(value_len as usize); - let value = try!(str::from_utf8(value)); + let value = str::from_utf8(value)?; self.buf = buf; Some(value) }; @@ -272,7 +274,7 @@ pub fn varbit_to_sql(len: usize, -> Result<(), StdBox> where I: Iterator { - let len = try!(i32::from_usize(len)); + let len = i32::from_usize(len)?; buf.write_i32::(len).unwrap(); for byte in v { @@ -285,7 +287,7 @@ pub fn varbit_to_sql(len: usize, /// Deserializes a `VARBIT` or `BIT` value. #[inline] pub fn varbit_from_sql<'a>(mut buf: &'a [u8]) -> Result, StdBox> { - let len = try!(buf.read_i32::()); + let len = buf.read_i32::()?; if len < 0 { return Err("invalid varbit length".into()); } @@ -295,9 +297,9 @@ pub fn varbit_from_sql<'a>(mut buf: &'a [u8]) -> Result, StdBox) { /// The value represents the number of microseconds since midnight, January 1st, 2000. #[inline] pub fn timestamp_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_i64::()); + let v = buf.read_i64::()?; if !buf.is_empty() { return Err("invalid message length".into()); } @@ -353,7 +355,7 @@ pub fn date_to_sql(v: i32, buf: &mut Vec) { /// The value represents the number of days since January 1st, 2000. #[inline] pub fn date_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_i32::()); + let v = buf.read_i32::()?; if !buf.is_empty() { return Err("invalid message length".into()); } @@ -373,7 +375,7 @@ pub fn time_to_sql(v: i64, buf: &mut Vec) { /// The value represents the number of microseconds since midnight. #[inline] pub fn time_from_sql(mut buf: &[u8]) -> Result> { - let v = try!(buf.read_i64::()); + let v = buf.read_i64::()?; if !buf.is_empty() { return Err("invalid message length".into()); } @@ -439,13 +441,13 @@ pub fn array_to_sql(dimensions: I, buf.write_i32::(dimension.lower_bound).unwrap(); } - let num_dimensions = try!(i32::from_usize(num_dimensions)); + let num_dimensions = i32::from_usize(num_dimensions)?; (&mut buf[dimensions_idx..dimensions_idx + 4]) .write_i32::(num_dimensions) .unwrap(); for element in elements { - try!(write_nullable(|buf| serializer(element, buf), buf)); + write_nullable(|buf| serializer(element, buf), buf)?; } Ok(()) @@ -454,21 +456,21 @@ pub fn array_to_sql(dimensions: I, /// Deserializes an array value. #[inline] pub fn array_from_sql<'a>(mut buf: &'a [u8]) -> Result, StdBox> { - let dimensions = try!(buf.read_i32::()); + let dimensions = buf.read_i32::()?; if dimensions < 0 { return Err("invalid dimension count".into()); } - let has_nulls = try!(buf.read_i32::()) != 0; - let element_type = try!(buf.read_u32::()); + let has_nulls = buf.read_i32::()? != 0; + let element_type = buf.read_u32::()?; let mut r = buf; let mut elements = 1i32; for _ in 0..dimensions { - let len = try!(r.read_i32::()); + let len = r.read_i32::()?; if len < 0 { return Err("invalid dimension size".into()); } - let _lower_bound = try!(r.read_i32::()); + let _lower_bound = r.read_i32::()?; elements = match elements.checked_mul(len) { Some(elements) => elements, None => return Err("too many array elements".into()), @@ -480,12 +482,12 @@ pub fn array_from_sql<'a>(mut buf: &'a [u8]) -> Result, StdBox FallibleIterator for ArrayDimensions<'a> { return Ok(None); } - let len = try!(self.0.read_i32::()); - let lower_bound = try!(self.0.read_i32::()); + let len = self.0.read_i32::()?; + let lower_bound = self.0.read_i32::()?; Ok(Some(ArrayDimension { - len: len, - lower_bound: lower_bound, - })) + len: len, + lower_bound: lower_bound, + })) } #[inline] @@ -585,7 +587,7 @@ impl<'a> FallibleIterator for ArrayValues<'a> { } self.remaining -= 1; - let len = try!(self.buf.read_i32::()); + let len = self.buf.read_i32::()?; let val = if len < 0 { None } else { @@ -625,13 +627,13 @@ pub fn range_to_sql(lower: F, buf.push(0); let mut tag = 0; - match try!(write_bound(lower, buf)) { + match write_bound(lower, buf)? { RangeBound::Inclusive(()) => tag |= RANGE_LOWER_INCLUSIVE, RangeBound::Exclusive(()) => {} RangeBound::Unbounded => tag |= RANGE_LOWER_UNBOUNDED, } - match try!(write_bound(upper, buf)) { + match write_bound(upper, buf)? { RangeBound::Inclusive(()) => tag |= RANGE_UPPER_INCLUSIVE, RangeBound::Exclusive(()) => {} RangeBound::Unbounded => tag |= RANGE_UPPER_UNBOUNDED, @@ -650,7 +652,7 @@ fn write_bound(bound: F, let base = buf.len(); buf.extend_from_slice(&[0; 4]); - let (null, ret) = match try!(bound(buf)) { + let (null, ret) = match bound(buf)? { RangeBound::Inclusive(null) => (Some(null), RangeBound::Inclusive(())), RangeBound::Exclusive(null) => (Some(null), RangeBound::Exclusive(())), RangeBound::Unbounded => (None, RangeBound::Unbounded), @@ -659,10 +661,12 @@ fn write_bound(bound: F, match null { Some(null) => { let len = match null { - IsNull::No => try!(i32::from_usize(buf.len() - base - 4)), + IsNull::No => i32::from_usize(buf.len() - base - 4)?, IsNull::Yes => -1, }; - (&mut buf[base..base + 4]).write_i32::(len).unwrap(); + (&mut buf[base..base + 4]) + .write_i32::(len) + .unwrap(); } None => buf.truncate(base), } @@ -683,7 +687,7 @@ pub enum RangeBound { /// Deserializes a range value. #[inline] pub fn range_from_sql<'a>(mut buf: &'a [u8]) -> Result, StdBox> { - let tag = try!(buf.read_u8()); + let tag = buf.read_u8()?; if tag == RANGE_EMPTY { if !buf.is_empty() { @@ -692,8 +696,8 @@ pub fn range_from_sql<'a>(mut buf: &'a [u8]) -> Result, StdBox(buf: &mut &'a [u8], if tag & unbounded != 0 { Ok(RangeBound::Unbounded) } else { - let len = try!(buf.read_i32::()); + let len = buf.read_i32::()?; let value = if len < 0 { None } else { @@ -750,8 +754,8 @@ pub fn point_to_sql(x: f64, y: f64, buf: &mut Vec) { /// Deserializes a point value. #[inline] pub fn point_from_sql(mut buf: &[u8]) -> Result> { - let x = try!(buf.read_f64::()); - let y = try!(buf.read_f64::()); + let x = buf.read_f64::()?; + let y = buf.read_f64::()?; if !buf.is_empty() { return Err("invalid buffer size".into()); } @@ -791,17 +795,17 @@ pub fn box_to_sql(x1: f64, y1: f64, x2: f64, y2: f64, buf: &mut Vec) { /// Deserializes a box value. #[inline] pub fn box_from_sql(mut buf: &[u8]) -> Result> { - let x1 = try!(buf.read_f64::()); - let y1 = try!(buf.read_f64::()); - let x2 = try!(buf.read_f64::()); - let y2 = try!(buf.read_f64::()); + let x1 = buf.read_f64::()?; + let y1 = buf.read_f64::()?; + let x2 = buf.read_f64::()?; + let y2 = buf.read_f64::()?; if !buf.is_empty() { return Err("invalid buffer size".into()); } Ok(Box { - upper_right: Point { x: x1, y: y1 }, - lower_left: Point { x: x2, y: y2 }, - }) + upper_right: Point { x: x1, y: y1 }, + lower_left: Point { x: x2, y: y2 }, + }) } /// A Postgres box. @@ -844,7 +848,7 @@ pub fn path_to_sql(closed: bool, buf.write_f64::(y).unwrap(); } - let num_points = try!(i32::from_usize(num_points)); + let num_points = i32::from_usize(num_points)?; (&mut buf[points_idx..]) .write_i32::(num_points) .unwrap(); @@ -855,14 +859,14 @@ pub fn path_to_sql(closed: bool, /// Deserializes a Postgres path. #[inline] pub fn path_from_sql<'a>(mut buf: &'a [u8]) -> Result, StdBox> { - let closed = try!(buf.read_u8()) != 0; - let points = try!(buf.read_i32::()); + let closed = buf.read_u8()? != 0; + let points = buf.read_i32::()?; Ok(Path { - closed: closed, - points: points, - buf: buf, - }) + closed: closed, + points: points, + buf: buf, + }) } /// A Postgres point. @@ -909,13 +913,10 @@ impl<'a> FallibleIterator for PathPoints<'a> { } self.remaining -= 1; - let x = try!(self.buf.read_f64::()); - let y = try!(self.buf.read_f64::()); + let x = self.buf.read_f64::()?; + let y = self.buf.read_f64::()?; - Ok(Some(Point { - x: x, - y: y, - })) + Ok(Some(Point { x: x, y: y })) } #[inline] @@ -987,7 +988,10 @@ mod test { let mut buf = vec![]; hstore_to_sql(map.iter().map(|(&k, &v)| (k, v)), &mut buf).unwrap(); - assert_eq!(hstore_from_sql(&buf).unwrap().collect::>().unwrap(), + assert_eq!(hstore_from_sql(&buf) + .unwrap() + .collect::>() + .unwrap(), map); } @@ -1028,7 +1032,7 @@ mod test { None => Ok(IsNull::Yes), }, &mut buf) - .unwrap(); + .unwrap(); let array = array_from_sql(&buf).unwrap(); assert_eq!(array.has_nulls(), true);