Replace try macros with ? operator

pka · pka · commit c59d3e698265 · 2016-12-04T21:18:21.000+01:00
diff --git a/src/ewkb.rs b/src/ewkb.rs
@@ -67,13 +67,13 @@ pub trait EwkbRead: fmt::Debug + Sized {
     }
 
     fn read_ewkb<R: Read>(raw: &mut R) -> Result<Self, Error> {
-        let byte_order = try!(raw.read_i8());
+        let byte_order = raw.read_i8()?;
         let is_be = byte_order == 0i8;
 
-        let type_id = try!(read_u32(raw, is_be));
+        let type_id = read_u32(raw, is_be)?;
         let mut srid: Option<i32> = None;
         if type_id & 0x20000000 == 0x20000000 {
-           srid = Some(try!(read_i32(raw, is_be)));
+           srid = Some(read_i32(raw, is_be)?);
         }
         Self::read_ewkb_body(raw, is_be, srid)
     }
@@ -107,11 +107,11 @@ pub trait EwkbWrite: fmt::Debug + Sized {
 
     fn write_ewkb<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {
         // use LE
-        try!(w.write_u8(0x01));
+        w.write_u8(0x01)?;
         let type_id = self.type_id();
-        try!(w.write_u32::<LittleEndian>(type_id));
+        w.write_u32::<LittleEndian>(type_id)?;
         self.opt_srid().map(|srid| w.write_i32::<LittleEndian>(srid));
-        try!(self.write_ewkb_body(w));
+        self.write_ewkb_body(w)?;
         Ok(())
     }
     fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error>;
@@ -259,15 +259,15 @@ macro_rules! impl_point_read_traits {
                 self.srid = srid;
             }
             fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {
-                let x = try!(read_f64(raw, is_be));
-                let y = try!(read_f64(raw, is_be));
+                let x = read_f64(raw, is_be)?;
+                let y = read_f64(raw, is_be)?;
                 let z = if Self::has_z() {
-                    Some(try!(read_f64(raw, is_be)))
+                    Some(read_f64(raw, is_be)?)
                 } else {
                     None
                 };
                 let m = if Self::has_m() {
-                    Some(try!(read_f64(raw, is_be)))
+                    Some(read_f64(raw, is_be)?)
                 } else {
                     None
                 };
@@ -301,7 +301,7 @@ pub trait AsEwkbPoint<'a> {
 
 impl<'a> fmt::Debug for EwkbPoint<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "EwkbPoint")); //TODO
+        write!(f, "EwkbPoint")?; //TODO
         Ok(())
     }
 }
@@ -314,29 +314,14 @@ impl<'a> EwkbWrite for EwkbPoint<'a> {
         self.srid
     }
     fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {
-        try!(w.write_f64::<LittleEndian>(self.geom.x()));
-        try!(w.write_f64::<LittleEndian>(self.geom.y()));
+        w.write_f64::<LittleEndian>(self.geom.x())?;
+        w.write_f64::<LittleEndian>(self.geom.y())?;
         self.geom.opt_z().map(|z| w.write_f64::<LittleEndian>(z));
         self.geom.opt_m().map(|m| w.write_f64::<LittleEndian>(m));
         Ok(())
     }
 }
 
-/*
-impl EwkbWrite for Point {
-    fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {
-        //lol
-        let x = unsafe { *mem::transmute::<_, *const f64>(self) };
-        let y = unsafe { *mem::transmute::<_, *const f64>(self).offset(1) };
-        try!(w.write_f64::<LittleEndian>(x));
-        try!(w.write_f64::<LittleEndian>(y));
-        self.opt_z().map(|z| w.write_f64::<LittleEndian>(z));
-        self.opt_m().map(|m| w.write_f64::<LittleEndian>(m));
-        Ok(())
-     }
-}
-*/
-
 
 macro_rules! point_container_type {
     // geometries containing points
@@ -441,7 +426,7 @@ macro_rules! impl_read_for_point_container_type {
             }
             fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {
                 let mut points: Vec<P> = vec![];
-                let size = try!(read_u32(raw, is_be)) as usize;
+                let size = read_u32(raw, is_be)? as usize;
                 for _ in 0..size {
                     points.push(P::read_ewkb_body(raw, is_be, srid)?);
                 }
@@ -462,7 +447,7 @@ macro_rules! impl_read_for_point_container_type {
             }
             fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {
                 let mut points: Vec<P> = vec![];
-                let size = try!(read_u32(raw, is_be)) as usize;
+                let size = read_u32(raw, is_be)? as usize;
                 for _ in 0..size {
                     points.push(P::read_ewkb(raw)?);
                 }
@@ -485,7 +470,7 @@ macro_rules! impl_read_for_geometry_container_type {
             }
             fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {
                 let mut $itemname: Vec<$itemtype<P>> = vec![];
-                let size = try!(read_u32(raw, is_be)) as usize;
+                let size = read_u32(raw, is_be)? as usize;
                 for _ in 0..size {
                     $itemname.push($itemtype::read_ewkb_body(raw, is_be, srid)?);
                  }
@@ -505,7 +490,7 @@ macro_rules! impl_read_for_geometry_container_type {
             }
             fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {
                 let mut $itemname: Vec<$itemtype<P>> = vec![];
-                let size = try!(read_u32(raw, is_be)) as usize;
+                let size = read_u32(raw, is_be)? as usize;
                 for _ in 0..size {
                     $itemname.push($itemtype::read_ewkb(raw)?);
                  }
@@ -538,7 +523,7 @@ macro_rules! point_container_write {
                   I: 'a + Iterator<Item=&'a T> + ExactSizeIterator<Item=&'a T>
         {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                try!(write!(f, "$ewkbtype")); //TODO
+                write!(f, "$ewkbtype")?; //TODO
                 Ok(())
             }
         }
@@ -556,10 +541,10 @@ macro_rules! point_container_write {
             }
 
             fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {
-                try!(w.write_u32::<LittleEndian>(self.geom.points().len() as u32));
+                w.write_u32::<LittleEndian>(self.geom.points().len() as u32)?;
                 for geom in self.geom.points() {
                     let wkb = EwkbPoint { geom: geom, srid: None, point_type: self.point_type.clone() };
-                    try!(wkb.$writecmd(w));
+                    wkb.$writecmd(w)?;
                 }
                 Ok(())
             }
@@ -606,7 +591,7 @@ macro_rules! geometry_container_write {
                   J: 'a + Iterator<Item=&'a T> + ExactSizeIterator<Item=&'a T>
         {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                try!(write!(f, "$ewkbtype")); //TODO
+                write!(f, "$ewkbtype")?; //TODO
                 Ok(())
             }
         }
@@ -626,10 +611,10 @@ macro_rules! geometry_container_write {
             }
 
             fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {
-                try!(w.write_u32::<LittleEndian>(self.geom.$itemname().len() as u32));
+                w.write_u32::<LittleEndian>(self.geom.$itemname().len() as u32)?;
                 for geom in self.geom.$itemname() {
                     let wkb = $ewkbitemtype { geom: geom, srid: None, point_type: self.point_type.clone() };
-                    try!(wkb.$writecmd(w));
+                    wkb.$writecmd(w)?;
                 }
                 Ok(())
             }
@@ -680,7 +665,7 @@ macro_rules! geometry_container_write {
                   J: 'a + Iterator<Item=&'a T> + ExactSizeIterator<Item=&'a T>
         {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                try!(write!(f, "$ewkbtype")); //TODO
+                write!(f, "$ewkbtype")?; //TODO
                 Ok(())
             }
         }
@@ -702,10 +687,10 @@ macro_rules! geometry_container_write {
             }
 
             fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {
-                try!(w.write_u32::<LittleEndian>(self.geom.$itemname().len() as u32));
+                w.write_u32::<LittleEndian>(self.geom.$itemname().len() as u32)?;
                 for geom in self.geom.$itemname() {
                     let wkb = $ewkbitemtype { geom: geom, srid: None, point_type: self.point_type.clone() };
-                    try!(wkb.$writecmd(w));
+                    wkb.$writecmd(w)?;
                 }
                 Ok(())
             }
@@ -813,13 +798,13 @@ impl<P> EwkbRead for GeometryT<P>
         P::point_type()
     }
     fn read_ewkb<R: Read>(raw: &mut R) -> Result<Self, Error> {
-        let byte_order = try!(raw.read_i8());
+        let byte_order = raw.read_i8()?;
         let is_be = byte_order == 0i8;
 
-        let type_id = try!(read_u32(raw, is_be));
+        let type_id = read_u32(raw, is_be)?;
         let mut srid: Option<i32> = None;
         if type_id & 0x20000000 == 0x20000000 {
-           srid = Some(try!(read_i32(raw, is_be)));
+           srid = Some(read_i32(raw, is_be)?);
         }
 
         let geom = match type_id & 0xff {
@@ -867,14 +852,14 @@ impl<P> EwkbRead for GeometryCollectionT<P>
     }
     fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, _srid: Option<i32>) -> Result<Self, Error> {
         let mut ret = GeometryCollectionT::new();
-        let size = try!(read_u32(raw, is_be)) as usize;
+        let size = read_u32(raw, is_be)? as usize;
         for _ in 0..size {
-            let is_be = try!(raw.read_i8()) == 0i8;
+            let is_be = raw.read_i8()? == 0i8;
 
-            let type_id = try!(read_u32(raw, is_be));
+            let type_id = read_u32(raw, is_be)?;
             let mut srid: Option<i32> = None;
             if type_id & 0x20000000 == 0x20000000 {
-               srid = Some(try!(read_i32(raw, is_be)));
+               srid = Some(read_i32(raw, is_be)?);
             }
             let geom = match type_id & 0xff {
                 0x01 => GeometryT::Point(P::read_ewkb_body(raw, is_be, srid)?),
diff --git a/src/postgis.rs b/src/postgis.rs
@@ -27,7 +27,7 @@ impl<'a> ToSql for ewkb::EwkbPoint<'a> {
     to_sql_checked!();
     accepts_geography!();
     fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {
-        try!(self.write_ewkb(out));
+        self.write_ewkb(out)?;
         Ok(IsNull::No)
     }
 }
@@ -46,7 +46,7 @@ macro_rules! impl_sql_for_point_type {
             to_sql_checked!();
             accepts_geography!();
             fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {
-                try!(self.as_ewkb().write_ewkb(out));
+                self.as_ewkb().write_ewkb(out)?;
                 Ok(IsNull::No)
             }
         }
@@ -77,7 +77,7 @@ macro_rules! impl_sql_for_geom_type {
             to_sql_checked!();
             accepts_geography!();
             fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {
-                try!(self.as_ewkb().write_ewkb(out));
+                self.as_ewkb().write_ewkb(out)?;
                 Ok(IsNull::No)
             }
         }
@@ -100,7 +100,7 @@ macro_rules! impl_sql_for_ewkb_type {
             to_sql_checked!();
             accepts_geography!();
             fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {
-                try!(self.write_ewkb(out));
+                self.write_ewkb(out)?;
                 Ok(IsNull::No)
             }
         }
@@ -115,7 +115,7 @@ macro_rules! impl_sql_for_ewkb_type {
             to_sql_checked!();
             accepts_geography!();
             fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {
-                try!(self.write_ewkb(out));
+                self.write_ewkb(out)?;
                 Ok(IsNull::No)
             }
         }
@@ -132,7 +132,7 @@ macro_rules! impl_sql_for_ewkb_type {
             to_sql_checked!();
             accepts_geography!();
             fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {
-                try!(self.write_ewkb(out));
+                self.write_ewkb(out)?;
                 Ok(IsNull::No)
             }
         }
diff --git a/src/twkb.rs b/src/twkb.rs

Original file line number	Diff line number	Diff line change
`@@ -67,13 +67,13 @@ pub trait EwkbRead: fmt::Debug + Sized {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`fn read_ewkb<R: Read>(raw: &mut R) -> Result<Self, Error> {`
`70`		`- let byte_order = try!(raw.read_i8());`
	`70`	`+ let byte_order = raw.read_i8()?;`
`71`	`71`	`let is_be = byte_order == 0i8;`
`72`	`72`
`73`		`- let type_id = try!(read_u32(raw, is_be));`
	`73`	`+ let type_id = read_u32(raw, is_be)?;`
`74`	`74`	`let mut srid: Option<i32> = None;`
`75`	`75`	`if type_id & 0x20000000 == 0x20000000 {`
`76`		`- srid = Some(try!(read_i32(raw, is_be)));`
	`76`	`+ srid = Some(read_i32(raw, is_be)?);`
`77`	`77`	`}`
`78`	`78`	`Self::read_ewkb_body(raw, is_be, srid)`
`79`	`79`	`}`
`@@ -107,11 +107,11 @@ pub trait EwkbWrite: fmt::Debug + Sized {`
`107`	`107`
`108`	`108`	`fn write_ewkb<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {`
`109`	`109`	`// use LE`
`110`		`- try!(w.write_u8(0x01));`
	`110`	`+ w.write_u8(0x01)?;`
`111`	`111`	`let type_id = self.type_id();`
`112`		`- try!(w.write_u32::<LittleEndian>(type_id));`
	`112`	`+ w.write_u32::<LittleEndian>(type_id)?;`
`113`	`113`	`self.opt_srid().map(\|srid\| w.write_i32::<LittleEndian>(srid));`
`114`		`- try!(self.write_ewkb_body(w));`
	`114`	`+ self.write_ewkb_body(w)?;`
`115`	`115`	`Ok(())`
`116`	`116`	`}`
`117`	`117`	`fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error>;`
`@@ -259,15 +259,15 @@ macro_rules! impl_point_read_traits {`
`259`	`259`	`self.srid = srid;`
`260`	`260`	`}`
`261`	`261`	`fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {`
`262`		`- let x = try!(read_f64(raw, is_be));`
`263`		`- let y = try!(read_f64(raw, is_be));`
	`262`	`+ let x = read_f64(raw, is_be)?;`
	`263`	`+ let y = read_f64(raw, is_be)?;`
`264`	`264`	`let z = if Self::has_z() {`
`265`		`- Some(try!(read_f64(raw, is_be)))`
	`265`	`+ Some(read_f64(raw, is_be)?)`
`266`	`266`	`} else {`
`267`	`267`	`None`
`268`	`268`	`};`
`269`	`269`	`let m = if Self::has_m() {`
`270`		`- Some(try!(read_f64(raw, is_be)))`
	`270`	`+ Some(read_f64(raw, is_be)?)`
`271`	`271`	`} else {`
`272`	`272`	`None`
`273`	`273`	`};`
`@@ -301,7 +301,7 @@ pub trait AsEwkbPoint<'a> {`
`301`	`301`
`302`	`302`	`impl<'a> fmt::Debug for EwkbPoint<'a> {`
`303`	`303`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`304`		`- try!(write!(f, "EwkbPoint")); //TODO`
	`304`	`+ write!(f, "EwkbPoint")?; //TODO`
`305`	`305`	`Ok(())`
`306`	`306`	`}`
`307`	`307`	`}`
`@@ -314,29 +314,14 @@ impl<'a> EwkbWrite for EwkbPoint<'a> {`
`314`	`314`	`self.srid`
`315`	`315`	`}`
`316`	`316`	`fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {`
`317`		`- try!(w.write_f64::<LittleEndian>(self.geom.x()));`
`318`		`- try!(w.write_f64::<LittleEndian>(self.geom.y()));`
	`317`	`+ w.write_f64::<LittleEndian>(self.geom.x())?;`
	`318`	`+ w.write_f64::<LittleEndian>(self.geom.y())?;`
`319`	`319`	`self.geom.opt_z().map(\|z\| w.write_f64::<LittleEndian>(z));`
`320`	`320`	`self.geom.opt_m().map(\|m\| w.write_f64::<LittleEndian>(m));`
`321`	`321`	`Ok(())`
`322`	`322`	`}`
`323`	`323`	`}`
`324`	`324`
`325`		`-/*`
`326`		`-impl EwkbWrite for Point {`
`327`		`- fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {`
`328`		`- //lol`
`329`		`- let x = unsafe { mem::transmute::<_, const f64>(self) };`
`330`		`- let y = unsafe { mem::transmute::<_, const f64>(self).offset(1) };`
`331`		`- try!(w.write_f64::<LittleEndian>(x));`
`332`		`- try!(w.write_f64::<LittleEndian>(y));`
`333`		`- self.opt_z().map(\|z\| w.write_f64::<LittleEndian>(z));`
`334`		`- self.opt_m().map(\|m\| w.write_f64::<LittleEndian>(m));`
`335`		`- Ok(())`
`336`		`- }`
`337`		`-}`
`338`		`-*/`
`339`		`-`
`340`	`325`
`341`	`326`	`macro_rules! point_container_type {`
`342`	`327`	`// geometries containing points`
`@@ -441,7 +426,7 @@ macro_rules! impl_read_for_point_container_type {`
`441`	`426`	`}`
`442`	`427`	`fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {`
`443`	`428`	`let mut points: Vec<P> = vec![];`
`444`		`- let size = try!(read_u32(raw, is_be)) as usize;`
	`429`	`+ let size = read_u32(raw, is_be)? as usize;`
`445`	`430`	`for _ in 0..size {`
`446`	`431`	`points.push(P::read_ewkb_body(raw, is_be, srid)?);`
`447`	`432`	`}`
`@@ -462,7 +447,7 @@ macro_rules! impl_read_for_point_container_type {`
`462`	`447`	`}`
`463`	`448`	`fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {`
`464`	`449`	`let mut points: Vec<P> = vec![];`
`465`		`- let size = try!(read_u32(raw, is_be)) as usize;`
	`450`	`+ let size = read_u32(raw, is_be)? as usize;`
`466`	`451`	`for _ in 0..size {`
`467`	`452`	`points.push(P::read_ewkb(raw)?);`
`468`	`453`	`}`
`@@ -485,7 +470,7 @@ macro_rules! impl_read_for_geometry_container_type {`
`485`	`470`	`}`
`486`	`471`	`fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {`
`487`	`472`	`let mut $itemname: Vec<$itemtype<P>> = vec![];`
`488`		`- let size = try!(read_u32(raw, is_be)) as usize;`
	`473`	`+ let size = read_u32(raw, is_be)? as usize;`
`489`	`474`	`for _ in 0..size {`
`490`	`475`	`$itemname.push($itemtype::read_ewkb_body(raw, is_be, srid)?);`
`491`	`476`	`}`
`@@ -505,7 +490,7 @@ macro_rules! impl_read_for_geometry_container_type {`
`505`	`490`	`}`
`506`	`491`	`fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, srid: Option<i32>) -> Result<Self, Error> {`
`507`	`492`	`let mut $itemname: Vec<$itemtype<P>> = vec![];`
`508`		`- let size = try!(read_u32(raw, is_be)) as usize;`
	`493`	`+ let size = read_u32(raw, is_be)? as usize;`
`509`	`494`	`for _ in 0..size {`
`510`	`495`	`$itemname.push($itemtype::read_ewkb(raw)?);`
`511`	`496`	`}`
`@@ -538,7 +523,7 @@ macro_rules! point_container_write {`
`538`	`523`	`I: 'a + Iterator<Item=&'a T> + ExactSizeIterator<Item=&'a T>`
`539`	`524`	`{`
`540`	`525`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`541`		`- try!(write!(f, "$ewkbtype")); //TODO`
	`526`	`+ write!(f, "$ewkbtype")?; //TODO`
`542`	`527`	`Ok(())`
`543`	`528`	`}`
`544`	`529`	`}`
`@@ -556,10 +541,10 @@ macro_rules! point_container_write {`
`556`	`541`	`}`
`557`	`542`
`558`	`543`	`fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {`
`559`		`- try!(w.write_u32::<LittleEndian>(self.geom.points().len() as u32));`
	`544`	`+ w.write_u32::<LittleEndian>(self.geom.points().len() as u32)?;`
`560`	`545`	`for geom in self.geom.points() {`
`561`	`546`	`let wkb = EwkbPoint { geom: geom, srid: None, point_type: self.point_type.clone() };`
`562`		`- try!(wkb.$writecmd(w));`
	`547`	`+ wkb.$writecmd(w)?;`
`563`	`548`	`}`
`564`	`549`	`Ok(())`
`565`	`550`	`}`
`@@ -606,7 +591,7 @@ macro_rules! geometry_container_write {`
`606`	`591`	`J: 'a + Iterator<Item=&'a T> + ExactSizeIterator<Item=&'a T>`
`607`	`592`	`{`
`608`	`593`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`609`		`- try!(write!(f, "$ewkbtype")); //TODO`
	`594`	`+ write!(f, "$ewkbtype")?; //TODO`
`610`	`595`	`Ok(())`
`611`	`596`	`}`
`612`	`597`	`}`
`@@ -626,10 +611,10 @@ macro_rules! geometry_container_write {`
`626`	`611`	`}`
`627`	`612`
`628`	`613`	`fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {`
`629`		`- try!(w.write_u32::<LittleEndian>(self.geom.$itemname().len() as u32));`
	`614`	`+ w.write_u32::<LittleEndian>(self.geom.$itemname().len() as u32)?;`
`630`	`615`	`for geom in self.geom.$itemname() {`
`631`	`616`	`let wkb = $ewkbitemtype { geom: geom, srid: None, point_type: self.point_type.clone() };`
`632`		`- try!(wkb.$writecmd(w));`
	`617`	`+ wkb.$writecmd(w)?;`
`633`	`618`	`}`
`634`	`619`	`Ok(())`
`635`	`620`	`}`
`@@ -680,7 +665,7 @@ macro_rules! geometry_container_write {`
`680`	`665`	`J: 'a + Iterator<Item=&'a T> + ExactSizeIterator<Item=&'a T>`
`681`	`666`	`{`
`682`	`667`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`683`		`- try!(write!(f, "$ewkbtype")); //TODO`
	`668`	`+ write!(f, "$ewkbtype")?; //TODO`
`684`	`669`	`Ok(())`
`685`	`670`	`}`
`686`	`671`	`}`
`@@ -702,10 +687,10 @@ macro_rules! geometry_container_write {`
`702`	`687`	`}`
`703`	`688`
`704`	`689`	`fn write_ewkb_body<W: Write+?Sized>(&self, w: &mut W) -> Result<(), Error> {`
`705`		`- try!(w.write_u32::<LittleEndian>(self.geom.$itemname().len() as u32));`
	`690`	`+ w.write_u32::<LittleEndian>(self.geom.$itemname().len() as u32)?;`
`706`	`691`	`for geom in self.geom.$itemname() {`
`707`	`692`	`let wkb = $ewkbitemtype { geom: geom, srid: None, point_type: self.point_type.clone() };`
`708`		`- try!(wkb.$writecmd(w));`
	`693`	`+ wkb.$writecmd(w)?;`
`709`	`694`	`}`
`710`	`695`	`Ok(())`
`711`	`696`	`}`
`@@ -813,13 +798,13 @@ impl<P> EwkbRead for GeometryT<P>`
`813`	`798`	`P::point_type()`
`814`	`799`	`}`
`815`	`800`	`fn read_ewkb<R: Read>(raw: &mut R) -> Result<Self, Error> {`
`816`		`- let byte_order = try!(raw.read_i8());`
	`801`	`+ let byte_order = raw.read_i8()?;`
`817`	`802`	`let is_be = byte_order == 0i8;`
`818`	`803`
`819`		`- let type_id = try!(read_u32(raw, is_be));`
	`804`	`+ let type_id = read_u32(raw, is_be)?;`
`820`	`805`	`let mut srid: Option<i32> = None;`
`821`	`806`	`if type_id & 0x20000000 == 0x20000000 {`
`822`		`- srid = Some(try!(read_i32(raw, is_be)));`
	`807`	`+ srid = Some(read_i32(raw, is_be)?);`
`823`	`808`	`}`
`824`	`809`
`825`	`810`	`let geom = match type_id & 0xff {`
`@@ -867,14 +852,14 @@ impl<P> EwkbRead for GeometryCollectionT<P>`
`867`	`852`	`}`
`868`	`853`	`fn read_ewkb_body<R: Read>(raw: &mut R, is_be: bool, _srid: Option<i32>) -> Result<Self, Error> {`
`869`	`854`	`let mut ret = GeometryCollectionT::new();`
`870`		`- let size = try!(read_u32(raw, is_be)) as usize;`
	`855`	`+ let size = read_u32(raw, is_be)? as usize;`
`871`	`856`	`for _ in 0..size {`
`872`		`- let is_be = try!(raw.read_i8()) == 0i8;`
	`857`	`+ let is_be = raw.read_i8()? == 0i8;`
`873`	`858`
`874`		`- let type_id = try!(read_u32(raw, is_be));`
	`859`	`+ let type_id = read_u32(raw, is_be)?;`
`875`	`860`	`let mut srid: Option<i32> = None;`
`876`	`861`	`if type_id & 0x20000000 == 0x20000000 {`
`877`		`- srid = Some(try!(read_i32(raw, is_be)));`
	`862`	`+ srid = Some(read_i32(raw, is_be)?);`
`878`	`863`	`}`
`879`	`864`	`let geom = match type_id & 0xff {`
`880`	`865`	`0x01 => GeometryT::Point(P::read_ewkb_body(raw, is_be, srid)?),`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ impl<'a> ToSql for ewkb::EwkbPoint<'a> {`
`27`	`27`	`to_sql_checked!();`
`28`	`28`	`accepts_geography!();`
`29`	`29`	`fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {`
`30`		`- try!(self.write_ewkb(out));`
	`30`	`+ self.write_ewkb(out)?;`
`31`	`31`	`Ok(IsNull::No)`
`32`	`32`	`}`
`33`	`33`	`}`
`@@ -46,7 +46,7 @@ macro_rules! impl_sql_for_point_type {`
`46`	`46`	`to_sql_checked!();`
`47`	`47`	`accepts_geography!();`
`48`	`48`	`fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {`
`49`		`- try!(self.as_ewkb().write_ewkb(out));`
	`49`	`+ self.as_ewkb().write_ewkb(out)?;`
`50`	`50`	`Ok(IsNull::No)`
`51`	`51`	`}`
`52`	`52`	`}`
`@@ -77,7 +77,7 @@ macro_rules! impl_sql_for_geom_type {`
`77`	`77`	`to_sql_checked!();`
`78`	`78`	`accepts_geography!();`
`79`	`79`	`fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {`
`80`		`- try!(self.as_ewkb().write_ewkb(out));`
	`80`	`+ self.as_ewkb().write_ewkb(out)?;`
`81`	`81`	`Ok(IsNull::No)`
`82`	`82`	`}`
`83`	`83`	`}`
`@@ -100,7 +100,7 @@ macro_rules! impl_sql_for_ewkb_type {`
`100`	`100`	`to_sql_checked!();`
`101`	`101`	`accepts_geography!();`
`102`	`102`	`fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {`
`103`		`- try!(self.write_ewkb(out));`
	`103`	`+ self.write_ewkb(out)?;`
`104`	`104`	`Ok(IsNull::No)`
`105`	`105`	`}`
`106`	`106`	`}`
`@@ -115,7 +115,7 @@ macro_rules! impl_sql_for_ewkb_type {`
`115`	`115`	`to_sql_checked!();`
`116`	`116`	`accepts_geography!();`
`117`	`117`	`fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {`
`118`		`- try!(self.write_ewkb(out));`
	`118`	`+ self.write_ewkb(out)?;`
`119`	`119`	`Ok(IsNull::No)`
`120`	`120`	`}`
`121`	`121`	`}`
`@@ -132,7 +132,7 @@ macro_rules! impl_sql_for_ewkb_type {`
`132`	`132`	`to_sql_checked!();`
`133`	`133`	`accepts_geography!();`
`134`	`134`	`fn to_sql(&self, _: &Type, out: &mut Vec<u8>, _ctx: &SessionInfo) -> Result<IsNull, Box<Error + Sync + Send>> {`
`135`		`- try!(self.write_ewkb(out));`
	`135`	`+ self.write_ewkb(out)?;`
`136`	`136`	`Ok(IsNull::No)`
`137`	`137`	`}`
`138`	`138`	`}`