aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/binary/reader.rs89
-rw-r--r--src/builder.rs22
-rw-r--r--src/date.rs2
-rw-r--r--src/lib.rs8
-rw-r--r--src/serde/de.rs6
-rw-r--r--src/serde/ser.rs6
-rw-r--r--src/xml/writer.rs52
7 files changed, 92 insertions, 93 deletions
diff --git a/src/binary/reader.rs b/src/binary/reader.rs
index 1f1a00b..097198e 100644
--- a/src/binary/reader.rs
+++ b/src/binary/reader.rs
@@ -74,29 +74,29 @@ impl<R: Read + Seek> EventReader<R> {
}
fn read_trailer(&mut self) -> Result<()> {
- try!(self.reader.seek(SeekFrom::Start(0)));
+ self.reader.seek(SeekFrom::Start(0))?;
let mut magic = [0; 8];
- try!(self.reader.read(&mut magic));
+ self.reader.read(&mut magic)?;
if &magic != b"bplist00" {
return Err(Error::InvalidData);
}
// Trailer starts with 6 bytes of padding
- let trailer_start = try!(self.reader.seek(SeekFrom::End(-32 + 6)));
+ let trailer_start = self.reader.seek(SeekFrom::End(-32 + 6))?;
- let offset_size = try!(self.reader.read_u8());
- self.ref_size = try!(self.reader.read_u8());
- let num_objects = try!(self.reader.read_u64::<BigEndian>());
- let top_object = try!(self.reader.read_u64::<BigEndian>());
- let offset_table_offset = try!(self.reader.read_u64::<BigEndian>());
+ let offset_size = self.reader.read_u8()?;
+ self.ref_size = self.reader.read_u8()?;
+ let num_objects = self.reader.read_u64::<BigEndian>()?;
+ let top_object = self.reader.read_u64::<BigEndian>()?;
+ let offset_table_offset = self.reader.read_u64::<BigEndian>()?;
// File size minus trailer and header
// Truncated to max(usize)
self.max_allocation = trailer_start.saturating_sub(8) as usize;
// Read offset table
- try!(self.reader.seek(SeekFrom::Start(offset_table_offset)));
- self.object_offsets = try!(self.read_ints(num_objects, offset_size));
+ self.reader.seek(SeekFrom::Start(offset_table_offset))?;
+ self.object_offsets = self.read_ints(num_objects, offset_size)?;
self.max_objects = self.object_offsets.len() * 10;
@@ -113,10 +113,10 @@ impl<R: Read + Seek> EventReader<R> {
let mut ints = self.allocate_vec(len)?;
for _ in 0..len {
match size {
- 1 => ints.push(try!(self.reader.read_u8()) as u64),
- 2 => ints.push(try!(self.reader.read_u16::<BigEndian>()) as u64),
- 4 => ints.push(try!(self.reader.read_u32::<BigEndian>()) as u64),
- 8 => ints.push(try!(self.reader.read_u64::<BigEndian>()) as u64),
+ 1 => ints.push(self.reader.read_u8()? as u64),
+ 2 => ints.push(self.reader.read_u16::<BigEndian>()? as u64),
+ 4 => ints.push(self.reader.read_u32::<BigEndian>()? as u64),
+ 8 => ints.push(self.reader.read_u64::<BigEndian>()? as u64),
_ => return Err(Error::InvalidData),
}
}
@@ -130,12 +130,12 @@ impl<R: Read + Seek> EventReader<R> {
fn read_object_len(&mut self, len: u8) -> Result<u64> {
if (len & 0x0f) == 0x0f {
- let len_power_of_two = try!(self.reader.read_u8()) & 0x03;
+ let len_power_of_two = self.reader.read_u8()? & 0x03;
Ok(match len_power_of_two {
- 0 => try!(self.reader.read_u8()) as u64,
- 1 => try!(self.reader.read_u16::<BigEndian>()) as u64,
- 2 => try!(self.reader.read_u32::<BigEndian>()) as u64,
- 3 => try!(self.reader.read_u64::<BigEndian>()),
+ 0 => self.reader.read_u8()? as u64,
+ 1 => self.reader.read_u16::<BigEndian>()? as u64,
+ 2 => self.reader.read_u32::<BigEndian>()? as u64,
+ 3 => self.reader.read_u64::<BigEndian>()?,
_ => return Err(Error::InvalidData),
})
} else {
@@ -152,16 +152,15 @@ impl<R: Read + Seek> EventReader<R> {
}
fn seek_to_object(&mut self, object_ref: u64) -> Result<u64> {
- let object_ref = try!(u64_to_usize(object_ref));
+ let object_ref = u64_to_usize(object_ref)?;
let offset = *self.object_offsets.get(object_ref).ok_or(Error::InvalidData)?;
- let pos = try!(self.reader.seek(SeekFrom::Start(offset)));
- Ok(pos)
+ Ok(self.reader.seek(SeekFrom::Start(offset))?)
}
fn read_next(&mut self) -> Result<Option<PlistEvent>> {
if self.ref_size == 0 {
// Initialise here rather than in new
- try!(self.read_trailer());
+ self.read_trailer()?;
}
let object_ref = match self.stack.last_mut() {
@@ -176,7 +175,7 @@ impl<R: Read + Seek> EventReader<R> {
return Err(Error::InvalidData);
}
self.current_objects += 1;
- try!(self.seek_to_object(object_ref));
+ self.seek_to_object(object_ref)?;
}
None => {
// We're at the end of an array or dict. Pop the top stack item and return
@@ -190,7 +189,7 @@ impl<R: Read + Seek> EventReader<R> {
}
}
- let token = try!(self.reader.read_u8());
+ let token = self.reader.read_u8()?;
let ty = (token & 0xf0) >> 4;
let size = token & 0x0f;
@@ -199,54 +198,54 @@ impl<R: Read + Seek> EventReader<R> {
(0x0, 0x08) => Some(PlistEvent::BooleanValue(false)),
(0x0, 0x09) => Some(PlistEvent::BooleanValue(true)),
(0x0, 0x0f) => return Err(Error::InvalidData), // fill
- (0x1, 0) => Some(PlistEvent::IntegerValue(try!(self.reader.read_u8()) as i64)),
+ (0x1, 0) => Some(PlistEvent::IntegerValue(self.reader.read_u8()? as i64)),
(0x1, 1) => {
- Some(PlistEvent::IntegerValue(try!(self.reader.read_u16::<BigEndian>()) as i64))
+ Some(PlistEvent::IntegerValue(self.reader.read_u16::<BigEndian>()? as i64))
}
(0x1, 2) => {
- Some(PlistEvent::IntegerValue(try!(self.reader.read_u32::<BigEndian>()) as i64))
+ Some(PlistEvent::IntegerValue(self.reader.read_u32::<BigEndian>()? as i64))
}
- (0x1, 3) => Some(PlistEvent::IntegerValue(try!(self.reader.read_i64::<BigEndian>()))),
+ (0x1, 3) => Some(PlistEvent::IntegerValue(self.reader.read_i64::<BigEndian>()?)),
(0x1, 4) => return Err(Error::InvalidData), // 128 bit int
(0x1, _) => return Err(Error::InvalidData), // variable length int
(0x2, 2) => {
- Some(PlistEvent::RealValue(try!(self.reader.read_f32::<BigEndian>()) as f64))
+ Some(PlistEvent::RealValue(self.reader.read_f32::<BigEndian>()? as f64))
}
- (0x2, 3) => Some(PlistEvent::RealValue(try!(self.reader.read_f64::<BigEndian>()))),
+ (0x2, 3) => Some(PlistEvent::RealValue(self.reader.read_f64::<BigEndian>()?)),
(0x2, _) => return Err(Error::InvalidData), // odd length float
(0x3, 3) => {
// Date. Seconds since 1/1/2001 00:00:00.
- let secs = try!(self.reader.read_f64::<BigEndian>());
+ let secs = self.reader.read_f64::<BigEndian>()?;
Some(PlistEvent::DateValue(Date::from_seconds_since_plist_epoch(secs)?))
}
(0x4, n) => {
// Data
- let len = try!(self.read_object_len(n));
- Some(PlistEvent::DataValue(try!(self.read_data(len))))
+ let len = self.read_object_len(n)?;
+ Some(PlistEvent::DataValue(self.read_data(len)?))
}
(0x5, n) => {
// ASCII string
- let len = try!(self.read_object_len(n));
- let raw = try!(self.read_data(len));
- let string = try!(String::from_utf8(raw));
+ let len = self.read_object_len(n)?;
+ let raw = self.read_data(len)?;
+ let string = String::from_utf8(raw)?;
Some(PlistEvent::StringValue(string))
}
(0x6, n) => {
// UTF-16 string
- let len_utf16_codepoints = try!(self.read_object_len(n));
+ let len_utf16_codepoints = self.read_object_len(n)?;
let mut raw_utf16 = self.allocate_vec(len_utf16_codepoints)?;
for _ in 0..len_utf16_codepoints {
- raw_utf16.push(try!(self.reader.read_u16::<BigEndian>()));
+ raw_utf16.push(self.reader.read_u16::<BigEndian>()?);
}
- let string = try!(String::from_utf16(&raw_utf16));
+ let string = String::from_utf16(&raw_utf16)?;
Some(PlistEvent::StringValue(string))
}
(0xa, n) => {
// Array
- let len = try!(self.read_object_len(n));
- let mut object_refs = try!(self.read_refs(len));
+ let len = self.read_object_len(n)?;
+ let mut object_refs = self.read_refs(len)?;
// Reverse so we can pop off the end of the stack in order
object_refs.reverse();
@@ -259,9 +258,9 @@ impl<R: Read + Seek> EventReader<R> {
}
(0xd, n) => {
// Dict
- let len = try!(self.read_object_len(n));
- let key_refs = try!(self.read_refs(len));
- let value_refs = try!(self.read_refs(len));
+ let len = self.read_object_len(n)?;
+ let key_refs = self.read_refs(len)?;
+ let value_refs = self.read_refs(len)?;
let mut object_refs = self.allocate_vec(len * 2)?;
let len = key_refs.len();
diff --git a/src/builder.rs b/src/builder.rs
index 7bb09b9..08467af 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -16,10 +16,10 @@ impl<T: Iterator<Item = Result<PlistEvent>>> Builder<T> {
}
pub fn build(mut self) -> Result<Plist> {
- try!(self.bump());
+ self.bump()?;
- let plist = try!(self.build_value());
- try!(self.bump());
+ let plist = self.build_value()?;
+ self.bump()?;
match self.token {
None => (),
// The stream should have finished
@@ -39,9 +39,9 @@ impl<T: Iterator<Item = Result<PlistEvent>>> Builder<T> {
fn build_value(&mut self) -> Result<Plist> {
match self.token.take() {
- Some(PlistEvent::StartArray(len)) => Ok(Plist::Array(try!(self.build_array(len)))),
+ Some(PlistEvent::StartArray(len)) => Ok(Plist::Array(self.build_array(len)?)),
Some(PlistEvent::StartDictionary(len)) => {
- Ok(Plist::Dictionary(try!(self.build_dict(len))))
+ Ok(Plist::Dictionary(self.build_dict(len)?))
}
Some(PlistEvent::BooleanValue(b)) => Ok(Plist::Boolean(b)),
@@ -60,19 +60,19 @@ impl<T: Iterator<Item = Result<PlistEvent>>> Builder<T> {
}
fn build_array(&mut self, len: Option<u64>) -> Result<Vec<Plist>> {
- let len = try!(u64_option_to_usize(len));
+ let len = u64_option_to_usize(len)?;
let mut values = match len {
Some(len) => Vec::with_capacity(len),
None => Vec::new(),
};
loop {
- try!(self.bump());
+ self.bump()?;
if let Some(PlistEvent::EndArray) = self.token {
self.token.take();
return Ok(values);
}
- values.push(try!(self.build_value()));
+ values.push(self.build_value()?);
}
}
@@ -80,12 +80,12 @@ impl<T: Iterator<Item = Result<PlistEvent>>> Builder<T> {
let mut values = BTreeMap::new();
loop {
- try!(self.bump());
+ self.bump()?;
match self.token.take() {
Some(PlistEvent::EndDictionary) => return Ok(values),
Some(PlistEvent::StringValue(s)) => {
- try!(self.bump());
- values.insert(s, try!(self.build_value()));
+ self.bump()?;
+ values.insert(s, self.build_value()?);
}
_ => {
// Only string keys are supported in plists
diff --git a/src/date.rs b/src/date.rs
index d36ff16..2bcf9da 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -27,7 +27,7 @@ impl Date {
let dur = dur + Duration::nanoseconds(submilli_nanos as i64);
let plist_epoch = UTC.ymd(2001, 1, 1).and_hms(0, 0, 0);
- let date = try!(plist_epoch.checked_add_signed(dur).ok_or(Error::InvalidData));
+ let date = plist_epoch.checked_add_signed(dur).ok_or(Error::InvalidData)?;
Ok(Date {
inner: date
diff --git a/src/lib.rs b/src/lib.rs
index 74c2095..1105d0d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -164,10 +164,10 @@ impl<R: Read + Seek> EventReader<R> {
}
fn is_binary(reader: &mut R) -> Result<bool> {
- try!(reader.seek(SeekFrom::Start(0)));
+ reader.seek(SeekFrom::Start(0))?;
let mut magic = [0; 8];
- try!(reader.read(&mut magic));
- try!(reader.seek(SeekFrom::Start(0)));
+ reader.read(&mut magic)?;
+ reader.seek(SeekFrom::Start(0))?;
Ok(if &magic == b"bplist00" { true } else { false })
}
@@ -212,7 +212,7 @@ fn u64_to_usize(len_u64: u64) -> Result<usize> {
fn u64_option_to_usize(len: Option<u64>) -> Result<Option<usize>> {
match len {
- Some(len) => Ok(Some(try!(u64_to_usize(len)))),
+ Some(len) => Ok(Some(u64_to_usize(len)?)),
None => Ok(None),
}
}
diff --git a/src/serde/de.rs b/src/serde/de.rs
index 1b9838a..dd7f829 100644
--- a/src/serde/de.rs
+++ b/src/serde/de.rs
@@ -68,7 +68,7 @@ impl<'de, 'a, I> de::Deserializer<'de> for &'a mut Deserializer<I>
{
match try_next!(self.events.next()) {
PlistEvent::StartArray(len) => {
- let len = try!(u64_option_to_usize(len));
+ let len = u64_option_to_usize(len)?;
let ret = visitor.visit_seq(MapAndSeqAccess::new(self, false, len))?;
expect!(self.events.next(), PlistEvent::EndArray);
Ok(ret)
@@ -76,7 +76,7 @@ impl<'de, 'a, I> de::Deserializer<'de> for &'a mut Deserializer<I>
PlistEvent::EndArray => return Err(event_mismatch_error()),
PlistEvent::StartDictionary(len) => {
- let len = try!(u64_option_to_usize(len));
+ let len = u64_option_to_usize(len)?;
let ret = visitor.visit_map(MapAndSeqAccess::new(self, false, len))?;
expect!(self.events.next(), PlistEvent::EndDictionary);
Ok(ret)
@@ -157,7 +157,7 @@ impl<'de, 'a, I> de::Deserializer<'de> for &'a mut Deserializer<I>
where V: de::Visitor<'de>
{
expect!(self.events.next(), PlistEvent::StartDictionary(_));
- let ret = try!(visitor.visit_enum(&mut *self));
+ let ret = visitor.visit_enum(&mut *self)?;
expect!(self.events.next(), PlistEvent::EndDictionary);
Ok(ret)
}
diff --git a/src/serde/ser.rs b/src/serde/ser.rs
index 3772d7f..b5eca6a 100644
--- a/src/serde/ser.rs
+++ b/src/serde/ser.rs
@@ -43,13 +43,13 @@ impl<W: EventWriter> Serializer<W> {
// Emit {key: value}
fn single_key_dict(&mut self, key: String) -> Result<(), Error> {
- try!(self.emit(PlistEvent::StartDictionary(Some(1))));
- try!(self.emit(PlistEvent::StringValue(key)));
+ self.emit(PlistEvent::StartDictionary(Some(1)))?;
+ self.emit(PlistEvent::StringValue(key))?;
Ok(())
}
fn single_key_dict_end(&mut self) -> Result<(), Error> {
- try!(self.emit(PlistEvent::EndDictionary));
+ self.emit(PlistEvent::EndDictionary)?;
Ok(())
}
}
diff --git a/src/xml/writer.rs b/src/xml/writer.rs
index a660adb..5d2e2f0 100644
--- a/src/xml/writer.rs
+++ b/src/xml/writer.rs
@@ -56,35 +56,35 @@ impl<W: Write> EventWriter<W> {
}
fn write_element_and_value(&mut self, name: &str, value: &str) -> Result<()> {
- try!(self.start_element(name));
- try!(self.write_value(value));
- try!(self.end_element(name));
+ self.start_element(name)?;
+ self.write_value(value)?;
+ self.end_element(name)?;
Ok(())
}
fn start_element(&mut self, name: &str) -> Result<()> {
- try!(self.xml_writer.write(WriteXmlEvent::StartElement {
+ self.xml_writer.write(WriteXmlEvent::StartElement {
name: Name::local(name),
attributes: Cow::Borrowed(&[]),
namespace: Cow::Borrowed(&self.empty_namespace),
- }));
+ })?;
Ok(())
}
fn end_element(&mut self, name: &str) -> Result<()> {
- try!(self.xml_writer.write(WriteXmlEvent::EndElement { name: Some(Name::local(name)) }));
+ self.xml_writer.write(WriteXmlEvent::EndElement { name: Some(Name::local(name)) })?;
Ok(())
}
fn write_value(&mut self, value: &str) -> Result<()> {
- try!(self.xml_writer.write(WriteXmlEvent::Characters(value)));
+ self.xml_writer.write(WriteXmlEvent::Characters(value))?;
Ok(())
}
fn maybe_end_plist(&mut self) -> Result<()> {
// If there are no more open tags then write the </plist> element
if self.stack.len() == 1 {
- try!(self.end_element("plist"));
+ self.end_element("plist")?;
if let Some(Element::Root) = self.stack.pop() {
} else {
return Err(Error::InvalidData);
@@ -104,13 +104,13 @@ impl<W: Write> PlistEventWriter for EventWriter<W> {
Some(Element::Dictionary(DictionaryState::ExpectKey)) => {
match *event {
PlistEvent::StringValue(ref value) => {
- try!(self.write_element_and_value("key", &*value));
+ self.write_element_and_value("key", &*value)?;
self.stack.push(Element::Dictionary(DictionaryState::ExpectValue));
}
PlistEvent::EndDictionary => {
- try!(self.end_element("dict"));
+ self.end_element("dict")?;
// We might be closing the last tag here as well
- try!(self.maybe_end_plist());
+ self.maybe_end_plist()?;
}
_ => return Err(Error::InvalidData),
};
@@ -124,11 +124,11 @@ impl<W: Write> PlistEventWriter for EventWriter<W> {
let version_name = Name::local("version");
let version_attr = Attribute::new(version_name, "1.0");
- try!(self.xml_writer.write(WriteXmlEvent::StartElement {
+ self.xml_writer.write(WriteXmlEvent::StartElement {
name: Name::local("plist"),
attributes: Cow::Borrowed(&[version_attr]),
namespace: Cow::Borrowed(&self.empty_namespace),
- }));
+ })?;
self.stack.push(Element::Root);
}
@@ -136,11 +136,11 @@ impl<W: Write> PlistEventWriter for EventWriter<W> {
match *event {
PlistEvent::StartArray(_) => {
- try!(self.start_element("array"));
+ self.start_element("array")?;
self.stack.push(Element::Array);
}
PlistEvent::EndArray => {
- try!(self.end_element("array"));
+ self.end_element("array")?;
if let Some(Element::Array) = self.stack.pop() {
} else {
return Err(Error::InvalidData);
@@ -148,38 +148,38 @@ impl<W: Write> PlistEventWriter for EventWriter<W> {
}
PlistEvent::StartDictionary(_) => {
- try!(self.start_element("dict"));
+ self.start_element("dict")?;
self.stack.push(Element::Dictionary(DictionaryState::ExpectKey));
}
PlistEvent::EndDictionary => return Err(Error::InvalidData),
PlistEvent::BooleanValue(true) => {
- try!(self.start_element("true"));
- try!(self.end_element("true"));
+ self.start_element("true")?;
+ self.end_element("true")?;
}
PlistEvent::BooleanValue(false) => {
- try!(self.start_element("false"));
- try!(self.end_element("false"));
+ self.start_element("false")?;
+ self.end_element("false")?;
}
PlistEvent::DataValue(ref value) => {
let base64_data = base64::encode_config(&value, base64::MIME);
- try!(self.write_element_and_value("data", &base64_data));
+ self.write_element_and_value("data", &base64_data)?;
}
PlistEvent::DateValue(ref value) => {
- try!(self.write_element_and_value("date", &value.to_string()));
+ self.write_element_and_value("date", &value.to_string())?
}
PlistEvent::IntegerValue(ref value) => {
- try!(self.write_element_and_value("integer", &value.to_string()))
+ self.write_element_and_value("integer", &value.to_string())?
}
PlistEvent::RealValue(ref value) => {
- try!(self.write_element_and_value("real", &value.to_string()))
+ self.write_element_and_value("real", &value.to_string())?
}
PlistEvent::StringValue(ref value) => {
- try!(self.write_element_and_value("string", &*value))
+ self.write_element_and_value("string", &*value)?
}
};
- try!(self.maybe_end_plist());
+ self.maybe_end_plist()?;
Ok(())
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-08 21:59:38 +0000