implement Events::extend using impl std::iter::Extend

crates/bevy_ecs/src/event.rs

@@ -351,12 +351,27 @@ impl<T: Component> Events<T> {
  }
  }
 
- pub fn extend<I>(&mut self, events: I)
+ /// Iterates over events that happened since the last "update" call.
+ /// WARNING: You probably don't want to use this call. In most cases you should use an
+ /// `EventReader`. You should only use this if you know you only need to consume events
+ /// between the last `update()` call and your call to `iter_current_update_events`.
+ /// If events happen outside that window, they will not be handled. For example, any events that
+ /// happen after this call and before the next `update()` call will be dropped.
+ pub fn iter_current_update_events(&self) -> impl DoubleEndedIterator<Item = &T> {
+ match self.state {
+ State::A => self.events_a.iter().map(map_instance_event),
+ State::B => self.events_b.iter().map(map_instance_event),
+ }
+ }
+}
+
+impl<T> std::iter::Extend<T> for Events<T> {
+ fn extend<I>(&mut self, iter: I)
  where
- I: Iterator<Item = T>,
+ I: IntoIterator<Item = T>,
  {
  let mut event_count = self.event_count;
- let events = events.map(|event| {
+ let events = iter.into_iter().map(|event| {
  let event_id = EventId {
  id: event_count,
  _marker: PhantomData,
@@ -496,4 +511,15 @@ mod tests {
  ) -> Vec<TestEvent> {
  reader.iter(events).cloned().collect::<Vec<TestEvent>>()
  }
+
+ #[test]
+ fn test_events_extent_impl() {
+ let mut events = Events::<TestEvent>::default();
+ let mut reader = events.get_reader();
+
+ events.extend(vec![TestEvent { i: 0 }, TestEvent { i: 1 }]);
+ assert!(reader
+ .iter(&events)
+ .eq([TestEvent { i: 0 }, TestEvent { i: 1 }].iter()));
+ }
 }