refactor: [torrust#1485] normalize event type parameter name in events pkg

Author: josecelano

packages/events/src/broadcaster.rs

@@ -9,42 +9,42 @@ const CHANNEL_CAPACITY: usize = 32768;
 
 /// An event sender implementation using a broadcast channel.
 #[derive(Clone)]
-pub struct Broadcaster<E: Sync + Send + Clone> {
-    pub(crate) sender: broadcast::Sender<E>,
+pub struct Broadcaster<Event: Sync + Send + Clone> {
+    pub(crate) sender: broadcast::Sender<Event>,
 }
 
-impl<E: Sync + Send + Clone> Default for Broadcaster<E> {
+impl<Event: Sync + Send + Clone> Default for Broadcaster<Event> {
     fn default() -> Self {
         let (sender, _) = broadcast::channel(CHANNEL_CAPACITY);
         Self { sender }
     }
 }
 
-impl<E: Sync + Send + Clone> Broadcaster<E> {
+impl<Event: Sync + Send + Clone> Broadcaster<Event> {
     #[must_use]
-    pub fn subscribe(&self) -> broadcast::Receiver<E> {
+    pub fn subscribe(&self) -> broadcast::Receiver<Event> {
         self.sender.subscribe()
     }
 }
 
-impl<E: Sync + Send + Clone> Sender for Broadcaster<E> {
-    type Event = E;
+impl<Event: Sync + Send + Clone> Sender for Broadcaster<Event> {
+    type Event = Event;
 
-    fn send_event(&self, event: E) -> BoxFuture<'_, Option<Result<usize, SendError<E>>>> {
+    fn send_event(&self, event: Event) -> BoxFuture<'_, Option<Result<usize, SendError<Event>>>> {
         async move { Some(self.sender.send(event).map_err(std::convert::Into::into)) }.boxed()
     }
 }
 
-impl<E: Sync + Send + Clone> Receiver for broadcast::Receiver<E> {
-    type Event = E;
+impl<Event: Sync + Send + Clone> Receiver for broadcast::Receiver<Event> {
+    type Event = Event;
 
     fn recv(&mut self) -> BoxFuture<'_, Result<Self::Event, RecvError>> {
         async move { self.recv().await.map_err(std::convert::Into::into) }.boxed()
     }
 }
 
-impl<E> From<broadcast::error::SendError<E>> for SendError<E> {
-    fn from(err: broadcast::error::SendError<E>) -> Self {
+impl<Event> From<broadcast::error::SendError<Event>> for SendError<Event> {
+    fn from(err: broadcast::error::SendError<Event>) -> Self {
         SendError(err.0)
     }
 }

packages/events/src/bus.rs

@@ -3,31 +3,31 @@ use std::sync::Arc;
 use crate::broadcaster::Broadcaster;
 use crate::{receiver, sender};
 
-pub struct EventBus<E: Sync + Send + Clone + 'static> {
+pub struct EventBus<Event: Sync + Send + Clone + 'static> {
     pub enable_sender: bool,
-    pub broadcaster: Broadcaster<E>,
+    pub broadcaster: Broadcaster<Event>,
 }
 
-impl<E: Sync + Send + Clone + 'static> Default for EventBus<E> {
+impl<Event: Sync + Send + Clone + 'static> Default for EventBus<Event> {
     fn default() -> Self {
         let enable_sender = true;
-        let broadcaster = Broadcaster::<E>::default();
+        let broadcaster = Broadcaster::<Event>::default();
 
         Self::new(enable_sender, broadcaster)
     }
 }
 
-impl<E: Sync + Send + Clone + 'static> EventBus<E> {
+impl<Event: Sync + Send + Clone + 'static> EventBus<Event> {
     #[must_use]
-    pub fn new(enable_sender: bool, broadcaster: Broadcaster<E>) -> Self {
+    pub fn new(enable_sender: bool, broadcaster: Broadcaster<Event>) -> Self {
         Self {
             enable_sender,
             broadcaster,
         }
     }
 
     #[must_use]
-    pub fn sender(&self) -> Arc<Option<Box<dyn sender::Sender<Event = E>>>> {
+    pub fn sender(&self) -> Arc<Option<Box<dyn sender::Sender<Event = Event>>>> {
         if self.enable_sender {
             Arc::new(Some(Box::new(self.broadcaster.clone())))
         } else {
@@ -36,7 +36,7 @@ impl<E: Sync + Send + Clone + 'static> EventBus<E> {
     }
 
     #[must_use]
-    pub fn receiver(&self) -> Box<dyn receiver::Receiver<Event = E>> {
+    pub fn receiver(&self) -> Box<dyn receiver::Receiver<Event = Event>> {
         Box::new(self.broadcaster.subscribe())
     }
 }

packages/events/src/sender.rs

@@ -22,4 +22,4 @@ impl<Event> fmt::Display for SendError<Event> {
     }
 }
 
-impl<T: fmt::Debug> std::error::Error for SendError<T> {}
+impl<Event: fmt::Debug> std::error::Error for SendError<Event> {}