Renamed State to BufferState for clarity

Event buffer's state should not clash with State concept

Author: alice-i-cecile

crates/bevy_ecs/src/event.rs

@@ -50,7 +50,7 @@ struct EventInstance<T> {
 }
 
 #[derive(Debug)]
-enum State {
+enum BufferState {
     A,
     B,
 }
@@ -124,7 +124,7 @@ pub struct Events<T> {
     a_start_event_count: usize,
     b_start_event_count: usize,
     event_count: usize,
-    state: State,
+    state: BufferState,
 }
 
 impl<T> Default for Events<T> {
@@ -135,7 +135,7 @@ impl<T> Default for Events<T> {
             event_count: 0,
             events_a: Vec::new(),
             events_b: Vec::new(),
-            state: State::A,
+            state: BufferState::A,
         }
     }
 }
@@ -153,8 +153,8 @@ impl<T: Component> Events<T> {
         let event_instance = EventInstance { event_id, event };
 
         match self.state {
-            State::A => self.events_a.push(event_instance),
-            State::B => self.events_b.push(event_instance),
+            BufferState::A => self.events_a.push(event_instance),
+            BufferState::B => self.events_b.push(event_instance),
         }
 
         self.event_count += 1;
@@ -181,14 +181,14 @@ impl<T: Component> Events<T> {
     /// called once per frame/update.
     pub fn update(&mut self) {
         match self.state {
-            State::A => {
+            BufferState::A => {
                 self.events_b = Vec::new();
-                self.state = State::B;
+                self.state = BufferState::B;
                 self.b_start_event_count = self.event_count;
             }
-            State::B => {
+            BufferState::B => {
                 self.events_a = Vec::new();
-                self.state = State::A;
+                self.state = BufferState::A;
                 self.a_start_event_count = self.event_count;
             }
         }
@@ -216,12 +216,12 @@ impl<T: Component> Events<T> {
     pub fn drain(&mut self) -> impl Iterator<Item = T> + '_ {
         let map = |i: EventInstance<T>| i.event;
         match self.state {
-            State::A => self
+            BufferState::A => self
                 .events_b
                 .drain(..)
                 .map(map)
                 .chain(self.events_a.drain(..).map(map)),
-            State::B => self
+            BufferState::B => self
                 .events_a
                 .drain(..)
                 .map(map)
@@ -246,8 +246,8 @@ impl<T: Component> Events<T> {
     /// 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),
+            BufferState::A => self.events_a.iter().map(map_instance_event),
+            BufferState::B => self.events_b.iter().map(map_instance_event),
         }
     }
 }
@@ -280,7 +280,7 @@ fn internal_event_reader<'a, T>(
     };
     *last_event_count = events.event_count;
     match events.state {
-        State::A => events
+        BufferState::A => events
             .events_b
             .get(b_index..)
             .unwrap_or_else(|| &[])
@@ -294,7 +294,7 @@ fn internal_event_reader<'a, T>(
                     .iter()
                     .map(map_instance_event_with_id),
             ),
-        State::B => events
+        BufferState::B => events
             .events_a
             .get(a_index..)
             .unwrap_or_else(|| &[])