generic shananigans

2024-11-29 13:36:53 +01:00
parent 04b96579bd
commit 4fc7972bdd
6 changed files with 454 additions and 205 deletions
--- a/satrs/src/mode.rs
+++ b/satrs/src/mode.rs
@ -12,7 +12,9 @@ pub use std_mod::*;

 use crate::{
    queue::GenericTargetedMessagingError,
-    request::{GenericMessage, MessageMetadata, MessageReceiver, MessageReceiverWithId, RequestId},
+    request::{
+        GenericMessage, MessageMetadata, MessageReceiverProvider, MessageReceiverWithId, RequestId,
+    },
    ComponentId,
 };

@ -156,7 +158,7 @@ pub trait ModeRequestReceiver {
    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError>;
 }

-impl<R: MessageReceiver<ModeRequest>> ModeRequestReceiver
+impl<R: MessageReceiverProvider<ModeRequest>> ModeRequestReceiver
    for MessageReceiverWithId<ModeRequest, R>
 {
    fn try_recv_mode_request(
@ -248,7 +250,9 @@ pub trait ModeReplyReceiver {
    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError>;
 }

-impl<R: MessageReceiver<ModeReply>> ModeReplyReceiver for MessageReceiverWithId<ModeReply, R> {
+impl<R: MessageReceiverProvider<ModeReply>> ModeReplyReceiver
+    for MessageReceiverWithId<ModeReply, R>
+{
    fn try_recv_mode_reply(
        &self,
    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
@ -270,12 +274,13 @@ pub trait ModeReplySender {
 #[cfg(feature = "alloc")]
 pub mod alloc_mod {
    use crate::request::{
-        MessageSender, MessageSenderAndReceiver, MessageSenderMap, RequestAndReplySenderAndReceiver,
+        MessageSenderAndReceiver, MessageSenderMap, MessageSenderProvider,
+        MessageSenderStoreProvider, RequestAndReplySenderAndReceiver,
    };

    use super::*;

-    impl<S: MessageSender<ModeReply>> MessageSenderMap<ModeReply, S> {
+    impl<S: MessageSenderProvider<ModeReply>> MessageSenderMap<ModeReply, S> {
        pub fn send_mode_reply(
            &self,
            requestor_info: MessageMetadata,
@ -290,8 +295,13 @@ pub mod alloc_mod {
        }
    }

-    impl<FROM, S: MessageSender<ModeReply>, R: MessageReceiver<FROM>> ModeReplySender
-        for MessageSenderAndReceiver<ModeReply, FROM, S, R>
+    impl<
+            From,
+            Sender: MessageSenderProvider<ModeReply>,
+            Receiver: MessageReceiverProvider<From>,
+            SenderStore: MessageSenderStoreProvider<ModeReply, Sender>,
+        > ModeReplySender
+        for MessageSenderAndReceiver<ModeReply, From, Sender, Receiver, SenderStore>
    {
        fn local_channel_id(&self) -> ComponentId {
            self.local_channel_id_generic()
@ -302,7 +312,7 @@ pub mod alloc_mod {
            requestor_info: MessageMetadata,
            request: ModeReply,
        ) -> Result<(), GenericTargetedMessagingError> {
-            self.message_sender_map.send_mode_reply(
+            self.message_sender_store.send_message(
                MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()),
                requestor_info.sender_id(),
                request,
@ -310,8 +320,13 @@ pub mod alloc_mod {
        }
    }

-    impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeReply>> ModeReplyReceiver
-        for MessageSenderAndReceiver<TO, ModeReply, S, R>
+    impl<
+            To,
+            Sender: MessageSenderProvider<To>,
+            Receiver: MessageReceiverProvider<ModeReply>,
+            SenderStore: MessageSenderStoreProvider<To, Sender>,
+        > ModeReplyReceiver
+        for MessageSenderAndReceiver<To, ModeReply, Sender, Receiver, SenderStore>
    {
        fn try_recv_mode_reply(
            &self,
@ -322,10 +337,10 @@ pub mod alloc_mod {

    impl<
            REQUEST,
-            S0: MessageSender<REQUEST>,
-            R0: MessageReceiver<ModeReply>,
-            S1: MessageSender<ModeReply>,
-            R1: MessageReceiver<REQUEST>,
+            S0: MessageSenderProvider<REQUEST>,
+            R0: MessageReceiverProvider<ModeReply>,
+            S1: MessageSenderProvider<ModeReply>,
+            R1: MessageReceiverProvider<REQUEST>,
        > RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
    {
        pub fn add_reply_target(&mut self, target_id: ComponentId, reply_sender: S1) {
@ -336,10 +351,10 @@ pub mod alloc_mod {

    impl<
            REQUEST,
-            S0: MessageSender<REQUEST>,
-            R0: MessageReceiver<ModeReply>,
-            S1: MessageSender<ModeReply>,
-            R1: MessageReceiver<REQUEST>,
+            S0: MessageSenderProvider<REQUEST>,
+            R0: MessageReceiverProvider<ModeReply>,
+            S1: MessageSenderProvider<ModeReply>,
+            R1: MessageReceiverProvider<REQUEST>,
        > ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
    {
        fn local_channel_id(&self) -> ComponentId {
@ -361,10 +376,10 @@ pub mod alloc_mod {

    impl<
            REQUEST,
-            S0: MessageSender<REQUEST>,
-            R0: MessageReceiver<ModeReply>,
-            S1: MessageSender<ModeReply>,
-            R1: MessageReceiver<REQUEST>,
+            S0: MessageSenderProvider<REQUEST>,
+            R0: MessageReceiverProvider<ModeReply>,
+            S1: MessageSenderProvider<ModeReply>,
+            R1: MessageReceiverProvider<REQUEST>,
        > ModeReplyReceiver
        for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
    {
@ -376,11 +391,14 @@ pub mod alloc_mod {
    }

    /// Helper type definition for a mode handler which can handle mode requests.
-    pub type ModeRequestHandlerInterface<S, R> =
-        MessageSenderAndReceiver<ModeReply, ModeRequest, S, R>;
+    pub type ModeRequestHandlerInterface<Sender, Receiver, ReplySenderStore> =
+        MessageSenderAndReceiver<ModeReply, ModeRequest, Sender, Receiver, ReplySenderStore>;

-    impl<S: MessageSender<ModeReply>, R: MessageReceiver<ModeRequest>>
-        ModeRequestHandlerInterface<S, R>
+    impl<
+            Sender: MessageSenderProvider<ModeReply>,
+            Receiver: MessageReceiverProvider<ModeRequest>,
+            ReplySenderStore: MessageSenderStoreProvider<ModeReply, Sender>,
+        > ModeRequestHandlerInterface<Sender, Receiver, ReplySenderStore>
    {
        pub fn try_recv_mode_request(
            &self,
@ -403,9 +421,15 @@ pub mod alloc_mod {

    /// Helper type defintion for a mode handler object which can send mode requests and receive
    /// mode replies.
-    pub type ModeRequestorInterface<S, R> = MessageSenderAndReceiver<ModeRequest, ModeReply, S, R>;
+    pub type ModeRequestorInterface<Sender, Receiver, RequestSenderStore> =
+        MessageSenderAndReceiver<ModeRequest, ModeReply, Sender, Receiver, RequestSenderStore>;

-    impl<S: MessageSender<ModeRequest>, R: MessageReceiver<ModeReply>> ModeRequestorInterface<S, R> {
+    impl<
+            Sender: MessageSenderProvider<ModeRequest>,
+            Receiver: MessageReceiverProvider<ModeReply>,
+            RequestSenderStore: MessageSenderStoreProvider<ModeRequest, Sender>,
+        > ModeRequestorInterface<Sender, Receiver, RequestSenderStore>
+    {
        pub fn try_recv_mode_reply(
            &self,
        ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
@ -427,7 +451,7 @@ pub mod alloc_mod {
    pub type ModeInterface<S0, R0, S1, R1> =
        RequestAndReplySenderAndReceiver<ModeRequest, ModeReply, S0, R0, S1, R1>;

-    impl<S: MessageSender<ModeRequest>> MessageSenderMap<ModeRequest, S> {
+    impl<S: MessageSenderProvider<ModeRequest>> MessageSenderMap<ModeRequest, S> {
        pub fn send_mode_request(
            &self,
            requestor_info: MessageMetadata,
@ -442,25 +466,13 @@ pub mod alloc_mod {
        }
    }

-    /*
-    impl<S: MessageSender<ModeRequest>> ModeRequestSender for MessageSenderMapWithId<ModeRequest, S> {
-        fn local_channel_id(&self) -> ComponentId {
-            self.local_channel_id
-        }
-
-        fn send_mode_request(
-            &self,
-            request_id: RequestId,
-            target_id: ComponentId,
-            request: ModeRequest,
-        ) -> Result<(), GenericTargetedMessagingError> {
-            self.send_message(request_id, target_id, request)
-        }
-    }
-    */
-
-    impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeRequest>> ModeRequestReceiver
-        for MessageSenderAndReceiver<TO, ModeRequest, S, R>
+    impl<
+            To,
+            Sender: MessageSenderProvider<To>,
+            Receiver: MessageReceiverProvider<ModeRequest>,
+            SenderStore: MessageSenderStoreProvider<To, Sender>,
+        > ModeRequestReceiver
+        for MessageSenderAndReceiver<To, ModeRequest, Sender, Receiver, SenderStore>
    {
        fn try_recv_mode_request(
            &self,
@ -469,8 +481,13 @@ pub mod alloc_mod {
        }
    }

-    impl<FROM, S: MessageSender<ModeRequest>, R: MessageReceiver<FROM>> ModeRequestSender
-        for MessageSenderAndReceiver<ModeRequest, FROM, S, R>
+    impl<
+            From,
+            Sender: MessageSenderProvider<ModeRequest>,
+            Receiver: MessageReceiverProvider<From>,
+            SenderStore: MessageSenderStoreProvider<ModeRequest, Sender>,
+        > ModeRequestSender
+        for MessageSenderAndReceiver<ModeRequest, From, Sender, Receiver, SenderStore>
    {
        fn local_channel_id(&self) -> ComponentId {
            self.local_channel_id_generic()
@ -482,7 +499,7 @@ pub mod alloc_mod {
            target_id: ComponentId,
            request: ModeRequest,
        ) -> Result<(), GenericTargetedMessagingError> {
-            self.message_sender_map.send_mode_request(
+            self.message_sender_store.send_message(
                MessageMetadata::new(request_id, self.local_channel_id()),
                target_id,
                request,
@ -492,10 +509,10 @@ pub mod alloc_mod {

    impl<
            REPLY,
-            S0: MessageSender<ModeRequest>,
-            R0: MessageReceiver<REPLY>,
-            S1: MessageSender<REPLY>,
-            R1: MessageReceiver<ModeRequest>,
+            S0: MessageSenderProvider<ModeRequest>,
+            R0: MessageReceiverProvider<REPLY>,
+            S1: MessageSenderProvider<REPLY>,
+            R1: MessageReceiverProvider<ModeRequest>,
        > RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
    {
        pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S0) {
@ -506,10 +523,10 @@ pub mod alloc_mod {

    impl<
            REPLY,
-            S0: MessageSender<ModeRequest>,
-            R0: MessageReceiver<REPLY>,
-            S1: MessageSender<REPLY>,
-            R1: MessageReceiver<ModeRequest>,
+            S0: MessageSenderProvider<ModeRequest>,
+            R0: MessageReceiverProvider<REPLY>,
+            S1: MessageSenderProvider<REPLY>,
+            R1: MessageReceiverProvider<ModeRequest>,
        > ModeRequestSender
        for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
    {
@ -533,10 +550,10 @@ pub mod alloc_mod {

    impl<
            REPLY,
-            S0: MessageSender<ModeRequest>,
-            R0: MessageReceiver<REPLY>,
-            S1: MessageSender<REPLY>,
-            R1: MessageReceiver<ModeRequest>,
+            S0: MessageSenderProvider<ModeRequest>,
+            R0: MessageReceiverProvider<REPLY>,
+            S1: MessageSenderProvider<REPLY>,
+            R1: MessageReceiverProvider<ModeRequest>,
        > ModeRequestReceiver
        for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
    {
@ -552,33 +569,55 @@ pub mod alloc_mod {
 pub mod std_mod {
    use std::sync::mpsc;

+    use crate::request::{MessageSenderList, OneMessageSender};
+
    use super::*;

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

-    pub type ModeRequestorMpsc = ModeRequestorInterface<
+    pub type ModeRequestorOneChildMpsc = ModeRequestorInterface<
        mpsc::Sender<GenericMessage<ModeRequest>>,
        mpsc::Receiver<GenericMessage<ModeReply>>,
+        OneMessageSender<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
    >;
-    pub type ModeRequestorBoundedMpsc = ModeRequestorInterface<
+    pub type ModeRequestorOneChildBoundedMpsc = ModeRequestorInterface<
        mpsc::SyncSender<GenericMessage<ModeRequest>>,
        mpsc::Receiver<GenericMessage<ModeReply>>,
+        OneMessageSender<
+            ModeRequest,
+            mpsc::SyncSender<GenericMessage<ModeRequest>>,
+        >,
+    >;
+    pub type ModeRequestorMultiChildListMpsc = ModeRequestorInterface<
+        mpsc::Sender<GenericMessage<ModeRequest>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+        MessageSenderList<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
+    >;
+    pub type ModeRequestorMultiChildListBoundedMpsc = ModeRequestorInterface<
+        mpsc::SyncSender<GenericMessage<ModeRequest>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+        MessageSenderList<
+            ModeRequest,
+            mpsc::SyncSender<GenericMessage<ModeRequest>>,
+        >,
    >;

-    pub type ModeRequestorAndHandlerMpsc = ModeInterface<
+    pub type ModeRequestorAndHandlerOneParentMpsc = ModeInterface<
        mpsc::Sender<GenericMessage<ModeRequest>>,
        mpsc::Receiver<GenericMessage<ModeReply>>,
        mpsc::Sender<GenericMessage<ModeReply>>,
        mpsc::Receiver<GenericMessage<ModeRequest>>,
    >;
-    pub type ModeRequestorAndHandlerMpscBounded = ModeInterface<
+    pub type ModeRequestorAndHandlerOneParentMpscBounded = ModeInterface<
        mpsc::SyncSender<GenericMessage<ModeRequest>>,
        mpsc::Receiver<GenericMessage<ModeReply>>,
        mpsc::SyncSender<GenericMessage<ModeReply>>,
--- a/satrs/src/mode_tree.rs
+++ b/satrs/src/mode_tree.rs
@ -3,7 +3,7 @@ use hashbrown::HashMap;

 use crate::{
    mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, Submode},
-    request::MessageSender,
+    request::MessageSenderProvider,
    ComponentId,
 };

@ -19,7 +19,7 @@ pub trait ModeNode {
 /// A mode parent is capable of sending mode requests to child objects and has a unique component
 /// ID.
 pub trait ModeParent: ModeNode {
-    type Sender: MessageSender<ModeRequest>;
+    type Sender: MessageSenderProvider<ModeRequest>;

    fn add_mode_child(&mut self, id: ComponentId, request_sender: Self::Sender);
 }
@ -28,7 +28,7 @@ pub trait ModeParent: ModeNode {
 ///
 /// A child is capable of sending mode replies to parent objects and has a unique component ID.
 pub trait ModeChild: ModeNode {
-    type Sender: MessageSender<ModeReply>;
+    type Sender: MessageSenderProvider<ModeReply>;

    fn add_mode_parent(&mut self, id: ComponentId, reply_sender: Self::Sender);
 }
--- a/satrs/src/pus/action.rs
+++ b/satrs/src/pus/action.rs
@ -68,7 +68,8 @@ pub mod alloc_mod {
        action::ActionRequest,
        queue::GenericTargetedMessagingError,
        request::{
-            GenericMessage, MessageReceiver, MessageSender, MessageSenderAndReceiver, RequestId,
+            GenericMessage, MessageReceiverProvider, MessageSenderAndReceiver,
+            MessageSenderProvider, MessageSenderStoreProvider, RequestId,
        },
        ComponentId,
    };
@ -76,11 +77,14 @@ pub mod alloc_mod {
    use super::ActionReplyPus;

    /// Helper type definition for a mode handler which can handle mode requests.
-    pub type ActionRequestHandlerInterface<S, R> =
-        MessageSenderAndReceiver<ActionReplyPus, ActionRequest, S, R>;
+    pub type ActionRequestHandlerInterface<Sender, Receiver, ReplySenderStore> =
+        MessageSenderAndReceiver<ActionReplyPus, ActionRequest, Sender, Receiver, ReplySenderStore>;

-    impl<S: MessageSender<ActionReplyPus>, R: MessageReceiver<ActionRequest>>
-        ActionRequestHandlerInterface<S, R>
+    impl<
+            Sender: MessageSenderProvider<ActionReplyPus>,
+            Receiver: MessageReceiverProvider<ActionRequest>,
+            ReplySender: MessageSenderStoreProvider<ActionReplyPus, Sender>,
+        > ActionRequestHandlerInterface<Sender, Receiver, ReplySender>
    {
        pub fn try_recv_action_request(
            &self,
@ -100,11 +104,20 @@ pub mod alloc_mod {

    /// Helper type defintion for a mode handler object which can send mode requests and receive
    /// mode replies.
-    pub type ActionRequestorInterface<S, R> =
-        MessageSenderAndReceiver<ActionRequest, ActionReplyPus, S, R>;
+    pub type ActionRequestorInterface<Sender, Receiver, RequestSenderStore> =
+        MessageSenderAndReceiver<
+            ActionRequest,
+            ActionReplyPus,
+            Sender,
+            Receiver,
+            RequestSenderStore,
+        >;

-    impl<S: MessageSender<ActionRequest>, R: MessageReceiver<ActionReplyPus>>
-        ActionRequestorInterface<S, R>
+    impl<
+            Sender: MessageSenderProvider<ActionRequest>,
+            Receiver: MessageReceiverProvider<ActionReplyPus>,
+            RequestSenderStore: MessageSenderStoreProvider<ActionRequest, Sender>,
+        > ActionRequestorInterface<Sender, Receiver, RequestSenderStore>
    {
        pub fn try_recv_action_reply(
            &self,
@ -132,6 +145,7 @@ pub mod std_mod {
            verification::{self, TcStateToken},
            ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap,
        },
+        request::{MessageSenderMap, OneMessageSender},
        ComponentId,
    };

@ -174,22 +188,38 @@ pub mod std_mod {
    }
    pub type DefaultActiveActionRequestMap = DefaultActiveRequestMap<ActivePusActionRequestStd>;

-    pub type ActionRequestHandlerMpsc = ActionRequestHandlerInterface<
+    pub type ActionRequestHandlerOneSenderMpsc = ActionRequestHandlerInterface<
        mpsc::Sender<GenericMessage<ActionReplyPus>>,
        mpsc::Receiver<GenericMessage<ActionRequest>>,
+        OneMessageSender<
+            GenericMessage<ActionReplyPus>,
+            mpsc::Sender<GenericMessage<ActionReplyPus>>,
+        >,
    >;
-    pub type ActionRequestHandlerMpscBounded = ActionRequestHandlerInterface<
+    pub type ActionRequestHandlerOneSenderMpscBounded = ActionRequestHandlerInterface<
        mpsc::SyncSender<GenericMessage<ActionReplyPus>>,
        mpsc::Receiver<GenericMessage<ActionRequest>>,
+        OneMessageSender<
+            GenericMessage<ActionReplyPus>,
+            mpsc::SyncSender<GenericMessage<ActionReplyPus>>,
+        >,
    >;

-    pub type ActionRequestorMpsc = ActionRequestorInterface<
+    pub type ActionRequestorWithSenderMapMpsc = ActionRequestorInterface<
        mpsc::Sender<GenericMessage<ActionRequest>>,
        mpsc::Receiver<GenericMessage<ActionReplyPus>>,
+        MessageSenderMap<
+            GenericMessage<ActionRequest>,
+            mpsc::Sender<GenericMessage<ActionRequest>>,
+        >,
    >;
-    pub type ActionRequestorBoundedMpsc = ActionRequestorInterface<
+    pub type ActionRequestorWithSenderMapBoundedMpsc = ActionRequestorInterface<
        mpsc::SyncSender<GenericMessage<ActionRequest>>,
        mpsc::Receiver<GenericMessage<ActionReplyPus>>,
+        MessageSenderMap<
+            GenericMessage<ActionRequest>,
+            mpsc::SyncSender<GenericMessage<ActionRequest>>,
+        >,
    >;
 }

--- a/satrs/src/pus/mode.rs
+++ b/satrs/src/pus/mode.rs
@ -39,7 +39,7 @@ mod tests {
    use crate::{
        mode::{
            ModeAndSubmode, ModeReply, ModeReplySender, ModeRequest, ModeRequestSender,
-            ModeRequestorAndHandlerMpsc, ModeRequestorMpsc,
+            ModeRequestorAndHandlerOneParentMpsc, ModeRequestorOneChildMpsc,
        },
        request::{GenericMessage, MessageMetadata},
    };
@ -52,7 +52,7 @@ 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 = ModeRequestorMpsc::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.
@ -89,7 +89,7 @@ mod tests {

        let (request_sender_to_channel_1, request_receiver_channel_1) = mpsc::channel();
        //let (reply_sender_to_channel_2, reply_receiver_channel_2) = mpsc::channel();
-        let mut mode_connector = ModeRequestorAndHandlerMpsc::new(
+        let mut mode_connector = ModeRequestorAndHandlerOneParentMpsc::new(
            TEST_COMPONENT_ID_0,
            request_receiver_of_connector,
            reply_receiver_of_connector,
@ -128,7 +128,7 @@ mod tests {
        let (_request_sender_to_connector, request_receiver_of_connector) = mpsc::channel();

        let (reply_sender_to_channel_2, reply_receiver_channel_2) = mpsc::channel();
-        let mut mode_connector = ModeRequestorAndHandlerMpsc::new(
+        let mut mode_connector = ModeRequestorAndHandlerOneParentMpsc::new(
            TEST_COMPONENT_ID_0,
            request_receiver_of_connector,
            reply_receiver_of_connector,
--- a/satrs/src/request.rs
+++ b/satrs/src/request.rs
@ -140,24 +140,27 @@ impl<Message> GenericMessage<Message> {
 }

 /// Generic trait for objects which can send targeted messages.
-pub trait MessageSender<MSG>: Send {
+pub trait MessageSenderProvider<MSG>: Send {
    fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError>;
 }

 // Generic trait for objects which can receive targeted messages.
-pub trait MessageReceiver<MSG> {
+pub trait MessageReceiverProvider<MSG> {
    fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError>;
 }

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

-impl<MSG, R: MessageReceiver<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> {
+impl<MSG, R: MessageReceiverProvider<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> {
    fn from(receiver: R) -> Self {
        MessageWithSenderIdReceiver(receiver, PhantomData)
    }
 }

-impl<MSG, R: MessageReceiver<MSG>> MessageWithSenderIdReceiver<MSG, R> {
+impl<MSG, R: MessageReceiverProvider<MSG>> MessageWithSenderIdReceiver<MSG, R> {
    pub fn try_recv_message(
        &self,
    ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
@ -165,12 +168,12 @@ impl<MSG, R: MessageReceiver<MSG>> MessageWithSenderIdReceiver<MSG, R> {
    }
 }

-pub struct MessageReceiverWithId<MSG, R: MessageReceiver<MSG>> {
+pub struct MessageReceiverWithId<MSG, R: MessageReceiverProvider<MSG>> {
    local_channel_id: ComponentId,
    reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
 }

-impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
+impl<MSG, R: MessageReceiverProvider<MSG>> MessageReceiverWithId<MSG, R> {
    pub fn new(local_channel_id: ComponentId, reply_receiver: R) -> Self {
        Self {
            local_channel_id,
@ -183,7 +186,7 @@ impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
    }
 }

-impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
+impl<MSG, R: MessageReceiverProvider<MSG>> MessageReceiverWithId<MSG, R> {
    pub fn try_recv_message(
        &self,
    ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
@ -191,6 +194,17 @@ impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
    }
 }

+pub trait MessageSenderStoreProvider<Message, Sender>: Default {
+    fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender);
+
+    fn send_message(
+        &self,
+        requestor_info: MessageMetadata,
+        target_channel_id: ComponentId,
+        message: Message,
+    ) -> Result<(), GenericTargetedMessagingError>;
+}
+
 #[cfg(feature = "alloc")]
 pub mod alloc_mod {
    use crate::queue::GenericSendError;
@ -198,23 +212,99 @@ pub mod alloc_mod {
    use super::*;
    use hashbrown::HashMap;

-    pub struct MessageSenderMap<MSG, S: MessageSender<MSG>>(
-        pub HashMap<ComponentId, S>,
+    pub struct OneMessageSender<Msg, S: MessageSenderProvider<Msg>> {
+        pub id_and_sender: Option<(ComponentId, S)>,
+        pub(crate) phantom: PhantomData<Msg>,
+    }
+
+    impl<Msg, S: MessageSenderProvider<Msg>> Default for OneMessageSender<Msg, S> {
+        fn default() -> Self {
+            Self {
+                id_and_sender: Default::default(),
+                phantom: Default::default(),
+            }
+        }
+    }
+
+    impl<Msg, S: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, S>
+        for OneMessageSender<Msg, S>
+    {
+        fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
+            if self.id_and_sender.is_some() {
+                return;
+            }
+            self.id_and_sender = Some((target_id, message_sender));
+        }
+
+        fn send_message(
+            &self,
+            requestor_info: MessageMetadata,
+            target_channel_id: ComponentId,
+            message: Msg,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            if let Some((current_id, sender)) = &self.id_and_sender {
+                if *current_id == target_channel_id {
+                    sender.send(GenericMessage::new(requestor_info, message))?;
+                    return Ok(());
+                }
+            }
+            Err(GenericSendError::TargetDoesNotExist(target_channel_id).into())
+        }
+    }
+
+    pub struct MessageSenderList<MSG, S: MessageSenderProvider<MSG>>(
+        pub alloc::vec::Vec<(ComponentId, S)>,
        pub(crate) PhantomData<MSG>,
    );

-    impl<MSG, S: MessageSender<MSG>> Default for MessageSenderMap<MSG, S> {
+    impl<MSG, S: MessageSenderProvider<MSG>> Default for MessageSenderList<MSG, S> {
        fn default() -> Self {
            Self(Default::default(), PhantomData)
        }
    }

-    impl<MSG, S: MessageSender<MSG>> MessageSenderMap<MSG, S> {
-        pub fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
+    impl<MSG, S: MessageSenderProvider<MSG>> MessageSenderStoreProvider<MSG, S>
+        for MessageSenderList<MSG, S>
+    {
+        fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
+            self.0.push((target_id, message_sender));
+        }
+
+        fn send_message(
+            &self,
+            requestor_info: MessageMetadata,
+            target_channel_id: ComponentId,
+            message: MSG,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            for (current_id, sender) in &self.0 {
+                if *current_id == target_channel_id {
+                    sender.send(GenericMessage::new(requestor_info, message))?;
+                    return Ok(());
+                }
+            }
+            Err(GenericSendError::TargetDoesNotExist(target_channel_id).into())
+        }
+    }
+
+    pub struct MessageSenderMap<MSG, S: MessageSenderProvider<MSG>>(
+        pub HashMap<ComponentId, S>,
+        pub(crate) PhantomData<MSG>,
+    );
+
+    impl<MSG, S: MessageSenderProvider<MSG>> Default for MessageSenderMap<MSG, S> {
+        fn default() -> Self {
+            Self(Default::default(), PhantomData)
+        }
+    }
+
+    impl<MSG, S: MessageSenderProvider<MSG>> MessageSenderStoreProvider<MSG, S>
+        for MessageSenderMap<MSG, S>
+    {
+        fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
            self.0.insert(target_id, message_sender);
        }

-        pub fn send_message(
+        fn send_message(
            &self,
            requestor_info: MessageMetadata,
            target_channel_id: ComponentId,
@ -231,25 +321,38 @@ pub mod alloc_mod {
        }
    }

-    pub struct MessageSenderAndReceiver<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>> {
+    pub struct MessageSenderAndReceiver<
+        To,
+        From,
+        Sender: MessageSenderProvider<To>,
+        Receiver: MessageReceiverProvider<From>,
+        SenderStore: MessageSenderStoreProvider<To, Sender>,
+    > {
        pub local_channel_id: ComponentId,
-        pub message_sender_map: MessageSenderMap<TO, S>,
-        pub message_receiver: MessageWithSenderIdReceiver<FROM, R>,
+        pub message_sender_store: SenderStore,
+        pub message_receiver: MessageWithSenderIdReceiver<From, Receiver>,
+        pub(crate) phantom: PhantomData<(To, Sender)>,
    }

-    impl<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>>
-        MessageSenderAndReceiver<TO, FROM, S, R>
+    impl<
+            To,
+            From,
+            Sender: MessageSenderProvider<To>,
+            Receiver: MessageReceiverProvider<From>,
+            SenderStore: MessageSenderStoreProvider<To, Sender>,
+        > MessageSenderAndReceiver<To, From, Sender, Receiver, SenderStore>
    {
-        pub fn new(local_channel_id: ComponentId, message_receiver: R) -> Self {
+        pub fn new(local_channel_id: ComponentId, message_receiver: Receiver) -> Self {
            Self {
                local_channel_id,
-                message_sender_map: Default::default(),
+                message_sender_store: Default::default(),
                message_receiver: MessageWithSenderIdReceiver::from(message_receiver),
+                phantom: PhantomData,
            }
        }

-        pub fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
-            self.message_sender_map
+        pub fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender) {
+            self.message_sender_store
                .add_message_target(target_id, message_sender)
        }

@ -262,9 +365,9 @@ pub mod alloc_mod {
            &self,
            request_id: RequestId,
            target_id: ComponentId,
-            message: TO,
+            message: To,
        ) -> Result<(), GenericTargetedMessagingError> {
-            self.message_sender_map.send_message(
+            self.message_sender_store.send_message(
                MessageMetadata::new(request_id, self.local_channel_id_generic()),
                target_id,
                message,
@ -274,7 +377,7 @@ pub mod alloc_mod {
        /// Try to receive a message, which can be a reply or a request, depending on the generics.
        pub fn try_recv_message(
            &self,
-        ) -> Result<Option<GenericMessage<FROM>>, GenericTargetedMessagingError> {
+        ) -> Result<Option<GenericMessage<From>>, GenericTargetedMessagingError> {
            self.message_receiver.try_recv_message()
        }
    }
@ -282,10 +385,10 @@ pub mod alloc_mod {
    pub struct RequestAndReplySenderAndReceiver<
        REQUEST,
        REPLY,
-        S0: MessageSender<REQUEST>,
-        R0: MessageReceiver<REPLY>,
-        S1: MessageSender<REPLY>,
-        R1: MessageReceiver<REQUEST>,
+        S0: MessageSenderProvider<REQUEST>,
+        R0: MessageReceiverProvider<REPLY>,
+        S1: MessageSenderProvider<REPLY>,
+        R1: MessageReceiverProvider<REQUEST>,
    > {
        pub local_channel_id: ComponentId,
        // These 2 are a functional group.
@ -299,10 +402,10 @@ pub mod alloc_mod {
    impl<
            REQUEST,
            REPLY,
-            S0: MessageSender<REQUEST>,
-            R0: MessageReceiver<REPLY>,
-            S1: MessageSender<REPLY>,
-            R1: MessageReceiver<REQUEST>,
+            S0: MessageSenderProvider<REQUEST>,
+            R0: MessageReceiverProvider<REPLY>,
+            S1: MessageSenderProvider<REPLY>,
+            R1: MessageReceiverProvider<REQUEST>,
        > RequestAndReplySenderAndReceiver<REQUEST, REPLY, S0, R0, S1, R1>
    {
        pub fn new(
@ -333,14 +436,14 @@ pub mod std_mod {

    use crate::queue::{GenericReceiveError, GenericSendError};

-    impl<MSG: Send> MessageSender<MSG> for mpsc::Sender<GenericMessage<MSG>> {
+    impl<MSG: Send> MessageSenderProvider<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<GenericMessage<MSG>> {
+    impl<MSG: Send> MessageSenderProvider<MSG> for mpsc::SyncSender<GenericMessage<MSG>> {
        fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError> {
            if let Err(e) = self.try_send(message) {
                return match e {
@ -357,7 +460,7 @@ pub mod std_mod {
    pub type MessageSenderMapMpsc<MSG> = MessageReceiverWithId<MSG, mpsc::Sender<MSG>>;
    pub type MessageSenderMapBoundedMpsc<MSG> = MessageReceiverWithId<MSG, mpsc::SyncSender<MSG>>;

-    impl<MSG> MessageReceiver<MSG> for mpsc::Receiver<GenericMessage<MSG>> {
+    impl<MSG> MessageReceiverProvider<MSG> for mpsc::Receiver<GenericMessage<MSG>> {
        fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
            match self.try_recv() {
                Ok(msg) => Ok(Some(msg)),
@ -386,7 +489,7 @@ mod tests {

    use crate::{
        queue::{GenericReceiveError, GenericSendError, GenericTargetedMessagingError},
-        request::{MessageMetadata, MessageSenderMap},
+        request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider},
    };

    use super::{GenericMessage, MessageReceiverWithId, UniqueApidTargetId};