michael/exif-rs
michael
/
exif-rs
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replace try!() with ?

This commit is contained in:
Kornel 2018-04-16 04:11:08 +01:00 committed by KAMADA Ken'ichi
parent c2912228c9
commit 9c45d1903a
7 changed files with 126 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/dumpexif.rs
View File

@ -41,8 +41,8 @@ fn main() {
}
fn dump_file(path: &Path) -> Result<(), exif::Error> {
let file = try!(File::open(path));
let reader = try!(exif::Reader::new(&mut BufReader::new(&file)));
let file = File::open(path)?;
let reader = exif::Reader::new(&mut BufReader::new(&file))?;
println!("{}", path.display());
for f in reader.fields() {

10
src/jpeg.rs
View File

@ -64,18 +64,18 @@ pub fn get_exif_attr<R>(reader: &mut R)
fn get_exif_attr_sub<R>(reader: &mut R)
-> Result<Vec<u8>, Error> where R: io::BufRead {
let mut soi = [0u8; 2];
try!(reader.read_exact(&mut soi));
reader.read_exact(&mut soi)?;
if soi != [marker::P, marker::SOI] {
return Err(Error::InvalidFormat("Not a JPEG file"));
}
loop {
// Find a marker prefix. Discard non-ff bytes, which appear if
// we are in the scan data after SOS or we are out of sync.
try!(reader.read_until(marker::P, &mut Vec::new()));
reader.read_until(marker::P, &mut Vec::new())?;
// Get a marker code.
let mut code;
loop {
code = try!(read8(reader));
code = read8(reader)?;
if code != marker::P { break; }
}
// Continue or return early on stand-alone markers.
@ -86,12 +86,12 @@ fn get_exif_attr_sub<R>(reader: &mut R)
_ => {},
}
// Read marker segments.
let seglen = try!(read16(reader));
let seglen = read16(reader)?;
if seglen < 2 {
return Err(Error::InvalidFormat("Invalid segment length"));
}
let mut seg = Vec::new();
try!(reader.by_ref().take(seglen as u64 - 2).read_to_end(&mut seg));
reader.by_ref().take(seglen as u64 - 2).read_to_end(&mut seg)?;
if code == marker::APP1 && seg.starts_with(&EXIF_ID) {
return Ok(seg.split_off(EXIF_ID.len()));
}

10
src/reader.rs
View File

@ -68,13 +68,13 @@ impl Reader {
-> Result<Reader, Error> where R: io::BufRead {
// Parse the data.
let mut buf = Vec::new();
try!(reader.by_ref().take(4).read_to_end(&mut buf));
reader.by_ref().take(4).read_to_end(&mut buf)?;
if jpeg::is_jpeg(&buf) {
let exif_buf = try!(jpeg::get_exif_attr(
&mut buf.as_mut_slice().chain(reader)));
let exif_buf = jpeg::get_exif_attr(
&mut buf.as_mut_slice().chain(reader))?;
buf = exif_buf;
} else if tiff::is_tiff(&buf) {
try!(reader.read_to_end(&mut buf));
reader.read_to_end(&mut buf)?;
} else {
return Err(Error::InvalidFormat("Unknown image format"));
}
@ -82,7 +82,7 @@ impl Reader {
// Cheat on the type system and erase the lifetime by transmute().
// The scope releases the inner `v` to unborrow `buf`.
let (fields, le) = {
let (v, le) = try!(tiff::parse_exif(&buf));
let (v, le) = tiff::parse_exif(&buf)?;
(unsafe { mem::transmute::<Vec<Field>, Vec<Field>>(v) }, le) };
// Initialize the HashMap of all fields.

34
src/tag.rs
View File

@ -652,7 +652,7 @@ fn d_exptime(w: &mut fmt::Write, value: &Value) -> fmt::Result {
// FNumber (Exif 0x829d)
fn d_fnumber(w: &mut fmt::Write, value: &Value) -> fmt::Result {
try!(w.write_str("f/"));
w.write_str("f/")?;
d_decimal(w, value)
}
@ -709,7 +709,7 @@ fn d_exifver(w: &mut fmt::Write, value: &Value) -> fmt::Result {
fn d_cpntcfg(w: &mut fmt::Write, value: &Value) -> fmt::Result {
if let Value::Undefined(u, _) = *value {
for &x in u {
try!(match x {
match x {
0 => w.write_char('_'),
1 => w.write_char('Y'),
2 => w.write_str("Cb"),
@ -718,7 +718,7 @@ fn d_cpntcfg(w: &mut fmt::Write, value: &Value) -> fmt::Result {
5 => w.write_char('G'),
6 => w.write_char('B'),
_ => w.write_char('?'),
});
}?;
}
return Ok(());
}
@ -1202,7 +1202,7 @@ fn d_decimal(w: &mut fmt::Write, value: &Value) -> fmt::Result {
#[inline(never)]
fn d_unknown(w: &mut fmt::Write, value: &Value, prefix: &str) -> fmt::Result {
try!(w.write_str(prefix));
w.write_str(prefix)?;
d_default(w, value)
}
@ -1213,10 +1213,10 @@ fn d_default(w: &mut fmt::Write, value: &Value) -> fmt::Result {
let mut first = true;
for x in v {
if !first {
try!(w.write_str(", "));
w.write_str(", ")?;
}
first = false;
try!(d_sub_ascii(w, x));
d_sub_ascii(w, x)?;
}
Ok(())
},
@ -1240,10 +1240,10 @@ fn d_sub_comma<T>(w: &mut fmt::Write, slice: &[T])
-> fmt::Result where T: fmt::Display {
let mut first = true;
for x in slice {
try!(match first {
match first {
true => write!(w, "{}", x),
false => write!(w, ", {}", x),
});
}?;
first = false;
}
Ok(())
@ -1254,33 +1254,33 @@ fn d_sub_comma_f64<T>(w: &mut fmt::Write, slice: &[T])
let mut first = true;
for &x in slice {
let x: f64 = x.into();
try!(match first {
match first {
true => write!(w, "{}", x),
false => write!(w, ", {}", x),
});
}?;
first = false;
}
Ok(())
}
fn d_sub_hex(w: &mut fmt::Write, bytes: &[u8]) -> fmt::Result {
try!(w.write_str("0x"));
w.write_str("0x")?;
for x in bytes {
try!(write!(w, "{:02x}", x));
write!(w, "{:02x}", x)?;
}
Ok(())
}
fn d_sub_ascii(w: &mut fmt::Write, bytes: &[u8]) -> fmt::Result {
try!(w.write_char('"'));
w.write_char('"')?;
for &c in bytes {
match c {
b'\\' | b'"' => {
try!(w.write_char('\\'));
try!(w.write_char(c as char));
w.write_char('\\')?;
w.write_char(c as char)?;
},
0x20...0x7e => try!(w.write_char(c as char)),
_ => try!(write!(w, "\\x{:02x}", c)),
0x20...0x7e => w.write_char(c as char)?,
_ => write!(w, "\\x{:02x}", c)?,
}
}
w.write_char('"')

40
src/tiff.rs
View File

@ -76,7 +76,7 @@ fn parse_exif_sub<E>(data: &[u8])
}
let ifd_offset = E::loadu32(data, 4) as usize;
let mut fields = Vec::new();
try!(parse_ifd::<E>(&mut fields, data, ifd_offset, Context::Tiff, false));
parse_ifd::<E>(&mut fields, data, ifd_offset, Context::Tiff, false)?;
Ok(fields)
}
@ -100,8 +100,8 @@ fn parse_ifd<'a, E>(fields: &mut Vec<Field<'a>>, data: &'a [u8],
let cnt = E::loadu32(data, offset + 2 + i * 12 + 4) as usize;
let valofs_at = offset + 2 + i * 12 + 8;
let (unitlen, parser) = get_type_info::<E>(typ);
let vallen = try!(unitlen.checked_mul(cnt).ok_or(
Error::InvalidFormat("Invalid entry count")));
let vallen = unitlen.checked_mul(cnt).ok_or(
Error::InvalidFormat("Invalid entry count"))?;
let val;
if unitlen == 0 {
val = Value::Unknown(typ, cnt as u32, valofs_at as u32);
@ -119,12 +119,12 @@ fn parse_ifd<'a, E>(fields: &mut Vec<Field<'a>>, data: &'a [u8],
// recursively defined.
let tag = Tag(ctx, tag);
match tag {
Tag::ExifIFDPointer => try!(parse_child_ifd::<E>(
fields, data, &val, Context::Exif, thumbnail)),
Tag::GPSInfoIFDPointer => try!(parse_child_ifd::<E>(
fields, data, &val, Context::Gps, thumbnail)),
Tag::InteropIFDPointer => try!(parse_child_ifd::<E>(
fields, data, &val, Context::Interop, thumbnail)),
Tag::ExifIFDPointer => parse_child_ifd::<E>(
fields, data, &val, Context::Exif, thumbnail)?,
Tag::GPSInfoIFDPointer => parse_child_ifd::<E>(
fields, data, &val, Context::Gps, thumbnail)?,
Tag::InteropIFDPointer => parse_child_ifd::<E>(
fields, data, &val, Context::Interop, thumbnail)?,
_ => fields.push(Field { tag: tag, thumbnail: thumbnail,
value: val }),
}
@ -150,8 +150,8 @@ fn parse_child_ifd<'a, E>(fields: &mut Vec<Field<'a>>, data: &'a [u8],
// A pointer field has type == LONG and count == 1, so the
// value (IFD offset) must be embedded in the "value offset"
// element of the field.
let ofs = try!(pointer.get_uint(0).ok_or(
Error::InvalidFormat("Invalid pointer"))) as usize;
let ofs = pointer.get_uint(0).ok_or(
Error::InvalidFormat("Invalid pointer"))? as usize;
parse_ifd::<E>(fields, data, ofs, ctx, thumbnail)
}
@ -198,12 +198,12 @@ impl DateTime {
return Err(Error::InvalidFormat("Invalid DateTime delimiter"));
}
Ok(DateTime {
year: try!(atou16(&data[0..4])),
month: try!(atou16(&data[5..7])) as u8,
day: try!(atou16(&data[8..10])) as u8,
hour: try!(atou16(&data[11..13])) as u8,
minute: try!(atou16(&data[14..16])) as u8,
second: try!(atou16(&data[17..19])) as u8,
year: atou16(&data[0..4])?,
month: atou16(&data[5..7])? as u8,
day: atou16(&data[8..10])? as u8,
hour: atou16(&data[11..13])? as u8,
minute: atou16(&data[14..16])? as u8,
second: atou16(&data[17..19])? as u8,
nanosecond: None,
offset: None,
})
@ -217,7 +217,7 @@ impl DateTime {
if c == b' ' {
break;
}
subsec = subsec * 10 + try!(ctou32(c));
subsec = subsec * 10 + ctou32(c)?;
ndigits += 1;
if ndigits >= 9 {
break;
@ -243,8 +243,8 @@ impl DateTime {
} else if data[3] != b':' {
return Err(Error::InvalidFormat("Invalid OffsetTime delimiter"));
}
let hour = try!(atou16(&data[1..3]));
let min = try!(atou16(&data[4..6]));
let hour = atou16(&data[1..3])?;
let min = atou16(&data[4..6])?;
let offset = (hour * 60 + min) as i16;
self.offset = Some(match data[0] {
b'+' => offset,

2
src/util.rs
View File

@ -40,7 +40,7 @@ pub fn read8<R>(reader: &mut R) -> Result<u8, io::Error> where R: io::Read {
pub fn read16<R>(reader: &mut R) -> Result<u16, io::Error> where R: io::Read {
let mut buf: [u8; 2] = unsafe { ::std::mem::uninitialized() };
try!(reader.read_exact(&mut buf));
reader.read_exact(&mut buf)?;
Ok(((buf[0] as u16) << 8) + buf[1] as u16)
}

152
src/writer.rs
View File

@ -182,11 +182,11 @@ impl<'a> Writer<'a> {
-> Result<(), Error> where W: Write + Seek {
// TIFF signature and the offset of the 0th IFD.
if little_endian {
try!(w.write_all(&TIFF_LE_SIG));
try!(LittleEndian::writeu32(w, 8));
w.write_all(&TIFF_LE_SIG)?;
LittleEndian::writeu32(w, 8)?;
} else {
try!(w.write_all(&TIFF_BE_SIG));
try!(BigEndian::writeu32(w, 8));
w.write_all(&TIFF_BE_SIG)?;
BigEndian::writeu32(w, 8)?;
}
// Write the primary image.
@ -204,7 +204,7 @@ impl<'a> Writer<'a> {
jpeg: None,
};
let next_ifd_offset_offset =
try!(synthesize_fields(w, ws, false, little_endian));
synthesize_fields(w, ws, false, little_endian)?;
// Do not output the thumbnail IFD if there are no data in it.
let thumbnail_absent =
@ -215,18 +215,18 @@ impl<'a> Writer<'a> {
self.tn_strips == None &&
self.tn_jpeg == None;
if thumbnail_absent {
try!(w.flush());
w.flush()?;
return Ok(());
}
let next_ifd_offset = try!(pad_and_get_offset(w));
let origpos = try!(w.seek(SeekFrom::Current(0)));
try!(w.seek(SeekFrom::Start(next_ifd_offset_offset as u64)));
let next_ifd_offset = pad_and_get_offset(w)?;
let origpos = w.seek(SeekFrom::Current(0))?;
w.seek(SeekFrom::Start(next_ifd_offset_offset as u64))?;
match little_endian {
false => try!(BigEndian::writeu32(w, next_ifd_offset)),
true => try!(LittleEndian::writeu32(w, next_ifd_offset)),
false => BigEndian::writeu32(w, next_ifd_offset)?,
true => LittleEndian::writeu32(w, next_ifd_offset)?,
}
try!(w.seek(SeekFrom::Start(origpos)));
w.seek(SeekFrom::Start(origpos))?;
// Write the thumbnail image.
let ws = WriterState {
@ -242,9 +242,9 @@ impl<'a> Writer<'a> {
tiles: None,
jpeg: self.tn_jpeg,
};
try!(synthesize_fields(w, ws, true, little_endian));
synthesize_fields(w, ws, true, little_endian)?;
try!(w.flush());
w.flush()?;
Ok(())
}
}
@ -319,9 +319,9 @@ fn synthesize_fields<W>(w: &mut W, ws: WriterState, thumbnail: bool,
match gps_fields_len { 0 => 0, _ => 1 } +
match exif_fields_len { 0 => 0, _ => 1 };
ws.tiff_ifd_offset = try!(reserve_ifd(w, tiff_fields_len));
ws.tiff_ifd_offset = reserve_ifd(w, tiff_fields_len)?;
if exif_fields_len > 0 {
ws.exif_ifd_offset = try!(reserve_ifd(w, exif_fields_len));
ws.exif_ifd_offset = reserve_ifd(w, exif_fields_len)?;
exif_in_tiff = Field {
tag: Tag::ExifIFDPointer,
thumbnail: thumbnail,
@ -330,7 +330,7 @@ fn synthesize_fields<W>(w: &mut W, ws: WriterState, thumbnail: bool,
ws.tiff_fields.push(&exif_in_tiff);
}
if gps_fields_len > 0 {
ws.gps_ifd_offset = try!(reserve_ifd(w, gps_fields_len));
ws.gps_ifd_offset = reserve_ifd(w, gps_fields_len)?;
gps_in_tiff = Field {
tag: Tag::GPSInfoIFDPointer,
thumbnail: thumbnail,
@ -339,7 +339,7 @@ fn synthesize_fields<W>(w: &mut W, ws: WriterState, thumbnail: bool,
ws.tiff_fields.push(&gps_in_tiff);
}
if interop_fields_len > 0 {
ws.interop_ifd_offset = try!(reserve_ifd(w, interop_fields_len));
ws.interop_ifd_offset = reserve_ifd(w, interop_fields_len)?;
interop_in_exif = Field {
tag: Tag::InteropIFDPointer,
thumbnail: thumbnail,
@ -364,54 +364,54 @@ fn write_image<W, E>(w: &mut W, ws: WriterState)
-> Result<u32, Error> where W: Write + Seek, E: Endian {
let (next_ifd_offset_offset,
strip_offsets_offset, tile_offsets_offset, jpeg_offset) =
try!(write_ifd_and_fields::<_, E>(
w, &ws.tiff_fields, ws.tiff_ifd_offset));
write_ifd_and_fields::<_, E>(
w, &ws.tiff_fields, ws.tiff_ifd_offset)?;
if ws.exif_fields.len() > 0 {
try!(write_ifd_and_fields::<_, E>(
w, &ws.exif_fields, ws.exif_ifd_offset));
write_ifd_and_fields::<_, E>(
w, &ws.exif_fields, ws.exif_ifd_offset)?;
}
if ws.gps_fields.len() > 0 {
try!(write_ifd_and_fields::<_, E>(
w, &ws.gps_fields, ws.gps_ifd_offset));
write_ifd_and_fields::<_, E>(
w, &ws.gps_fields, ws.gps_ifd_offset)?;
}
if ws.interop_fields.len() > 0 {
try!(write_ifd_and_fields::<_, E>(
w, &ws.interop_fields, ws.interop_ifd_offset));
write_ifd_and_fields::<_, E>(
w, &ws.interop_fields, ws.interop_ifd_offset)?;
}
if let Some(strips) = ws.strips {
let mut strip_offsets = Vec::new();
for strip in strips {
strip_offsets.push(try!(get_offset(w)));
try!(w.write_all(strip));
strip_offsets.push(get_offset(w)?);
w.write_all(strip)?;
}
let origpos = try!(w.seek(SeekFrom::Current(0)));
try!(w.seek(SeekFrom::Start(strip_offsets_offset as u64)));
let origpos = w.seek(SeekFrom::Current(0))?;
w.seek(SeekFrom::Start(strip_offsets_offset as u64))?;
for ofs in strip_offsets {
try!(E::writeu32(w, ofs));
E::writeu32(w, ofs)?;
}
try!(w.seek(SeekFrom::Start(origpos)));
w.seek(SeekFrom::Start(origpos))?;
}
if let Some(tiles) = ws.tiles {
let mut tile_offsets = Vec::new();
for tile in tiles {
tile_offsets.push(try!(get_offset(w)));
try!(w.write_all(tile));
tile_offsets.push(get_offset(w)?);
w.write_all(tile)?;
}
let origpos = try!(w.seek(SeekFrom::Current(0)));
try!(w.seek(SeekFrom::Start(tile_offsets_offset as u64)));
let origpos = w.seek(SeekFrom::Current(0))?;
w.seek(SeekFrom::Start(tile_offsets_offset as u64))?;
for ofs in tile_offsets {
try!(E::writeu32(w, ofs));
E::writeu32(w, ofs)?;
}
try!(w.seek(SeekFrom::Start(origpos)));
w.seek(SeekFrom::Start(origpos))?;
}
if let Some(jpeg) = ws.jpeg {
let offset = try!(get_offset(w));
try!(w.write_all(jpeg));
let origpos = try!(w.seek(SeekFrom::Current(0)));
try!(w.seek(SeekFrom::Start(jpeg_offset as u64)));
try!(E::writeu32(w, offset));
try!(w.seek(SeekFrom::Start(origpos)));
let offset = get_offset(w)?;
w.write_all(jpeg)?;
let origpos = w.seek(SeekFrom::Current(0))?;
w.seek(SeekFrom::Start(jpeg_offset as u64))?;
E::writeu32(w, offset)?;
w.seek(SeekFrom::Start(origpos))?;
}
Ok(next_ifd_offset_offset)
@ -421,11 +421,11 @@ fn write_image<W, E>(w: &mut W, ws: WriterState)
// returns the offset of the IFD.
fn reserve_ifd<W>(w: &mut W, count: usize)
-> Result<u32, Error> where W: Write + Seek {
let ifdpos = try!(get_offset(w));
let ifdpos = get_offset(w)?;
assert!(ifdpos % 2 == 0);
// The number of entries (2) + array of entries (12 * n) +
// the next IFD pointer (4).
try!(w.seek(SeekFrom::Current(2 + count as i64 * 12 + 4)));
w.seek(SeekFrom::Current(2 + count as i64 * 12 + 4))?;
Ok(ifdpos)
}
@ -442,38 +442,38 @@ fn write_ifd_and_fields<W, E>(
let mut ifd = Vec::new();
// Write the number of entries.
try!(E::writeu16(&mut ifd, fields.len() as u16));
E::writeu16(&mut ifd, fields.len() as u16)?;
// Write the fields.
for f in fields {
let (typ, cnt, mut valbuf) = try!(compose_value::<E>(&f.value));
let (typ, cnt, mut valbuf) = compose_value::<E>(&f.value)?;
if cnt as u32 as usize != cnt {
return Err(Error::TooBig("Too long array"));
}
try!(E::writeu16(&mut ifd, f.tag.number()));
try!(E::writeu16(&mut ifd, typ));
try!(E::writeu32(&mut ifd, cnt as u32));
E::writeu16(&mut ifd, f.tag.number())?;
E::writeu16(&mut ifd, typ)?;
E::writeu32(&mut ifd, cnt as u32)?;
// Embed the value itself into the offset, or
// encode as an offset and the value.
if valbuf.len() <= 4 {
valbuf.resize(4, 0);
try!(ifd.write_all(&valbuf));
ifd.write_all(&valbuf)?;
} else {
// The value must begin on a word boundary. [TIFF6, Section 2:
// TIFF Structure, Image File Directory, IFD Entry, p. 15]
let valofs = try!(pad_and_get_offset(w));
try!(E::writeu32(&mut ifd, valofs));
try!(w.write_all(&valbuf));
let valofs = pad_and_get_offset(w)?;
E::writeu32(&mut ifd, valofs)?;
w.write_all(&valbuf)?;
}
if f.tag == Tag::StripOffsets {
strip_offsets_offset = match valbuf.len() {
0...4 => ifd_offset + ifd.len() as u32 - 4,
_ => try!(get_offset(w)) - valbuf.len() as u32,
_ => get_offset(w)? - valbuf.len() as u32,
};
}
if f.tag == Tag::TileOffsets {
tile_offsets_offset = match valbuf.len() {
0...4 => ifd_offset + ifd.len() as u32 - 4,
_ => try!(get_offset(w)) - valbuf.len() as u32,
_ => get_offset(w)? - valbuf.len() as u32,
};
}
if f.tag == Tag::JPEGInterchangeFormat {
@ -482,10 +482,10 @@ fn write_ifd_and_fields<W, E>(
}
// Write the next IFD pointer.
let next_ifd_offset_offset = ifd_offset + ifd.len() as u32;
try!(E::writeu32(&mut ifd, 0));
E::writeu32(&mut ifd, 0)?;
// Write the IFD.
try!(write_at(w, &ifd, ifd_offset));
write_at(w, &ifd, ifd_offset)?;
Ok((next_ifd_offset_offset,
strip_offsets_offset, tile_offsets_offset, jpeg_offset))
@ -508,22 +508,22 @@ fn compose_value<E>(value: &Value)
Value::Short(ref vec) => {
let mut buf = Vec::new();
for &v in vec {
try!(E::writeu16(&mut buf, v));
E::writeu16(&mut buf, v)?;
}
Ok((3, vec.len(), buf))
},
Value::Long(ref vec) => {
let mut buf = Vec::new();
for &v in vec {
try!(E::writeu32(&mut buf, v));
E::writeu32(&mut buf, v)?;
}
Ok((4, vec.len(), buf))
},
Value::Rational(ref vec) => {
let mut buf = Vec::new();
for v in vec {
try!(E::writeu32(&mut buf, v.num));
try!(E::writeu32(&mut buf, v.denom));
E::writeu32(&mut buf, v.num)?;
E::writeu32(&mut buf, v.denom)?;
}
Ok((5, vec.len(), buf))
},
@ -537,36 +537,36 @@ fn compose_value<E>(value: &Value)
Value::SShort(ref vec) => {
let mut buf = Vec::new();
for &v in vec {
try!(E::writeu16(&mut buf, v as u16));
E::writeu16(&mut buf, v as u16)?;
}
Ok((8, vec.len(), buf))
},
Value::SLong(ref vec) => {
let mut buf = Vec::new();
for &v in vec {
try!(E::writeu32(&mut buf, v as u32));
E::writeu32(&mut buf, v as u32)?;
}
Ok((9, vec.len(), buf))
},
Value::SRational(ref vec) => {
let mut buf = Vec::new();
for v in vec {
try!(E::writeu32(&mut buf, v.num as u32));
try!(E::writeu32(&mut buf, v.denom as u32));
E::writeu32(&mut buf, v.num as u32)?;
E::writeu32(&mut buf, v.denom as u32)?;
}
Ok((10, vec.len(), buf))
},
Value::Float(ref vec) => {
let mut buf = Vec::new();
for &v in vec {
try!(E::writeu32(&mut buf, unsafe { mem::transmute(v) }));
E::writeu32(&mut buf, unsafe { mem::transmute(v) })?;
}
Ok((11, vec.len(), buf))
},
Value::Double(ref vec) => {
let mut buf = Vec::new();
for &v in vec {
try!(E::writeu64(&mut buf, unsafe { mem::transmute(v) }));
E::writeu64(&mut buf, unsafe { mem::transmute(v) })?;
}
Ok((12, vec.len(), buf))
},
@ -577,22 +577,22 @@ fn compose_value<E>(value: &Value)
fn write_at<W>(w: &mut W, buf: &[u8], offset: u32)
-> io::Result<()> where W: Write + Seek {
let orig = try!(w.seek(SeekFrom::Current(0)));
try!(w.seek(SeekFrom::Start(offset as u64)));
try!(w.write_all(buf));
try!(w.seek(SeekFrom::Start(orig)));
let orig = w.seek(SeekFrom::Current(0))?;
w.seek(SeekFrom::Start(offset as u64))?;
w.write_all(buf)?;
w.seek(SeekFrom::Start(orig))?;
Ok(())
}
// Aligns `w` to the two-byte (word) boundary and returns the new offset.
fn pad_and_get_offset<W>(w: &mut W)
-> Result<u32, Error> where W: Write + Seek {
let mut pos = try!(w.seek(SeekFrom::Current(0)));
let mut pos = w.seek(SeekFrom::Current(0))?;
if pos >= (1 << 32) - 1 {
return Err(Error::TooBig("Offset too large"));
}
if pos % 2 != 0 {
try!(w.write_all(&[0]));
w.write_all(&[0])?;
pos += 1;
}
Ok(pos as u32)
@ -600,7 +600,7 @@ fn pad_and_get_offset<W>(w: &mut W)
fn get_offset<W>(w: &mut W)
-> Result<u32, Error> where W: Write + Seek {
let pos = try!(w.seek(SeekFrom::Current(0)));
let pos = w.seek(SeekFrom::Current(0))?;
if pos as u32 as u64 != pos {
return Err(Error::TooBig("Offset too large"));
}