Always pass events by value

- The EventReceiver gets ownership of events
- Breaks compatilibility with previous interface

saphyr/src/parser.rs

@@ -76,31 +76,20 @@ pub struct Parser<T> {
 
 
 pub trait EventReceiver {
-    fn on_event(&mut self, ev: &Event);
+    fn on_event(&mut self, ev: Event);
 }
 
 
 pub trait MarkedEventReceiver {
-    fn on_event(&mut self, ev: &Event, _mark: Marker);
+    fn on_event(&mut self, ev: Event, _mark: Marker);
 }
 
 impl<R: EventReceiver> MarkedEventReceiver for R {
-    fn on_event(&mut self, ev: &Event, _mark: Marker) {
+    fn on_event(&mut self, ev: Event, _mark: Marker) {
         self.on_event(ev)
     }
 }
 
-pub trait MarkedOwnedEventReceiver {
-    fn on_owned_event(&mut self, ev: Event, _mark: Marker);
-}
-
-impl<R: MarkedEventReceiver> MarkedOwnedEventReceiver for R {
-    fn on_owned_event(&mut self, ev: Event, _mark: Marker) {
-        self.on_event(&ev, _mark);
-    }
-}
-
-
 pub type ParseResult = Result<(Event, Marker), ScanError>;
 
 impl<T: Iterator<Item=char>> Parser<T> {
@@ -145,7 +134,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
         self.states.push(state);
     }
 
-    fn parse(&mut self) -> Result<(Event, Marker), ScanError> {
+    fn parse(&mut self) -> ParseResult {
         if self.state == State::End {
             return Ok((Event::StreamEnd, self.scanner.mark()));
         }
@@ -154,23 +143,23 @@ impl<T: Iterator<Item=char>> Parser<T> {
         Ok((ev, mark))
     }
 
-    pub fn load<R: MarkedOwnedEventReceiver>(&mut self, recv: &mut R, multi: bool)
+    pub fn load<R: MarkedEventReceiver>(&mut self, recv: &mut R, multi: bool)
         -> Result<(), ScanError> {
         if !self.scanner.stream_started() {
             let (ev, mark) = try!(self.parse());
             assert_eq!(ev, Event::StreamStart);
-            recv.on_owned_event(ev, mark);
+            recv.on_event(ev, mark);
         }
 
         if self.scanner.stream_ended() {
             // XXX has parsed?
-            recv.on_owned_event(Event::StreamEnd, self.scanner.mark());
+            recv.on_event(Event::StreamEnd, self.scanner.mark());
             return Ok(());
         }
         loop {
             let (ev, mark) = try!(self.parse());
             if ev == Event::StreamEnd {
-                recv.on_owned_event(ev, mark);
+                recv.on_event(ev, mark);
                 return Ok(());
             }
             // clear anchors before a new document
@@ -183,10 +172,10 @@ impl<T: Iterator<Item=char>> Parser<T> {
         Ok(())
     }
 
-    fn load_document<R: MarkedOwnedEventReceiver>(&mut self, first_ev: Event, mark: Marker, recv: &mut R)
+    fn load_document<R: MarkedEventReceiver>(&mut self, first_ev: Event, mark: Marker, recv: &mut R)
         -> Result<(), ScanError> {
         assert_eq!(first_ev, Event::DocumentStart);
-        recv.on_owned_event(first_ev, mark);
+        recv.on_event(first_ev, mark);
 
         let (ev, mark) = try!(self.parse());
         try!(self.load_node(ev, mark, recv));
@@ -194,24 +183,24 @@ impl<T: Iterator<Item=char>> Parser<T> {
         // DOCUMENT-END is expected.
         let (ev, mark) = try!(self.parse());
         assert_eq!(ev, Event::DocumentEnd);
-        recv.on_owned_event(ev, mark);
+        recv.on_event(ev, mark);
 
         Ok(())
     }
 
-    fn load_node<R: MarkedOwnedEventReceiver>(&mut self, first_ev: Event, mark: Marker, recv: &mut R)
+    fn load_node<R: MarkedEventReceiver>(&mut self, first_ev: Event, mark: Marker, recv: &mut R)
         -> Result<(), ScanError> {
         match first_ev {
             Event::Alias(..) | Event::Scalar(..) => {
-                recv.on_owned_event(first_ev, mark);
+                recv.on_event(first_ev, mark);
                 Ok(())
             },
             Event::SequenceStart(_) => {
-                recv.on_owned_event(first_ev, mark);
+                recv.on_event(first_ev, mark);
                 self.load_sequence(recv)
             },
             Event::MappingStart(_) => {
-                recv.on_owned_event(first_ev, mark);
+                recv.on_event(first_ev, mark);
                 self.load_mapping(recv)
             },
             _ => { println!("UNREACHABLE EVENT: {:?}", first_ev);
@@ -219,7 +208,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
         }
     }
 
-    fn load_mapping<R: MarkedOwnedEventReceiver>(&mut self, recv: &mut R)
+    fn load_mapping<R: MarkedEventReceiver>(&mut self, recv: &mut R)
         -> Result<(), ScanError> {
         let (mut key_ev, mut key_mark) = try!(self.parse());
         while key_ev != Event::MappingEnd {
@@ -236,11 +225,11 @@ impl<T: Iterator<Item=char>> Parser<T> {
             key_mark = mark;
 
         }
-        recv.on_owned_event(key_ev, key_mark);
+        recv.on_event(key_ev, key_mark);
         Ok(())
     }
 
-    fn load_sequence<R: MarkedOwnedEventReceiver>(&mut self, recv: &mut R)
+    fn load_sequence<R: MarkedEventReceiver>(&mut self, recv: &mut R)
         -> Result<(), ScanError> {
         let (mut ev, mut mark) = try!(self.parse());
         while ev != Event::SequenceEnd {
@@ -251,7 +240,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
             ev = next_ev;
             mark = next_mark;
         }
-        recv.on_owned_event(ev, mark);
+        recv.on_event(ev, mark);
         Ok(())
     }
 

saphyr/src/yaml.rs

@@ -75,8 +75,8 @@ pub struct YamlLoader {
     anchor_map: BTreeMap<usize, Yaml>,
 }
 
-impl MarkedOwnedEventReceiver for YamlLoader {
-    fn on_owned_event(&mut self, ev: Event, _: Marker) {
+impl MarkedEventReceiver for YamlLoader {
+    fn on_event(&mut self, ev: Event, _: Marker) {
         // println!("EV {:?}", ev);
         match ev {
             Event::DocumentStart => {

saphyr/tests/spec_test.rs

@@ -25,8 +25,8 @@ struct YamlChecker {
 }
 
 impl EventReceiver for YamlChecker {
-    fn on_event(&mut self, ev: &Event) {
-        let tev = match *ev {
+    fn on_event(&mut self, ev: Event) {
+        let tev = match ev {
             Event::DocumentStart => TestEvent::OnDocumentStart,
             Event::DocumentEnd => TestEvent::OnDocumentEnd,
             Event::SequenceStart(..) => TestEvent::OnSequenceStart,