[#390] Fixing first batch of review comments

Author: elfenpiff

examples/rust/event_multiplexing/wait.rs

@@ -51,8 +51,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Waiting on the following services: {:?}", args.services);
 
     // the callback that is called when a listener has received an event
-    let trigger_call = |attachment| {
-        if let Some((service_name, listener)) = listeners.get(&attachment) {
+    let trigger_call = |attachment_id| {
+        if let Some((service_name, listener)) = listeners.get(&attachment_id) {
             print!("Received trigger from \"{}\" ::", service_name);
 
             while let Ok(Some(event_id)) = listener.try_wait_one() {

iceoryx2/src/port/waitset.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Contributors to the Eclipse Foundation
+// Copyright (c) 2024 Contributors to the Eclipse Foundation
 //
 // See the NOTICE file(s) distributed with this work for additional
 // information regarding copyright ownership.
@@ -33,7 +33,7 @@
 //! let _guard_1 = waitset.attach(&listener_1)?;
 //! let _guard_2 = waitset.attach(&listener_2)?;
 //!
-//! while waitset.timed_wait(|attachment_id| {
+//! let event_handler = |attachment_id| {
 //!     let listener = if attachment_id.originates_from(&listener_1) {
 //!         &listener_1
 //!     } else {
@@ -43,7 +43,10 @@
 //!     while let Ok(Some(event_id)) = listener.try_wait_one() {
 //!         println!("received notification {:?}", event_id);
 //!     }
-//! }, Duration::from_secs(1)) != Ok(WaitEvent::TerminationRequest) {}
+//! };
+//!
+//! while waitset.timed_wait(event_handler, Duration::from_secs(1))
+//!     != Ok(WaitEvent::TerminationRequest) {}
 //!
 //! # Ok(())
 //! # }
@@ -94,7 +97,11 @@
 use std::{fmt::Debug, time::Duration};
 
 use iceoryx2_bb_log::fail;
-use iceoryx2_bb_posix::{file_descriptor_set::SynchronousMultiplexing, signal::SignalHandler};
+use iceoryx2_bb_posix::{
+    file_descriptor_set::SynchronousMultiplexing,
+    periodic_timer::{PeriodicTimer, PeriodicTimerBuilder, PeriodicTimerGuard},
+    signal::SignalHandler,
+};
 use iceoryx2_cal::reactor::*;
 
 /// Defines the type of that triggered [`WaitSet::try_wait()`], [`WaitSet::timed_wait()`] or
@@ -183,11 +190,13 @@ impl AttachmentId {
 
 /// Is returned when something is attached to the [`WaitSet`]. As soon as it goes out
 /// of scope, the attachment is detached.
-pub struct Guard<'waitset, 'attachment, Service: crate::service::Service>(
-    <Service::Reactor as Reactor>::Guard<'waitset, 'attachment>,
-)
+pub struct Guard<'waitset, 'attachment, Service: crate::service::Service>
 where
-    Service::Reactor: 'waitset;
+    Service::Reactor: 'waitset,
+{
+    reactor_guard: Option<<Service::Reactor as Reactor>::Guard<'waitset, 'attachment>>,
+    periodic_timer_guard: Option<PeriodicTimerGuard<'waitset>>,
+}
 
 /// The builder for the [`WaitSet`].
 #[derive(Debug)]
@@ -211,8 +220,16 @@ impl WaitSetBuilder {
     ) -> Result<WaitSet<Service>, WaitSetCreateError> {
         let msg = "Unable to create WaitSet";
 
+        let periodic_timer = fail!(from self,
+                when PeriodicTimerBuilder::new().create(),
+                with WaitSetCreateError::InternalError,
+                "{} since the PeriodicTimer could not be created.", msg);
+
         match <Service::Reactor as Reactor>::Builder::new().create() {
-            Ok(reactor) => Ok(WaitSet { reactor }),
+            Ok(reactor) => Ok(WaitSet {
+                reactor,
+                periodic_timer,
+            }),
             Err(ReactorCreateError::UnknownError(e)) => {
                 fail!(from self, with WaitSetCreateError::InternalError,
                     "{msg} due to an internal error (error code = {})", e);
@@ -232,18 +249,22 @@ impl WaitSetBuilder {
 #[derive(Debug)]
 pub struct WaitSet<Service: crate::service::Service> {
     reactor: Service::Reactor,
+    periodic_timer: PeriodicTimer,
 }
 
 impl<Service: crate::service::Service> WaitSet<Service> {
     /// Attaches an object to the [`WaitSet`]. The object cannot be attached twice and the
     /// [`WaitSet::capacity()`] is limited by the underlying implementation.
-    pub fn attach<'waitset, 'attachment, T: SynchronousMultiplexing + Debug>(
+    pub fn notification<'waitset, 'attachment, T: SynchronousMultiplexing + Debug>(
         &'waitset self,
         attachment: &'attachment T,
     ) -> Result<Guard<'waitset, 'attachment, Service>, WaitSetAttachmentError> {
         let msg = "Unable to attach the attachment";
         match self.reactor.attach(attachment) {
-            Ok(guard) => Ok(Guard(guard)),
+            Ok(guard) => Ok(Guard {
+                reactor_guard: Some(guard),
+                periodic_timer_guard: None,
+            }),
             Err(ReactorAttachError::AlreadyAttached) => {
                 fail!(from self, with WaitSetAttachmentError::AlreadyAttached,
                     "{msg} {:?} since it is already attached.", attachment);

iceoryx2/tests/waitset_tests.rs

@@ -374,10 +374,10 @@ mod waitset {
         barrier.wait();
         let wait_event = sut.blocking_wait(|_| {}).unwrap();
 
-        t1.join().unwrap();
-
         assert_that!(wait_event, eq WaitEvent::Notification);
         assert_that!(start.elapsed(), time_at_least TIMEOUT);
+
+        t1.join().unwrap();
     }
 
     #[instantiate_tests(<iceoryx2::service::ipc::Service>)]