Skip to content

Commit c68b66f

Browse files
sfacklersfackler
committed
Upgrade to 2018
1 parent 9c37388 commit c68b66f

File tree

4 files changed

+86
-92
lines changed

4 files changed

+86
-92
lines changed

‎Cargo.toml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
name = "postgres_array"
33
version = "0.9.0"
44
authors = ["Steven Fackler <sfackler@gmail.com>"]
5+
edition = "2018"
56
license = "MIT"
67
description = "Array support for rust-postgres"
78
repository = "https://github.com/sfackler/rust-postgres-array"

‎src/array.rs‎

Lines changed: 33 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,9 @@
1+
use std::fmt;
12
use std::ops::{Index, IndexMut};
23
use std::slice;
34
use std::vec;
4-
use std::fmt;
55

6-
use Dimension;
6+
use crate::Dimension;
77

88
/// A multi-dimensional array.
99
#[derive(Debug, PartialEq, Eq, Clone)]
@@ -13,17 +13,17 @@ pub struct Array<T> {
1313
}
1414

1515
impl<T: fmt::Display> fmt::Display for Array<T> {
16-
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
16+
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
1717
if self.dims.iter().any(|dim| dim.lower_bound != 1) {
1818
for dim in &self.dims {
19-
try!(write!(
19+
write!(
2020
fmt,
2121
"[{}:{}]",
2222
dim.lower_bound,
2323
dim.lower_bound + dim.len - 1
24-
));
24+
)?;
2525
}
26-
try!(write!(fmt, "="));
26+
write!(fmt, "=")?;
2727
}
2828
fmt_helper(0, &self.dims, &mut self.data.iter(), fmt)
2929
}
@@ -32,8 +32,8 @@ impl<T: fmt::Display> fmt::Display for Array<T> {
3232
fn fmt_helper<'a, T, I>(
3333
depth: usize,
3434
dims: &[Dimension],
35-
mut data: &mut I,
36-
fmt: &mut fmt::Formatter,
35+
data: &mut I,
36+
fmt: &mut fmt::Formatter<'_>,
3737
) -> fmt::Result
3838
where
3939
I: Iterator<Item = &'a T>,
@@ -43,12 +43,12 @@ where
4343
return write!(fmt, "{}", data.next().unwrap());
4444
}
4545

46-
try!(write!(fmt, "{{"));
46+
write!(fmt, "{{")?;
4747
for i in 0..dims[depth].len {
4848
if i != 0 {
49-
try!(write!(fmt, ","));
49+
write!(fmt, ",")?;
5050
}
51-
try!(fmt_helper(depth + 1, dims, data, fmt));
51+
fmt_helper(depth + 1, dims, data, fmt)?;
5252
}
5353
write!(fmt, "}}")
5454
}
@@ -65,26 +65,24 @@ impl<T> Array<T> {
6565
/// elements specified by the dimensions.
6666
pub fn from_parts(data: Vec<T>, dimensions: Vec<Dimension>) -> Array<T> {
6767
assert!(
68-
(data.is_empty() && dimensions.is_empty()) ||
69-
data.len() as i32 == dimensions.iter().fold(1, |acc, i| acc * i.len),
68+
(data.is_empty() && dimensions.is_empty())
69+
|| data.len() as i32 == dimensions.iter().fold(1, |acc, i| acc * i.len),
7070
"size mismatch"
7171
);
7272
Array {
7373
dims: dimensions,
74-
data: data,
74+
data,
7575
}
7676
}
7777

7878
/// Creates a new one-dimensional array.
7979
pub fn from_vec(data: Vec<T>, lower_bound: i32) -> Array<T> {
8080
Array {
81-
dims: vec![
82-
Dimension {
83-
len: data.len() as i32,
84-
lower_bound: lower_bound,
85-
},
86-
],
87-
data: data,
81+
dims: vec![Dimension {
82+
len: data.len() as i32,
83+
lower_bound,
84+
}],
85+
data,
8886
}
8987
}
9088

@@ -97,7 +95,7 @@ impl<T> Array<T> {
9795
0,
9896
Dimension {
9997
len: 1,
100-
lower_bound: lower_bound,
98+
lower_bound,
10199
},
102100
);
103101
}
@@ -147,14 +145,18 @@ impl<T> Array<T> {
147145

148146
/// Returns an iterator over references to the elements of the array in the
149147
/// higher-dimensional equivalent of row-major order.
150-
pub fn iter<'a>(&'a self) -> Iter<'a, T> {
151-
Iter { inner: self.data.iter() }
148+
pub fn iter(&self) -> Iter<'_, T> {
149+
Iter {
150+
inner: self.data.iter(),
151+
}
152152
}
153153

154154
/// Returns an iterator over mutable references to the elements of the
155155
/// array in the higher-dimensional equivalent of row-major order.
156-
pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
157-
IterMut { inner: self.data.iter_mut() }
156+
pub fn iter_mut(&mut self) -> IterMut<'_, T> {
157+
IterMut {
158+
inner: self.data.iter_mut(),
159+
}
158160
}
159161

160162
/// Returns the underlying data vector for this Array in the
@@ -293,13 +295,15 @@ impl<T> IntoIterator for Array<T> {
293295
type IntoIter = IntoIter<T>;
294296

295297
fn into_iter(self) -> IntoIter<T> {
296-
IntoIter { inner: self.data.into_iter() }
298+
IntoIter {
299+
inner: self.data.into_iter(),
300+
}
297301
}
298302
}
299303

300304
/// An iterator over references to values of an `Array` in the
301305
/// higher-dimensional equivalent of row-major order.
302-
pub struct Iter<'a, T: 'a> {
306+
pub struct Iter<'a, T> {
303307
inner: slice::Iter<'a, T>,
304308
}
305309

@@ -329,7 +333,7 @@ impl<'a, T: 'a> ExactSizeIterator for Iter<'a, T> {
329333

330334
/// An iterator over mutable references to values of an `Array` in the
331335
/// higher-dimensional equivalent of row-major order.
332-
pub struct IterMut<'a, T: 'a> {
336+
pub struct IterMut<'a, T> {
333337
inner: slice::IterMut<'a, T>,
334338
}
335339

‎src/impls.rs‎

Lines changed: 45 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -1,41 +1,36 @@
11
use fallible_iterator::FallibleIterator;
2-
use postgres_shared::types::{Type, Kind, ToSql, FromSql, IsNull};
3-
use postgres_protocol::types;
42
use postgres_protocol;
3+
use postgres_protocol::types;
4+
use postgres_shared::to_sql_checked;
5+
use postgres_shared::types::{FromSql, IsNull, Kind, ToSql, Type};
56
use std::error::Error;
67

7-
use {Array, Dimension};
8+
use crate::{Array, Dimension};
89

910
impl<T> FromSql for Array<T>
1011
where
1112
T: FromSql,
1213
{
13-
fn from_sql(ty: &Type, raw: &[u8]) -> Result<Array<T>, Box<Error + Sync + Send>> {
14+
fn from_sql(ty: &Type, raw: &[u8]) -> Result<Array<T>, Box<dyn Error + Sync + Send>> {
1415
let element_type = match *ty.kind() {
1516
Kind::Array(ref ty) => ty,
1617
_ => unreachable!(),
1718
};
1819

19-
let array = try!(types::array_from_sql(raw));
20-
21-
let dimensions = try!(
22-
array
23-
.dimensions()
24-
.map(|d| {
25-
Dimension {
26-
len: d.len,
27-
lower_bound: d.lower_bound,
28-
}
29-
})
30-
.collect()
31-
);
20+
let array = types::array_from_sql(raw)?;
3221

33-
let elements = try!(
34-
array
35-
.values()
36-
.and_then(|v| FromSql::from_sql_nullable(element_type, v))
37-
.collect()
38-
);
22+
let dimensions = array
23+
.dimensions()
24+
.map(|d| Dimension {
25+
len: d.len,
26+
lower_bound: d.lower_bound,
27+
})
28+
.collect()?;
29+
30+
let elements = array
31+
.values()
32+
.and_then(|v| FromSql::from_sql_nullable(element_type, v))
33+
.collect()?;
3934

4035
Ok(Array::from_parts(elements, dimensions))
4136
}
@@ -52,21 +47,19 @@ impl<T> ToSql for Array<T>
5247
where
5348
T: ToSql,
5449
{
55-
fn to_sql(&self, ty: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
50+
fn to_sql(&self, ty: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
5651
let element_type = match ty.kind() {
5752
&Kind::Array(ref ty) => ty,
5853
_ => unreachable!(),
5954
};
6055

61-
let dimensions = self.dimensions().iter().map(|d| {
62-
types::ArrayDimension {
63-
len: d.len,
64-
lower_bound: d.lower_bound,
65-
}
56+
let dimensions = self.dimensions().iter().map(|d| types::ArrayDimension {
57+
len: d.len,
58+
lower_bound: d.lower_bound,
6659
});
6760
let elements = self.iter();
6861

69-
try!(types::array_to_sql(
62+
types::array_to_sql(
7063
dimensions,
7164
true,
7265
element_type.oid(),
@@ -77,7 +70,7 @@ where
7770
Err(e) => Err(e),
7871
},
7972
w,
80-
));
73+
)?;
8174

8275
Ok(IsNull::No)
8376
}
@@ -96,18 +89,19 @@ where
9689
mod test {
9790
use std::fmt;
9891

99-
use postgres::{Connection, TlsMode};
92+
use crate::Array;
10093
use postgres::types::{FromSql, ToSql};
101-
use Array;
94+
use postgres::{Connection, TlsMode};
10295

10396
fn test_type<T: PartialEq + FromSql + ToSql, S: fmt::Display>(
10497
sql_type: &str,
10598
checks: &[(T, S)],
10699
) {
107-
let conn = Connection::connect("postgres://postgres:password@localhost", TlsMode::None)
108-
.unwrap();
100+
let conn =
101+
Connection::connect("postgres://postgres:password@localhost", TlsMode::None).unwrap();
109102
for &(ref val, ref repr) in checks.iter() {
110-
let stmt = conn.prepare(&format!("SELECT {}::{}", *repr, sql_type))
103+
let stmt = conn
104+
.prepare(&format!("SELECT {}::{}", *repr, sql_type))
111105
.unwrap();
112106
let result = stmt.query(&[]).unwrap().iter().next().unwrap().get(0);
113107
assert!(val == &result);
@@ -119,19 +113,24 @@ mod test {
119113
}
120114

121115
macro_rules! test_array_params {
122-
($name:expr, $v1:expr, $s1:expr, $v2:expr, $s2:expr, $v3:expr, $s3:expr) => ({
123-
124-
let tests = &[(Some(Array::from_vec(vec!(Some($v1), Some($v2), None), 1)),
125-
format!("'{{{},{},NULL}}'", $s1, $s2)),
126-
(None, "NULL".to_string())];
116+
($name:expr, $v1:expr, $s1:expr, $v2:expr, $s2:expr, $v3:expr, $s3:expr) => {{
117+
let tests = &[
118+
(
119+
Some(Array::from_vec(vec![Some($v1), Some($v2), None], 1)),
120+
format!("'{{{},{},NULL}}'", $s1, $s2),
121+
),
122+
(None, "NULL".to_string()),
123+
];
127124
test_type(&format!("{}[]", $name), tests);
128-
let mut a = Array::from_vec(vec!(Some($v1), Some($v2)), 0);
125+
let mut a = Array::from_vec(vec![Some($v1), Some($v2)], 0);
129126
a.wrap(-1);
130-
a.push(Array::from_vec(vec!(None, Some($v3)), 0));
131-
let tests = &[(Some(a), format!("'[-1:0][0:1]={{{{{},{}}},{{NULL,{}}}}}'",
132-
$s1, $s2, $s3))];
127+
a.push(Array::from_vec(vec![None, Some($v3)], 0));
128+
let tests = &[(
129+
Some(a),
130+
format!("'[-1:0][0:1]={{{{{},{}}},{{NULL,{}}}}}'", $s1, $s2, $s3),
131+
)];
133132
test_type(&format!("{}[][]", $name), tests);
134-
})
133+
}};
135134
}
136135

137136
#[test]

‎src/lib.rs‎

Lines changed: 7 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,8 @@
11
//! Multi-dimensional arrays with per-dimension specifiable lower bounds
2-
#![doc(html_root_url="https://docs.rs/postgres_array/0.9.0")]
3-
4-
extern crate fallible_iterator;
5-
#[macro_use]
6-
extern crate postgres_shared;
7-
extern crate postgres_protocol;
8-
9-
#[cfg(test)]
10-
extern crate postgres;
2+
#![doc(html_root_url = "https://docs.rs/postgres_array/0.9.0")]
113

124
#[doc(inline)]
13-
pub use array::Array;
5+
pub use crate::array::Array;
146

157
pub mod array;
168
mod impls;
@@ -47,13 +39,11 @@ mod tests {
4739
fn test_from_vec() {
4840
let a = Array::from_vec(vec![0i32, 1, 2], -1);
4941
assert!(
50-
&[
51-
Dimension {
52-
len: 3,
53-
lower_bound: -1,
54-
},
55-
]
56-
[..] == a.dimensions()
42+
&[Dimension {
43+
len: 3,
44+
lower_bound: -1,
45+
},][..]
46+
== a.dimensions()
5747
);
5848
assert_eq!(0, a[-1]);
5949
assert_eq!(1, a[0]);

0 commit comments

Comments
 (0)