rustfmt

Author: sfackler

src/array.rs

@@ -16,7 +16,9 @@ impl<T: fmt::Display> fmt::Display for Array<T>{
 fnfmt(&self,fmt:&mut fmt::Formatter) -> fmt::Result{
 ifself.dims.iter().any(|dim| dim.lower_bound != 1){
 for dim in&self.dims{
- try!(write!(fmt,"[{}:{}]", dim.lower_bound,
+ try!(write!(fmt,
+"[{}:{}]",
+ dim.lower_bound,
  dim.lower_bound + dim.len asisize - 1));
 }
  try!(write!(fmt,"="));
@@ -30,7 +32,9 @@ fn fmt_helper<'a, T, I>(depth: usize,
 mutdata:&mutI,
 fmt:&mut fmt::Formatter)
  -> fmt::Result
-whereI:Iterator<Item=&'aT>,T:'a + fmt::Display{
+whereI:Iterator<Item = &'aT>,
+T:'a + fmt::Display
+{
 if depth == dims.len(){
 returnwrite!(fmt,"{}", data.next().unwrap());
 }
@@ -69,9 +73,9 @@ impl<T> Array<T>{
 pubfnfrom_vec(data:Vec<T>,lower_bound:isize) -> Array<T>{
 Array{
 dims:vec![Dimension{
- len: data.len(),
- lower_bound: lower_bound
-}],
+len: data.len(),
+lower_bound: lower_bound,
+}],
 data: data,
 }
 }
@@ -81,10 +85,11 @@ impl<T> Array<T>{
 /// For example, the one dimensional array `[1, 2]` would turn into the
 /// two-dimensional array `[[1, 2]]`.
 pubfnwrap(&mutself,lower_bound:isize){
-self.dims.insert(0,Dimension{
-len:1,
-lower_bound: lower_bound,
-});
+self.dims.insert(0,
+Dimension{
+len:1,
+lower_bound: lower_bound,
+});
 }
 
 /// Consumes another array, appending it to the top level dimension of this
@@ -131,17 +136,13 @@ impl<T> Array<T>{
 /// Returns an iterator over references to the elements of the array in the
 /// higher-dimensional equivalent of row-major order.
 pubfniter<'a>(&'aself) -> Iter<'a,T>{
-Iter{
-inner:self.data.iter(),
-}
+Iter{inner:self.data.iter()}
 }
 
 /// Returns an iterator over mutable references to the elements of the
 /// array in the higher-dimensional equivalent of row-major order.
 pubfniter_mut<'a>(&'amutself) -> IterMut<'a,T>{
-IterMut{
-inner:self.data.iter_mut(),
-}
+IterMut{inner:self.data.iter_mut()}
 }
 }
 
@@ -255,9 +256,7 @@ impl<T> IntoIterator for Array<T>{
 typeIntoIter = IntoIter<T>;
 
 fninto_iter(self) -> IntoIter<T>{
-IntoIter{
-inner:self.data.into_iter()
-}
+IntoIter{inner:self.data.into_iter()}
 }
 }
 

src/impls.rs

@@ -8,9 +8,10 @@ use postgres::types::{Type, Kind, ToSql, FromSql, Oid, IsNull, SessionInfo};
 
 use{Array,Dimension};
 
-impl<T>FromSqlforArray<T>whereT:FromSql{
-fnfrom_sql<R:Read>(ty:&Type,raw:&mutR,info:&SessionInfo)
- -> postgres::Result<Array<T>>{
+impl<T>FromSqlforArray<T>
+whereT:FromSql
+{
+fnfrom_sql<R:Read>(ty:&Type,raw:&mutR,info:&SessionInfo) -> postgres::Result<Array<T>>{
 let element_type = match ty.kind(){
 &Kind::Array(ref ty) => ty,
  _ => panic!("unexpected type{:?}", ty),
@@ -42,8 +43,9 @@ impl<T> FromSql for Array<T> where T: FromSql{
 letmut limit = raw.take(len asu64);
  elements.push(try!(FromSql::from_sql(&element_type,&mut limit, info)));
 if limit.limit() != 0{
-let err:Box<error::Error+Sync+Send> =
-"from_sql call did not consume all data".into();
+let err:Box<error::Error + Sync + Send> = "from_sql call did not consume all \
+ data"
+.into();
 returnErr(Error::Conversion(err));
 }
 }
@@ -55,14 +57,19 @@ impl<T> FromSql for Array<T> where T: FromSql{
 fnaccepts(ty:&Type) -> bool{
 match ty.kind(){
 &Kind::Array(ref ty) => <TasFromSql>::accepts(ty),
- _ => false
+ _ => false,
 }
 }
 }
 
-impl<T>ToSqlforArray<T>whereT:ToSql{
-fnto_sql<W: ?Sized+Write>(&self,ty:&Type,mutw:&mutW,info:&SessionInfo)
- -> postgres::Result<IsNull>{
+impl<T>ToSqlforArray<T>
+whereT:ToSql
+{
+fnto_sql<W: ?Sized + Write>(&self,
+ty:&Type,
+mutw:&mutW,
+info:&SessionInfo)
+ -> postgres::Result<IsNull>{
 let element_type = match ty.kind(){
 &Kind::Array(ref ty) => ty,
  _ => panic!("unexpected type{:?}", ty),
@@ -75,9 +82,9 @@ impl<T> ToSql for Array<T> where T: ToSql{
 for info inself.dimensions(){
  try!(w.write_i32::<BigEndian>(try!(downcast(info.len))));
 
-let bound = if info.lower_bound > i32::max_value()asisize
-|| info.lower_bound < i32::min_value()asisize{
-let err:Box<error::Error+Sync+Send> = "value too large to transmit".into();
+let bound = if info.lower_bound > i32::max_value()asisize ||
+ info.lower_bound < i32::min_value()asisize{
+let err:Box<error::Error + Sync + Send> = "value too large to transmit".into();
 returnErr(Error::Conversion(err));
 }else{
  info.lower_boundasi32
@@ -103,7 +110,7 @@ impl<T> ToSql for Array<T> where T: ToSql{
 fnaccepts(ty:&Type) -> bool{
 match ty.kind(){
 &Kind::Array(ref ty) => <TasToSql>::accepts(ty),
- _ => false
+ _ => false,
 }
 }
 
@@ -112,7 +119,7 @@ impl<T> ToSql for Array<T> where T: ToSql{
 
 fndowncast(len:usize) -> Result<i32>{
 if len > i32::max_value()asusize{
-let err:Box<error::Error+Sync+Send> = "value too large to transmit".into();
+let err:Box<error::Error + Sync + Send> = "value too large to transmit".into();
 Err(Error::Conversion(err))
 }else{
 Ok(len asi32)
@@ -127,7 +134,8 @@ mod test{
 use postgres::types::{FromSql,ToSql};
 useArray;
 
-fntest_type<T:PartialEq+FromSql+ToSql,S: fmt::Display>(sql_type:&str,checks:&[(T,S)]){
+fntest_type<T:PartialEq + FromSql + ToSql,S: fmt::Display>(sql_type:&str,
+checks:&[(T,S)]){
 let conn = Connection::connect("postgres://postgres@localhost",SslMode::None).unwrap();
 for&(ref val,ref repr)in checks.iter(){
 let stmt = conn.prepare(&format!("SELECT{}::{}",*repr, sql_type)).unwrap();
@@ -163,20 +171,29 @@ mod test{
 
 #[test]
 fntest_byteaarray_params(){
-test_array_params!("BYTEA", vec!(0u8,1),r#""\\x0001""#, vec!(254u8,255u8),
-r#""\\xfeff""#, vec!(10u8,11u8),r#""\\x0a0b""#);
+test_array_params!("BYTEA",
+ vec![0u8,1],
+r#""\\x0001""#,
+ vec![254u8,255u8],
+r#""\\xfeff""#,
+ vec![10u8,11u8],
+r#""\\x0a0b""#);
 }
 
 #[test]
 fntest_chararray_params(){
-test_array_params!("\"char\"",'a'asi8,"a",'z'asi8,"z",
-'0'asi8,"0");
+test_array_params!("\"char\"",'a'asi8,"a",'z'asi8,"z",'0'asi8,"0");
 }
 
 #[test]
 fntest_namearray_params(){
-test_array_params!("NAME","hello".to_string(),"hello","world".to_string(),
-"world","!".to_string(),"!");
+test_array_params!("NAME",
+"hello".to_string(),
+"hello",
+"world".to_string(),
+"world",
+"!".to_string(),
+"!");
 }
 
 #[test]
@@ -191,20 +208,35 @@ mod test{
 
 #[test]
 fntest_textarray_params(){
-test_array_params!("TEXT","hello".to_string(),"hello","world".to_string(),
-"world","!".to_string(),"!");
+test_array_params!("TEXT",
+"hello".to_string(),
+"hello",
+"world".to_string(),
+"world",
+"!".to_string(),
+"!");
 }
 
 #[test]
 fntest_charnarray_params(){
-test_array_params!("CHAR(5)","hello".to_string(),"hello",
-"world".to_string(),"world","! ".to_string(),"!");
+test_array_params!("CHAR(5)",
+"hello".to_string(),
+"hello",
+"world".to_string(),
+"world",
+"! ".to_string(),
+"!");
 }
 
 #[test]
 fntest_varchararray_params(){
-test_array_params!("VARCHAR","hello".to_string(),"hello",
-"world".to_string(),"world","!".to_string(),"!");
+test_array_params!("VARCHAR",
+"hello".to_string(),
+"hello",
+"world".to_string(),
+"world",
+"!".to_string(),
+"!");
 }
 
 #[test]

src/lib.rs

@@ -38,17 +38,19 @@ mod tests{
 
 #[test]
 fntest_from_vec(){
-let a = Array::from_vec(vec!(0i32,1,2), -1);
-assert!(&[Dimension{ len:3, lower_bound: -1}][..] ==
- a.dimensions());
+let a = Array::from_vec(vec![0i32,1,2], -1);
+assert!(&[Dimension{
+ len:3,
+ lower_bound: -1,
+}][..] == a.dimensions());
 assert_eq!(0, a[-1]);
 assert_eq!(1, a[0]);
 assert_eq!(2, a[1]);
 }
 
 #[test]
 fntest_2d_slice_get(){
-letmut a = Array::from_vec(vec!(0i32,1,2), -1);
+letmut a = Array::from_vec(vec![0i32,1,2], -1);
  a.wrap(1);
 assert_eq!(0, a[(1, -1)]);
 assert_eq!(1, a[(1,0)]);
@@ -58,33 +60,33 @@ mod tests{
 #[test]
 #[should_panic]
 fntest_push_wrong_lower_bound(){
-letmut a = Array::from_vec(vec!(1i32), -1);
- a.push(Array::from_vec(vec!(2),0));
+letmut a = Array::from_vec(vec![1i32], -1);
+ a.push(Array::from_vec(vec![2],0));
 }
 
 #[test]
 #[should_panic]
 fntest_push_wrong_dims(){
-letmut a = Array::from_vec(vec!(1i32), -1);
+letmut a = Array::from_vec(vec![1i32], -1);
  a.wrap(1);
- a.push(Array::from_vec(vec!(1,2), -1));
+ a.push(Array::from_vec(vec![1,2], -1));
 }
 
 #[test]
 #[should_panic]
 fntest_push_wrong_dim_count(){
-letmut a = Array::from_vec(vec!(1i32), -1);
+letmut a = Array::from_vec(vec![1i32], -1);
  a.wrap(1);
-letmut b = Array::from_vec(vec!(2), -1);
+letmut b = Array::from_vec(vec![2], -1);
  b.wrap(1);
  a.push(b);
 }
 
 #[test]
 fntest_push_ok(){
-letmut a = Array::from_vec(vec!(1i32,2),0);
+letmut a = Array::from_vec(vec![1i32,2],0);
  a.wrap(0);
- a.push(Array::from_vec(vec!(3,4),0));
+ a.push(Array::from_vec(vec![3,4],0));
 assert_eq!(1, a[(0,0)]);
 assert_eq!(2, a[(0,1)]);
 assert_eq!(3, a[(1,0)]);
@@ -93,13 +95,13 @@ mod tests{
 
 #[test]
 fntest_3d(){
-letmut a = Array::from_vec(vec!(0i32,1),0);
+letmut a = Array::from_vec(vec![0i32,1],0);
  a.wrap(0);
- a.push(Array::from_vec(vec!(2,3),0));
+ a.push(Array::from_vec(vec![2,3],0));
  a.wrap(0);
-letmut b = Array::from_vec(vec!(4,5),0);
+letmut b = Array::from_vec(vec![4,5],0);
  b.wrap(0);
- b.push(Array::from_vec(vec!(6,7),0));
+ b.push(Array::from_vec(vec![6,7],0));
  a.push(b);
 assert_eq!(0, a[(0,0,0)]);
 assert_eq!(1, a[(0,0,1)]);
@@ -113,7 +115,7 @@ mod tests{
 
 #[test]
 fntest_mut(){
-letmut a = Array::from_vec(vec!(1i32,2),0);
+letmut a = Array::from_vec(vec![1i32,2],0);
  a.wrap(0);
  a[(0,0)] = 3;
 assert_eq!(3, a[(0,0)]);