continue mode tree feature

2024-12-02 16:37:28 +01:00
parent 4fc7972bdd
commit a2c2e35067
5 changed files with 361 additions and 140 deletions
--- a/satrs/src/mode.rs
+++ b/satrs/src/mode.rs
@ -336,26 +336,51 @@ pub mod alloc_mod {
    }

    impl<
-            REQUEST,
-            S0: MessageSenderProvider<REQUEST>,
-            R0: MessageReceiverProvider<ModeReply>,
-            S1: MessageSenderProvider<ModeReply>,
-            R1: MessageReceiverProvider<REQUEST>,
-        > RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+            Request,
+            ReqSender: MessageSenderProvider<Request>,
+            ReqReceiver: MessageReceiverProvider<Request>,
+            ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
+            Reply,
+            ReplySender: MessageSenderProvider<Reply>,
+            ReplyReceiver: MessageReceiverProvider<Reply>,
+            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
+        >
+        RequestAndReplySenderAndReceiver<
+            Request,
+            ReqSender,
+            ReqReceiver,
+            ReqSenderStore,
+            Reply,
+            ReplySender,
+            ReplyReceiver,
+            ReplySenderStore,
+        >
    {
-        pub fn add_reply_target(&mut self, target_id: ComponentId, reply_sender: S1) {
-            self.reply_sender_map
+        pub fn add_reply_target(&mut self, target_id: ComponentId, reply_sender: ReplySender) {
+            self.reply_sender_store
                .add_message_target(target_id, reply_sender)
        }
    }

    impl<
-            REQUEST,
-            S0: MessageSenderProvider<REQUEST>,
-            R0: MessageReceiverProvider<ModeReply>,
-            S1: MessageSenderProvider<ModeReply>,
-            R1: MessageReceiverProvider<REQUEST>,
-        > ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+            Request,
+            ReqSender: MessageSenderProvider<Request>,
+            ReqReceiver: MessageReceiverProvider<Request>,
+            ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
+            ReplySender: MessageSenderProvider<ModeReply>,
+            ReplyReceiver: MessageReceiverProvider<ModeReply>,
+            ReplySenderStore: MessageSenderStoreProvider<ModeReply, ReplySender>,
+        > ModeReplySender
+        for RequestAndReplySenderAndReceiver<
+            Request,
+            ReqSender,
+            ReqReceiver,
+            ReqSenderStore,
+            ModeReply,
+            ReplySender,
+            ReplyReceiver,
+            ReplySenderStore,
+        >
    {
        fn local_channel_id(&self) -> ComponentId {
            self.local_channel_id_generic()
@ -364,24 +389,35 @@ pub mod alloc_mod {
        fn send_mode_reply(
            &self,
            requestor_info: MessageMetadata,
-            request: ModeReply,
+            reply: ModeReply,
        ) -> Result<(), GenericTargetedMessagingError> {
-            self.reply_sender_map.send_mode_reply(
+            self.reply_sender_store.send_message(
                MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()),
                requestor_info.sender_id(),
-                request,
+                reply,
            )
        }
    }

    impl<
-            REQUEST,
-            S0: MessageSenderProvider<REQUEST>,
-            R0: MessageReceiverProvider<ModeReply>,
-            S1: MessageSenderProvider<ModeReply>,
-            R1: MessageReceiverProvider<REQUEST>,
+            Request,
+            ReqSender: MessageSenderProvider<Request>,
+            ReqReceiver: MessageReceiverProvider<Request>,
+            ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
+            ReplySender: MessageSenderProvider<ModeReply>,
+            ReplyReceiver: MessageReceiverProvider<ModeReply>,
+            ReplySenderStore: MessageSenderStoreProvider<ModeReply, ReplySender>,
        > ModeReplyReceiver
-        for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+        for RequestAndReplySenderAndReceiver<
+            Request,
+            ReqSender,
+            ReqReceiver,
+            ReqSenderStore,
+            ModeReply,
+            ReplySender,
+            ReplyReceiver,
+            ReplySenderStore,
+        >
    {
        fn try_recv_mode_reply(
            &self,
@ -448,8 +484,23 @@ pub mod alloc_mod {

    /// Helper type defintion for a mode handler object which can both send mode requests and
    /// process mode requests.
-    pub type ModeInterface<S0, R0, S1, R1> =
-        RequestAndReplySenderAndReceiver<ModeRequest, ModeReply, S0, R0, S1, R1>;
+    pub type ModeInterface<
+        ReqSender,
+        ReqReceiver,
+        ReqSenderStore,
+        ReplySender,
+        ReplyReceiver,
+        ReplySenderStore,
+    > = RequestAndReplySenderAndReceiver<
+        ModeRequest,
+        ReqSender,
+        ReqReceiver,
+        ReqSenderStore,
+        ModeReply,
+        ReplySender,
+        ReplyReceiver,
+        ReplySenderStore,
+    >;

    impl<S: MessageSenderProvider<ModeRequest>> MessageSenderMap<ModeRequest, S> {
        pub fn send_mode_request(
@ -508,27 +559,50 @@ pub mod alloc_mod {
    }

    impl<
-            REPLY,
-            S0: MessageSenderProvider<ModeRequest>,
-            R0: MessageReceiverProvider<REPLY>,
-            S1: MessageSenderProvider<REPLY>,
-            R1: MessageReceiverProvider<ModeRequest>,
-        > RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+            ReqSender: MessageSenderProvider<ModeRequest>,
+            ReqReceiver: MessageReceiverProvider<ModeRequest>,
+            ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
+            Reply,
+            ReplySender: MessageSenderProvider<Reply>,
+            ReplyReceiver: MessageReceiverProvider<Reply>,
+            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
+        >
+        RequestAndReplySenderAndReceiver<
+            ModeRequest,
+            ReqSender,
+            ReqReceiver,
+            ReqSenderStore,
+            Reply,
+            ReplySender,
+            ReplyReceiver,
+            ReplySenderStore,
+        >
    {
-        pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S0) {
-            self.request_sender_map
+        pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: ReqSender) {
+            self.request_sender_store
                .add_message_target(target_id, request_sender)
        }
    }

    impl<
-            REPLY,
-            S0: MessageSenderProvider<ModeRequest>,
-            R0: MessageReceiverProvider<REPLY>,
-            S1: MessageSenderProvider<REPLY>,
-            R1: MessageReceiverProvider<ModeRequest>,
+            ReqSender: MessageSenderProvider<ModeRequest>,
+            ReqReceiver: MessageReceiverProvider<ModeRequest>,
+            ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
+            Reply,
+            ReplySender: MessageSenderProvider<Reply>,
+            ReplyReceiver: MessageReceiverProvider<Reply>,
+            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
        > ModeRequestSender
-        for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+        for RequestAndReplySenderAndReceiver<
+            ModeRequest,
+            ReqSender,
+            ReqReceiver,
+            ReqSenderStore,
+            Reply,
+            ReplySender,
+            ReplyReceiver,
+            ReplySenderStore,
+        >
    {
        fn local_channel_id(&self) -> ComponentId {
            self.local_channel_id_generic()
@ -540,7 +614,7 @@ pub mod alloc_mod {
            target_id: ComponentId,
            request: ModeRequest,
        ) -> Result<(), GenericTargetedMessagingError> {
-            self.request_sender_map.send_mode_request(
+            self.request_sender_store.send_message(
                MessageMetadata::new(request_id, self.local_channel_id()),
                target_id,
                request,
@ -549,13 +623,24 @@ pub mod alloc_mod {
    }

    impl<
-            REPLY,
-            S0: MessageSenderProvider<ModeRequest>,
-            R0: MessageReceiverProvider<REPLY>,
-            S1: MessageSenderProvider<REPLY>,
-            R1: MessageReceiverProvider<ModeRequest>,
+            ReqSender: MessageSenderProvider<ModeRequest>,
+            ReqReceiver: MessageReceiverProvider<ModeRequest>,
+            ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
+            Reply,
+            ReplySender: MessageSenderProvider<Reply>,
+            ReplyReceiver: MessageReceiverProvider<Reply>,
+            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
        > ModeRequestReceiver
-        for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+        for RequestAndReplySenderAndReceiver<
+            ModeRequest,
+            ReqSender,
+            ReqReceiver,
+            ReqSenderStore,
+            Reply,
+            ReplySender,
+            ReplyReceiver,
+            ReplySenderStore,
+        >
    {
        fn try_recv_mode_request(
            &self,
@ -573,15 +658,15 @@ pub mod std_mod {

    use super::*;

-    pub type ModeRequestHandlerOneParentMpsc = ModeRequestHandlerInterface<
+    pub type ModeRequestHandlerMpsc = ModeRequestHandlerInterface<
        mpsc::Sender<GenericMessage<ModeReply>>,
        mpsc::Receiver<GenericMessage<ModeRequest>>,
-        OneMessageSender<ModeReply, mpsc::Sender<GenericMessage<ModeReply>>>,
+        MessageSenderList<ModeReply, mpsc::Sender<GenericMessage<ModeReply>>>,
    >;
-    pub type ModeRequestHandlerOneParentMpscBounded = ModeRequestHandlerInterface<
+    pub type ModeRequestHandlerMpscBounded = ModeRequestHandlerInterface<
        mpsc::SyncSender<GenericMessage<ModeReply>>,
        mpsc::Receiver<GenericMessage<ModeRequest>>,
-        OneMessageSender<ModeReply, mpsc::SyncSender<GenericMessage<ModeReply>>>,
+        MessageSenderList<ModeReply, mpsc::SyncSender<GenericMessage<ModeReply>>>,
    >;

    pub type ModeRequestorOneChildMpsc = ModeRequestorInterface<
@ -592,36 +677,34 @@ pub mod std_mod {
    pub type ModeRequestorOneChildBoundedMpsc = ModeRequestorInterface<
        mpsc::SyncSender<GenericMessage<ModeRequest>>,
        mpsc::Receiver<GenericMessage<ModeReply>>,
-        OneMessageSender<
-            ModeRequest,
-            mpsc::SyncSender<GenericMessage<ModeRequest>>,
-        >,
+        OneMessageSender<ModeRequest, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
    >;
-    pub type ModeRequestorMultiChildListMpsc = ModeRequestorInterface<
+    pub type ModeRequestorChildListMpsc = ModeRequestorInterface<
        mpsc::Sender<GenericMessage<ModeRequest>>,
        mpsc::Receiver<GenericMessage<ModeReply>>,
        MessageSenderList<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
    >;
-    pub type ModeRequestorMultiChildListBoundedMpsc = ModeRequestorInterface<
+    pub type ModeRequestorChildListBoundedMpsc = ModeRequestorInterface<
        mpsc::SyncSender<GenericMessage<ModeRequest>>,
        mpsc::Receiver<GenericMessage<ModeReply>>,
-        MessageSenderList<
-            ModeRequest,
-            mpsc::SyncSender<GenericMessage<ModeRequest>>,
-        >,
+        MessageSenderList<ModeRequest, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
    >;

-    pub type ModeRequestorAndHandlerOneParentMpsc = ModeInterface<
+    pub type ModeRequestorAndHandlerMpsc = ModeInterface<
        mpsc::Sender<GenericMessage<ModeRequest>>,
-        mpsc::Receiver<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeRequest>>,
+        MessageSenderList<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
        mpsc::Sender<GenericMessage<ModeReply>>,
-        mpsc::Receiver<GenericMessage<ModeRequest>>,
-    >;
-    pub type ModeRequestorAndHandlerOneParentMpscBounded = ModeInterface<
-        mpsc::SyncSender<GenericMessage<ModeRequest>>,
        mpsc::Receiver<GenericMessage<ModeReply>>,
-        mpsc::SyncSender<GenericMessage<ModeReply>>,
+        MessageSenderList<ModeReply, mpsc::Sender<GenericMessage<ModeReply>>>,
+    >;
+    pub type ModeRequestorAndHandlerMpscBounded = ModeInterface<
+        mpsc::SyncSender<GenericMessage<ModeRequest>>,
        mpsc::Receiver<GenericMessage<ModeRequest>>,
+        MessageSenderList<ModeRequest, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
+        mpsc::SyncSender<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+        MessageSenderList<ModeReply, mpsc::SyncSender<GenericMessage<ModeReply>>>,
    >;
 }

--- a/satrs/src/pus/mode.rs
+++ b/satrs/src/pus/mode.rs
@ -52,7 +52,8 @@ mod tests {
    fn test_simple_mode_requestor() {
        let (reply_sender, reply_receiver) = mpsc::channel();
        let (request_sender, request_receiver) = mpsc::channel();
-        let mut mode_requestor = ModeRequestorOneChildMpsc::new(TEST_COMPONENT_ID_0, reply_receiver);
+        let mut mode_requestor =
+            ModeRequestorOneChildMpsc::new(TEST_COMPONENT_ID_0, reply_receiver);
        mode_requestor.add_message_target(TEST_COMPONENT_ID_1, request_sender);

        // Send a request and verify it arrives at the receiver.
--- a/satrs/src/request.rs
+++ b/satrs/src/request.rs
@ -149,9 +149,9 @@ pub trait MessageReceiverProvider<MSG> {
    fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError>;
 }

-pub struct MessageWithSenderIdReceiver<MSG, R: MessageReceiverProvider<MSG>>(
-    pub R,
-    PhantomData<MSG>,
+pub struct MessageWithSenderIdReceiver<Msg, Receiver: MessageReceiverProvider<Msg>>(
+    pub Receiver,
+    PhantomData<Msg>,
 );

 impl<MSG, R: MessageReceiverProvider<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> {
@ -208,6 +208,7 @@ pub trait MessageSenderStoreProvider<Message, Sender>: Default {
 #[cfg(feature = "alloc")]
 pub mod alloc_mod {
    use crate::queue::GenericSendError;
+    use std::convert::From;

    use super::*;
    use hashbrown::HashMap;
@ -226,10 +227,10 @@ pub mod alloc_mod {
        }
    }

-    impl<Msg, S: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, S>
-        for OneMessageSender<Msg, S>
+    impl<Msg, Sender: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, Sender>
+        for OneMessageSender<Msg, Sender>
    {
-        fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
+        fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender) {
            if self.id_and_sender.is_some() {
                return;
            }
@ -263,10 +264,10 @@ pub mod alloc_mod {
        }
    }

-    impl<MSG, S: MessageSenderProvider<MSG>> MessageSenderStoreProvider<MSG, S>
-        for MessageSenderList<MSG, S>
+    impl<Msg, Sender: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, Sender>
+        for MessageSenderList<Msg, Sender>
    {
-        fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
+        fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender) {
            self.0.push((target_id, message_sender));
        }

@ -274,7 +275,7 @@ pub mod alloc_mod {
            &self,
            requestor_info: MessageMetadata,
            target_channel_id: ComponentId,
-            message: MSG,
+            message: Msg,
        ) -> Result<(), GenericTargetedMessagingError> {
            for (current_id, sender) in &self.0 {
                if *current_id == target_channel_id {
@ -297,10 +298,10 @@ pub mod alloc_mod {
        }
    }

-    impl<MSG, S: MessageSenderProvider<MSG>> MessageSenderStoreProvider<MSG, S>
-        for MessageSenderMap<MSG, S>
+    impl<Msg, Sender: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, Sender>
+        for MessageSenderMap<Msg, Sender>
    {
-        fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
+        fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender) {
            self.0.insert(target_id, message_sender);
        }

@ -308,7 +309,7 @@ pub mod alloc_mod {
            &self,
            requestor_info: MessageMetadata,
            target_channel_id: ComponentId,
-            message: MSG,
+            message: Msg,
        ) -> Result<(), GenericTargetedMessagingError> {
            if self.0.contains_key(&target_channel_id) {
                return self
@ -383,42 +384,58 @@ pub mod alloc_mod {
    }

    pub struct RequestAndReplySenderAndReceiver<
-        REQUEST,
-        REPLY,
-        S0: MessageSenderProvider<REQUEST>,
-        R0: MessageReceiverProvider<REPLY>,
-        S1: MessageSenderProvider<REPLY>,
-        R1: MessageReceiverProvider<REQUEST>,
+        Request,
+        ReqSender: MessageSenderProvider<Request>,
+        ReqReceiver: MessageReceiverProvider<Request>,
+        ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
+        Reply,
+        ReplySender: MessageSenderProvider<Reply>,
+        ReplyReceiver: MessageReceiverProvider<Reply>,
+        ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
    > {
        pub local_channel_id: ComponentId,
        // These 2 are a functional group.
-        pub request_sender_map: MessageSenderMap<REQUEST, S0>,
-        pub reply_receiver: MessageWithSenderIdReceiver<REPLY, R0>,
+        pub request_sender_store: ReqSenderStore,
+        pub reply_receiver: MessageWithSenderIdReceiver<Reply, ReplyReceiver>,
        // These 2 are a functional group.
-        pub request_receiver: MessageWithSenderIdReceiver<REQUEST, R1>,
-        pub reply_sender_map: MessageSenderMap<REPLY, S1>,
+        pub request_receiver: MessageWithSenderIdReceiver<Request, ReqReceiver>,
+        pub reply_sender_store: ReplySenderStore,
+        phantom: PhantomData<(ReqSender, ReplySender)>,
    }

    impl<
-            REQUEST,
-            REPLY,
-            S0: MessageSenderProvider<REQUEST>,
-            R0: MessageReceiverProvider<REPLY>,
-            S1: MessageSenderProvider<REPLY>,
-            R1: MessageReceiverProvider<REQUEST>,
-        > RequestAndReplySenderAndReceiver<REQUEST, REPLY, S0, R0, S1, R1>
+            Request,
+            ReqSender: MessageSenderProvider<Request>,
+            ReqReceiver: MessageReceiverProvider<Request>,
+            ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
+            Reply,
+            ReplySender: MessageSenderProvider<Reply>,
+            ReplyReceiver: MessageReceiverProvider<Reply>,
+            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
+        >
+        RequestAndReplySenderAndReceiver<
+            Request,
+            ReqSender,
+            ReqReceiver,
+            ReqSenderStore,
+            Reply,
+            ReplySender,
+            ReplyReceiver,
+            ReplySenderStore,
+        >
    {
        pub fn new(
            local_channel_id: ComponentId,
-            request_receiver: R1,
-            reply_receiver: R0,
+            request_receiver: ReqReceiver,
+            reply_receiver: ReplyReceiver,
        ) -> Self {
            Self {
                local_channel_id,
                request_receiver: request_receiver.into(),
                reply_receiver: reply_receiver.into(),
-                request_sender_map: Default::default(),
-                reply_sender_map: Default::default(),
+                request_sender_store: Default::default(),
+                reply_sender_store: Default::default(),
+                phantom: PhantomData,
            }
        }