aboutsummaryrefslogtreecommitdiffstats
path: root/src/xml
diff options
context:
space:
mode:
Diffstat (limited to 'src/xml')
-rw-r--r--src/xml/reader.rs32
-rw-r--r--src/xml/writer.rs57
2 files changed, 41 insertions, 48 deletions
diff --git a/src/xml/reader.rs b/src/xml/reader.rs
index 90422c2..e32dd4a 100644
--- a/src/xml/reader.rs
+++ b/src/xml/reader.rs
@@ -4,7 +4,7 @@ use std::io::Read;
use std::str::FromStr;
use xml_rs::reader::{EventReader as XmlEventReader, ParserConfig, XmlEvent};
-use super::super::{ReadError, ReadResult, PlistEvent};
+use {Error, Result, PlistEvent};
pub struct EventReader<R: Read> {
xml_reader: XmlEventReader<R>,
@@ -31,8 +31,8 @@ impl<R: Read> EventReader<R> {
}
}
- fn read_content<F>(&mut self, f: F) -> ReadResult<PlistEvent>
- where F: FnOnce(String) -> ReadResult<PlistEvent>
+ fn read_content<F>(&mut self, f: F) -> Result<PlistEvent>
+ where F: FnOnce(String) -> Result<PlistEvent>
{
match self.xml_reader.next() {
Ok(XmlEvent::Characters(s)) => f(s),
@@ -40,11 +40,11 @@ impl<R: Read> EventReader<R> {
self.queued_event = Some(event);
f("".to_owned())
}
- _ => Err(ReadError::InvalidData),
+ _ => Err(Error::InvalidData),
}
}
- fn next_event(&mut self) -> Result<XmlEvent, ()> {
+ fn next_event(&mut self) -> ::std::result::Result<XmlEvent, ()> {
if let Some(event) = self.queued_event.take() {
Ok(event)
} else {
@@ -52,7 +52,7 @@ impl<R: Read> EventReader<R> {
}
}
- fn read_next(&mut self) -> Option<ReadResult<PlistEvent>> {
+ fn read_next(&mut self) -> Option<Result<PlistEvent>> {
loop {
match self.next_event() {
Ok(XmlEvent::StartElement { name, .. }) => {
@@ -71,7 +71,7 @@ impl<R: Read> EventReader<R> {
let s: String = s.replace(" ", "").replace("\t", "");
match FromBase64::from_base64(&s[..]) {
Ok(b) => Ok(PlistEvent::DataValue(b)),
- Err(_) => Err(ReadError::InvalidData),
+ Err(_) => Err(Error::InvalidData),
}
}))
}
@@ -85,7 +85,7 @@ impl<R: Read> EventReader<R> {
return Some(self.read_content(|s| {
match FromStr::from_str(&s) {
Ok(i) => Ok(PlistEvent::IntegerValue(i)),
- Err(_) => Err(ReadError::InvalidData),
+ Err(_) => Err(Error::InvalidData),
}
}))
}
@@ -93,22 +93,22 @@ impl<R: Read> EventReader<R> {
return Some(self.read_content(|s| {
match FromStr::from_str(&s) {
Ok(f) => Ok(PlistEvent::RealValue(f)),
- Err(_) => Err(ReadError::InvalidData),
+ Err(_) => Err(Error::InvalidData),
}
}))
}
"string" => {
return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s))))
}
- _ => return Some(Err(ReadError::InvalidData)),
+ _ => return Some(Err(Error::InvalidData)),
}
}
Ok(XmlEvent::EndElement { name, .. }) => {
// Check the corrent element is being closed
match self.element_stack.pop() {
Some(ref open_name) if &name.local_name == open_name => (),
- Some(ref _open_name) => return Some(Err(ReadError::InvalidData)),
- None => return Some(Err(ReadError::InvalidData)),
+ Some(ref _open_name) => return Some(Err(Error::InvalidData)),
+ None => return Some(Err(Error::InvalidData)),
}
match &name.local_name[..] {
@@ -121,10 +121,10 @@ impl<R: Read> EventReader<R> {
Ok(XmlEvent::EndDocument) => {
match self.element_stack.is_empty() {
true => return None,
- false => return Some(Err(ReadError::UnexpectedEof)),
+ false => return Some(Err(Error::UnexpectedEof)),
}
}
- Err(_) => return Some(Err(ReadError::InvalidData)),
+ Err(_) => return Some(Err(Error::InvalidData)),
_ => (),
}
}
@@ -132,9 +132,9 @@ impl<R: Read> EventReader<R> {
}
impl<R: Read> Iterator for EventReader<R> {
- type Item = ReadResult<PlistEvent>;
+ type Item = Result<PlistEvent>;
- fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
+ fn next(&mut self) -> Option<Result<PlistEvent>> {
if self.finished {
None
} else {
diff --git a/src/xml/writer.rs b/src/xml/writer.rs
index efca29e..633181b 100644
--- a/src/xml/writer.rs
+++ b/src/xml/writer.rs
@@ -7,7 +7,7 @@ use xml_rs::namespace::Namespace;
use xml_rs::writer::{EventWriter as XmlEventWriter, EmitterConfig};
use xml_rs::writer::events::XmlEvent as WriteXmlEvent;
-use PlistEvent;
+use {Error, EventWriter as EventWriterTrait, PlistEvent, Result};
enum Element {
Dictionary(DictionaryState),
@@ -48,46 +48,39 @@ impl<W: Write> EventWriter<W> {
}
}
- fn write_element_and_value(&mut self, name: &str, value: &str) -> Result<(), ()> {
+ 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));
Ok(())
}
- fn start_element(&mut self, name: &str) -> Result<(), ()> {
- let result = self.xml_writer.write(WriteXmlEvent::StartElement {
+ fn start_element(&mut self, name: &str) -> Result<()> {
+ try!(self.xml_writer.write(WriteXmlEvent::StartElement {
name: Name::local(name),
attributes: Cow::Borrowed(&[]),
namespace: Cow::Borrowed(&self.empty_namespace),
- });
-
- match result {
- Ok(()) => Ok(()),
- Err(_) => Err(()),
- }
+ }));
+ Ok(())
}
- fn end_element(&mut self, name: &str) -> Result<(), ()> {
- let result = self.xml_writer
- .write(WriteXmlEvent::EndElement { name: Some(Name::local(name)) });
-
- match result {
- Ok(()) => Ok(()),
- Err(_) => Err(()),
- }
+ fn end_element(&mut self, name: &str) -> Result<()> {
+ try!(self.xml_writer.write(WriteXmlEvent::EndElement { name: Some(Name::local(name)) }));
+ Ok(())
}
- fn write_value(&mut self, value: &str) -> Result<(), ()> {
- let result = self.xml_writer.write(WriteXmlEvent::Characters(value));
+ fn write_value(&mut self, value: &str) -> Result<()> {
+ try!(self.xml_writer.write(WriteXmlEvent::Characters(value)));
+ Ok(())
+ }
- match result {
- Ok(()) => Ok(()),
- Err(_) => Err(()),
- }
+ pub fn write(&mut self, event: &PlistEvent) -> Result<()> {
+ <Self as EventWriterTrait>::write(self, event)
}
+}
- pub fn write(&mut self, event: &PlistEvent) -> Result<(), ()> {
+impl<W: Write> EventWriterTrait for EventWriter<W> {
+ fn write(&mut self, event: &PlistEvent) -> Result<()> {
match self.stack.pop() {
Some(Element::Dictionary(DictionaryState::ExpectKey)) => {
match *event {
@@ -96,7 +89,7 @@ impl<W: Write> EventWriter<W> {
self.stack.push(Element::Dictionary(DictionaryState::ExpectValue));
}
PlistEvent::EndDictionary => try!(self.end_element("dict")),
- _ => return Err(()), // Invalid event
+ _ => return Err(Error::InvalidData),
};
return Ok(());
}
@@ -118,23 +111,23 @@ impl<W: Write> EventWriter<W> {
match result {
Ok(()) => (),
- Err(_) => return Err(()),
+ Err(_) => return Err(Error::InvalidData),
}
self.stack.push(Element::Root);
return Ok(());
}
- _ => return Err(()), // Invalid event
+ _ => return Err(Error::InvalidData),
}
}
}
Ok(match *event {
- PlistEvent::StartPlist => return Err(()), // Invalid event
+ PlistEvent::StartPlist => return Err(Error::InvalidData),
PlistEvent::EndPlist => {
try!(self.end_element("plist"));
if let Some(Element::Root) = self.stack.pop() {} else {
- return Err(()); // Invalid event
+ return Err(Error::InvalidData);
}
}
@@ -145,7 +138,7 @@ impl<W: Write> EventWriter<W> {
PlistEvent::EndArray => {
try!(self.end_element("array"));
if let Some(Element::Array) = self.stack.pop() {} else {
- return Err(()); // Invalid event
+ return Err(Error::InvalidData);
}
}
@@ -153,7 +146,7 @@ impl<W: Write> EventWriter<W> {
try!(self.start_element("dict"));
self.stack.push(Element::Dictionary(DictionaryState::ExpectKey));
}
- PlistEvent::EndDictionary => return Err(()), // Invalid event
+ PlistEvent::EndDictionary => return Err(Error::InvalidData),
PlistEvent::BooleanValue(true) => {
try!(self.start_element("true"));
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-04 05:15:15 +0000