added new RequestId

satrs/src/mode_tree.rs

@@ -6,9 +6,9 @@ use crate::{
     mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, Submode},
     queue::GenericTargetedMessagingError,
     request::{
-        MessageReceiver, MessageReceiverWithId, MessageSender, MessageSenderAndReceiver,
-        MessageSenderMap, MessageSenderMapWithId, MessageWithSenderId,
-        RequestAndReplySenderAndReceiver,
+        GenericMessage, MessageReceiver, MessageReceiverWithId, MessageSender,
+        MessageSenderAndReceiver, MessageSenderMap, MessageSenderMapWithId,
+        RequestAndReplySenderAndReceiver, RequestId,
     },
     ChannelId,
 };
@@ -44,6 +44,7 @@ pub trait ModeRequestSender {
     fn local_channel_id(&self) -> ChannelId;
     fn send_mode_request(
         &self,
+        request_id: RequestId,
         target_id: ChannelId,
         request: ModeRequest,
     ) -> Result<(), GenericTargetedMessagingError>;
@@ -54,6 +55,7 @@ pub trait ModeReplySender {
 
     fn send_mode_reply(
         &self,
+        request_id: RequestId,
         target_id: ChannelId,
         reply: ModeReply,
     ) -> Result<(), GenericTargetedMessagingError>;
@@ -62,23 +64,24 @@ pub trait ModeReplySender {
 pub trait ModeRequestReceiver {
     fn try_recv_mode_request(
         &self,
-    ) -> Result<Option<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError>;
+    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError>;
 }
 
 pub trait ModeReplyReceiver {
     fn try_recv_mode_reply(
         &self,
-    ) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError>;
+    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError>;
 }
 
 impl<S: MessageSender<ModeRequest>> MessageSenderMap<ModeRequest, S> {
     pub fn send_mode_request(
         &self,
+        request_id: RequestId,
         local_id: ChannelId,
         target_id: ChannelId,
         request: ModeRequest,
     ) -> Result<(), GenericTargetedMessagingError> {
-        self.send_message(local_id, target_id, request)
+        self.send_message(request_id, local_id, target_id, request)
     }
 
     pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S) {
@@ -89,11 +92,12 @@ impl<S: MessageSender<ModeRequest>> MessageSenderMap<ModeRequest, S> {
 impl<S: MessageSender<ModeReply>> MessageSenderMap<ModeReply, S> {
     pub fn send_mode_reply(
         &self,
+        request_id: RequestId,
         local_id: ChannelId,
         target_id: ChannelId,
         request: ModeReply,
     ) -> Result<(), GenericTargetedMessagingError> {
-        self.send_message(local_id, target_id, request)
+        self.send_message(request_id, local_id, target_id, request)
     }
 
     pub fn add_reply_target(&mut self, target_id: ChannelId, request_sender: S) {
@@ -104,10 +108,11 @@ impl<S: MessageSender<ModeReply>> MessageSenderMap<ModeReply, S> {
 impl<S: MessageSender<ModeReply>> ModeReplySender for MessageSenderMapWithId<ModeReply, S> {
     fn send_mode_reply(
         &self,
+        request_id: RequestId,
         target_channel_id: ChannelId,
         reply: ModeReply,
     ) -> Result<(), GenericTargetedMessagingError> {
-        self.send_message(target_channel_id, reply)
+        self.send_message(request_id, target_channel_id, reply)
     }
 
     fn local_channel_id(&self) -> ChannelId {
@@ -122,17 +127,18 @@ impl<S: MessageSender<ModeRequest>> ModeRequestSender for MessageSenderMapWithId
 
     fn send_mode_request(
         &self,
+        request_id: RequestId,
         target_id: ChannelId,
         request: ModeRequest,
     ) -> Result<(), GenericTargetedMessagingError> {
-        self.send_message(target_id, request)
+        self.send_message(request_id, target_id, request)
     }
 }
 
 impl<R: MessageReceiver<ModeReply>> ModeReplyReceiver for MessageReceiverWithId<ModeReply, R> {
     fn try_recv_mode_reply(
         &self,
-    ) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError> {
+    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
         self.try_recv_message()
     }
 }
@@ -142,7 +148,7 @@ impl<R: MessageReceiver<ModeRequest>> ModeRequestReceiver
 {
     fn try_recv_mode_request(
         &self,
-    ) -> Result<Option<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError> {
+    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
         self.try_recv_message()
     }
 }
@@ -156,11 +162,16 @@ impl<FROM, S: MessageSender<ModeRequest>, R: MessageReceiver<FROM>> ModeRequestS
 
     fn send_mode_request(
         &self,
+        request_id: RequestId,
         target_id: ChannelId,
         request: ModeRequest,
     ) -> Result<(), GenericTargetedMessagingError> {
-        self.message_sender_map
-            .send_mode_request(self.local_channel_id(), target_id, request)
+        self.message_sender_map.send_mode_request(
+            request_id,
+            self.local_channel_id(),
+            target_id,
+            request,
+        )
     }
 }
 
@@ -173,11 +184,16 @@ impl<FROM, S: MessageSender<ModeReply>, R: MessageReceiver<FROM>> ModeReplySende
 
     fn send_mode_reply(
         &self,
+        request_id: RequestId,
         target_id: ChannelId,
         request: ModeReply,
     ) -> Result<(), GenericTargetedMessagingError> {
-        self.message_sender_map
-            .send_mode_reply(self.local_channel_id(), target_id, request)
+        self.message_sender_map.send_mode_reply(
+            request_id,
+            self.local_channel_id(),
+            target_id,
+            request,
+        )
     }
 }
 
@@ -186,7 +202,7 @@ impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeReply>> ModeReplyReceiver
 {
     fn try_recv_mode_reply(
         &self,
-    ) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError> {
+    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
         self.message_receiver
             .try_recv_message(self.local_channel_id_generic())
     }
@@ -196,7 +212,7 @@ impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeRequest>> ModeRequestRecei
 {
     fn try_recv_mode_request(
         &self,
-    ) -> Result<Option<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError> {
+    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
         self.message_receiver
             .try_recv_message(self.local_channel_id_generic())
     }
@@ -204,37 +220,37 @@ impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeRequest>> ModeRequestRecei
 
 pub type ModeRequestHandlerConnector<S, R> = MessageSenderAndReceiver<ModeReply, ModeRequest, S, R>;
 pub type MpscModeRequestHandlerConnector = ModeRequestHandlerConnector<
-    mpsc::Sender<MessageWithSenderId<ModeReply>>,
-    mpsc::Receiver<MessageWithSenderId<ModeRequest>>,
+    mpsc::Sender<GenericMessage<ModeReply>>,
+    mpsc::Receiver<GenericMessage<ModeRequest>>,
 >;
 pub type MpscBoundedModeRequestHandlerConnector = ModeRequestHandlerConnector<
-    mpsc::SyncSender<MessageWithSenderId<ModeReply>>,
-    mpsc::Receiver<MessageWithSenderId<ModeRequest>>,
+    mpsc::SyncSender<GenericMessage<ModeReply>>,
+    mpsc::Receiver<GenericMessage<ModeRequest>>,
 >;
 
 pub type ModeRequestorConnector<S, R> = MessageSenderAndReceiver<ModeRequest, ModeReply, S, R>;
 pub type MpscModeRequestorConnector = ModeRequestorConnector<
-    mpsc::Sender<MessageWithSenderId<ModeRequest>>,
-    mpsc::Receiver<MessageWithSenderId<ModeReply>>,
+    mpsc::Sender<GenericMessage<ModeRequest>>,
+    mpsc::Receiver<GenericMessage<ModeReply>>,
 >;
 pub type MpscBoundedModeRequestorConnector = ModeRequestorConnector<
-    mpsc::SyncSender<MessageWithSenderId<ModeRequest>>,
-    mpsc::Receiver<MessageWithSenderId<ModeReply>>,
+    mpsc::SyncSender<GenericMessage<ModeRequest>>,
+    mpsc::Receiver<GenericMessage<ModeReply>>,
 >;
 
 pub type ModeConnector<S0, R0, S1, R1> =
     RequestAndReplySenderAndReceiver<ModeRequest, ModeReply, S0, R0, S1, R1>;
 pub type MpscModeConnector = ModeConnector<
-    mpsc::Sender<MessageWithSenderId<ModeRequest>>,
-    mpsc::Receiver<MessageWithSenderId<ModeReply>>,
-    mpsc::Sender<MessageWithSenderId<ModeReply>>,
-    mpsc::Receiver<MessageWithSenderId<ModeRequest>>,
+    mpsc::Sender<GenericMessage<ModeRequest>>,
+    mpsc::Receiver<GenericMessage<ModeReply>>,
+    mpsc::Sender<GenericMessage<ModeReply>>,
+    mpsc::Receiver<GenericMessage<ModeRequest>>,
 >;
 pub type MpscBoundedModeConnector = ModeConnector<
-    mpsc::SyncSender<MessageWithSenderId<ModeRequest>>,
-    mpsc::Receiver<MessageWithSenderId<ModeReply>>,
-    mpsc::SyncSender<MessageWithSenderId<ModeReply>>,
-    mpsc::Receiver<MessageWithSenderId<ModeRequest>>,
+    mpsc::SyncSender<GenericMessage<ModeRequest>>,
+    mpsc::Receiver<GenericMessage<ModeReply>>,
+    mpsc::SyncSender<GenericMessage<ModeReply>>,
+    mpsc::Receiver<GenericMessage<ModeRequest>>,
 >;
 
 impl<
@@ -279,11 +295,16 @@ impl<
 
     fn send_mode_request(
         &self,
+        request_id: RequestId,
         target_id: ChannelId,
         request: ModeRequest,
     ) -> Result<(), GenericTargetedMessagingError> {
-        self.request_sender_map
-            .send_mode_request(self.local_channel_id(), target_id, request)
+        self.request_sender_map.send_mode_request(
+            request_id,
+            self.local_channel_id(),
+            target_id,
+            request,
+        )
     }
 }
 
@@ -301,11 +322,16 @@ impl<
 
     fn send_mode_reply(
         &self,
+        request_id: RequestId,
         target_id: ChannelId,
         request: ModeReply,
     ) -> Result<(), GenericTargetedMessagingError> {
-        self.reply_sender_map
-            .send_mode_reply(self.local_channel_id(), target_id, request)
+        self.reply_sender_map.send_mode_reply(
+            request_id,
+            self.local_channel_id(),
+            target_id,
+            request,
+        )
     }
 }
 
@@ -319,7 +345,7 @@ impl<
 {
     fn try_recv_mode_reply(
         &self,
-    ) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError> {
+    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
         self.reply_receiver
             .try_recv_message(self.local_channel_id_generic())
     }
@@ -335,7 +361,7 @@ impl<
 {
     fn try_recv_mode_request(
         &self,
-    ) -> Result<Option<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError> {
+    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
         self.request_receiver
             .try_recv_message(self.local_channel_id_generic())
     }
@@ -357,9 +383,14 @@ impl From<GenericTargetedMessagingError> for ModeError {
 }
 
 pub trait ModeRequestHandler: ModeProvider {
-    fn start_transition(&mut self, mode_and_submode: ModeAndSubmode) -> Result<(), ModeError>;
+    fn start_transition(
+        &mut self,
+        request_id: RequestId,
+        sender_id: ChannelId,
+        mode_and_submode: ModeAndSubmode,
+    ) -> Result<(), ModeError>;
 
-    fn announce_mode(&self, recursive: bool);
+    fn announce_mode(&self, request_id: RequestId, sender_id: ChannelId, recursive: bool);
     fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError>;
 }
 

satrs/src/request.rs

@@ -118,25 +118,32 @@ impl fmt::Display for TargetAndApidId {
     }
 }
 
-pub struct MessageWithSenderId<MSG> {
+/// Generic message type which is associated with a sender using a [ChannelId] and associated
+/// with a request using a [RequestId].
+pub struct GenericMessage<MSG> {
     pub sender_id: ChannelId,
+    pub request_id: RequestId,
     pub message: MSG,
 }
 
-impl<MSG> MessageWithSenderId<MSG> {
-    pub fn new(sender_id: ChannelId, message: MSG) -> Self {
-        Self { sender_id, message }
+impl<MSG> GenericMessage<MSG> {
+    pub fn new(request_id: RequestId, sender_id: ChannelId, message: MSG) -> Self {
+        Self {
+            request_id,
+            sender_id,
+            message,
+        }
     }
 }
 
 /// Generic trait for objects which can send targeted messages.
 pub trait MessageSender<MSG>: Send {
-    fn send(&self, message: MessageWithSenderId<MSG>) -> Result<(), GenericTargetedMessagingError>;
+    fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError>;
 }
 
 // Generic trait for objects which can receive targeted messages.
 pub trait MessageReceiver<MSG> {
-    fn try_recv(&self) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError>;
+    fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError>;
 }
 
 #[cfg(feature = "std")]
@@ -152,23 +159,17 @@ mod std_mod {
         ChannelId,
     };
 
-    use super::{MessageReceiver, MessageSender, MessageWithSenderId};
+    use super::{GenericMessage, MessageReceiver, MessageSender, RequestId};
 
-    impl<MSG: Send> MessageSender<MSG> for mpsc::Sender<MessageWithSenderId<MSG>> {
-        fn send(
-            &self,
-            message: MessageWithSenderId<MSG>,
-        ) -> Result<(), GenericTargetedMessagingError> {
+    impl<MSG: Send> MessageSender<MSG> for mpsc::Sender<GenericMessage<MSG>> {
+        fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError> {
             self.send(message)
                 .map_err(|_| GenericSendError::RxDisconnected)?;
             Ok(())
         }
     }
-    impl<MSG: Send> MessageSender<MSG> for mpsc::SyncSender<MessageWithSenderId<MSG>> {
-        fn send(
-            &self,
-            message: MessageWithSenderId<MSG>,
-        ) -> Result<(), GenericTargetedMessagingError> {
+    impl<MSG: Send> MessageSender<MSG> for mpsc::SyncSender<GenericMessage<MSG>> {
+        fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError> {
             if let Err(e) = self.try_send(message) {
                 match e {
                     mpsc::TrySendError::Full(_) => {
@@ -202,6 +203,7 @@ mod std_mod {
 
         pub fn send_message(
             &self,
+            request_id: RequestId,
             local_channel_id: ChannelId,
             target_channel_id: ChannelId,
             message: MSG,
@@ -210,7 +212,7 @@ mod std_mod {
                 self.0
                     .get(&target_channel_id)
                     .unwrap()
-                    .send(MessageWithSenderId::new(local_channel_id, message))
+                    .send(GenericMessage::new(request_id, local_channel_id, message))
                     .map_err(|_| GenericSendError::RxDisconnected)?;
                 return Ok(());
             }
@@ -233,11 +235,16 @@ mod std_mod {
 
         pub fn send_message(
             &self,
+            request_id: RequestId,
             target_channel_id: ChannelId,
             message: MSG,
         ) -> Result<(), GenericTargetedMessagingError> {
-            self.message_sender_map
-                .send_message(self.local_channel_id, target_channel_id, message)
+            self.message_sender_map.send_message(
+                request_id,
+                self.local_channel_id,
+                target_channel_id,
+                message,
+            )
         }
 
         pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
@@ -246,10 +253,8 @@ mod std_mod {
         }
     }
 
-    impl<MSG> MessageReceiver<MSG> for mpsc::Receiver<MessageWithSenderId<MSG>> {
-        fn try_recv(
-            &self,
-        ) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError> {
+    impl<MSG> MessageReceiver<MSG> for mpsc::Receiver<GenericMessage<MSG>> {
+        fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
             match self.try_recv() {
                 Ok(msg) => Ok(Some(msg)),
                 Err(e) => match e {
@@ -274,7 +279,7 @@ mod std_mod {
         pub fn try_recv_message(
             &self,
             _local_id: ChannelId,
-        ) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError> {
+        ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
             self.0.try_recv()
         }
     }
@@ -305,7 +310,7 @@ mod std_mod {
     impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
         pub fn try_recv_message(
             &self,
-        ) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError> {
+        ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
             self.reply_receiver.0.try_recv()
         }
     }