re-introduce layering

satrs-example/src/pus/action.rs

@@ -1,5 +1,5 @@
 use log::{error, warn};
-use satrs::action::ActionRequest;
+use satrs::action::{ActionRequest, ActionRequestVariant};
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::action::{PusActionToRequestConverter, PusService8ActionHandler};
 use satrs::pus::verification::std_mod::{
@@ -58,10 +58,10 @@ impl PusActionToRequestConverter for ExampleActionRequestConverter {
         if subservice == 128 {
             Ok((
                 target_id.raw(),
-                ActionRequest::UnsignedIdAndVecData {
+                ActionRequest::new(
                     action_id,
-                    data: user_data[8..].to_vec(),
+                    ActionRequestVariant::VecData(user_data[8..].to_vec()),
-                },
+                ),
             ))
         } else {
             verif_reporter

satrs/src/action.rs

@@ -1,71 +1,76 @@
-use crate::{params::Params, pool::StoreAddr, TargetId};
+use crate::{params::Params, pool::StoreAddr};
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub use alloc_mod::*;
 
 pub type ActionId = u32;
 
-#[non_exhaustive]
+#[derive(Debug, Eq, PartialEq, Clone)]
-#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct ActionRequest {
-pub enum ActionRequest {
+    pub action_id: ActionId,
-    UnsignedIdAndStoreData {
+    pub variant: ActionRequestVariant,
-        action_id: ActionId,
-        data_addr: StoreAddr,
-    },
-    #[cfg(feature = "alloc")]
-    UnsignedIdAndVecData {
-        action_id: ActionId,
-        data: alloc::vec::Vec<u8>,
-    },
-    #[cfg(feature = "alloc")]
-    StringIdAndVecData {
-        action_id: alloc::string::String,
-        data: alloc::vec::Vec<u8>,
-    },
-    #[cfg(feature = "alloc")]
-    StringIdAndStoreData {
-        action_id: alloc::string::String,
-        data: StoreAddr,
-    },
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+impl ActionRequest {
-pub struct TargetedActionRequest {
+    pub fn new(action_id: ActionId, variant: ActionRequestVariant) -> Self {
-    target: TargetId,
+        Self { action_id, variant }
-    action_request: ActionRequest,
-}
-
-impl TargetedActionRequest {
-    pub fn new(target: TargetId, action_request: ActionRequest) -> Self {
-        Self {
-            target,
-            action_request,
-        }
     }
 }
 
-/// A reply to an action request specific to PUS.
 #[non_exhaustive]
-#[derive(Clone, Debug)]
+#[derive(Clone, Eq, PartialEq, Debug)]
-pub enum ActionReply {
+pub enum ActionRequestVariant {
-    CompletionFailed {
+    StoreData(StoreAddr),
-        id: ActionId,
-        reason: Params,
-    },
-    StepFailed {
-        id: ActionId,
-        step: u32,
-        reason: Params,
-    },
-    Completed(ActionId),
     #[cfg(feature = "alloc")]
-    CompletedStringId(alloc::string::String),
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
-    #[cfg(feature = "alloc")]
+    VecData(alloc::vec::Vec<u8>),
-    CompletionFailedStringId {
-        id: alloc::string::String,
-        reason: Params,
-    },
-    #[cfg(feature = "alloc")]
-    StepFailedStringId {
-        id: alloc::string::String,
-        step: u32,
-        reason: Params,
-    },
 }
+
+#[derive(Debug, PartialEq, Clone)]
+pub struct ActionReply {
+    pub action_id: ActionId,
+    pub variant: ActionReplyVariant,
+}
+
+/// A reply to an action request.
+#[non_exhaustive]
+#[derive(Clone, Debug, PartialEq)]
+pub enum ActionReplyVariant {
+    CompletionFailed(Params),
+    StepFailed { step: u32, reason: Params },
+    Completed,
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub mod alloc_mod {
+    use super::*;
+
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    #[derive(Debug, Eq, PartialEq, Clone)]
+    pub struct ActionRequestStringId {
+        pub action_id: alloc::string::String,
+        pub variant: ActionRequestVariant,
+    }
+
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    impl ActionRequestStringId {
+        pub fn new(action_id: alloc::string::String, variant: ActionRequestVariant) -> Self {
+            Self { action_id, variant }
+        }
+    }
+
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    #[derive(Debug, PartialEq, Clone)]
+    pub struct ActionReplyStringId {
+        pub action_id: alloc::string::String,
+        pub variant: ActionReplyVariant,
+    }
+}
+
+#[cfg(test)]
+mod tests {}

satrs/src/mode.rs

@@ -3,7 +3,11 @@ use core::mem::size_of;
 use serde::{Deserialize, Serialize};
 use spacepackets::ByteConversionError;
 
-use crate::TargetId;
+use crate::{
+    queue::GenericTargetedMessagingError,
+    request::{GenericMessage, MessageReceiver, MessageReceiverWithId, RequestId},
+    ChannelId, TargetId,
+};
 
 pub type Mode = u32;
 pub type Submode = u16;
@@ -114,3 +118,385 @@ pub struct TargetedModeRequest {
     target_id: TargetId,
     mode_request: ModeRequest,
 }
+
+pub trait ModeRequestSender {
+    fn local_channel_id(&self) -> ChannelId;
+    fn send_mode_request(
+        &self,
+        request_id: RequestId,
+        target_id: ChannelId,
+        request: ModeRequest,
+    ) -> Result<(), GenericTargetedMessagingError>;
+}
+
+pub trait ModeReplySender {
+    fn local_channel_id(&self) -> ChannelId;
+
+    fn send_mode_reply(
+        &self,
+        request_id: RequestId,
+        target_id: ChannelId,
+        reply: ModeReply,
+    ) -> Result<(), GenericTargetedMessagingError>;
+}
+
+pub trait ModeRequestReceiver {
+    fn try_recv_mode_request(
+        &self,
+    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError>;
+}
+
+pub trait ModeReplyReceiver {
+    fn try_recv_mode_reply(
+        &self,
+    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError>;
+}
+
+impl<R: MessageReceiver<ModeReply>> ModeReplyReceiver for MessageReceiverWithId<ModeReply, R> {
+    fn try_recv_mode_reply(
+        &self,
+    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
+        self.try_recv_message()
+    }
+}
+
+impl<R: MessageReceiver<ModeRequest>> ModeRequestReceiver
+    for MessageReceiverWithId<ModeRequest, R>
+{
+    fn try_recv_mode_request(
+        &self,
+    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
+        self.try_recv_message()
+    }
+}
+
+pub trait ModeProvider {
+    fn mode_and_submode(&self) -> ModeAndSubmode;
+}
+
+#[derive(Debug, Clone)]
+pub enum ModeError {
+    Messaging(GenericTargetedMessagingError),
+}
+
+impl From<GenericTargetedMessagingError> for ModeError {
+    fn from(value: GenericTargetedMessagingError) -> Self {
+        Self::Messaging(value)
+    }
+}
+
+pub trait ModeRequestHandler: ModeProvider {
+    fn start_transition(
+        &mut self,
+        request_id: RequestId,
+        sender_id: ChannelId,
+        mode_and_submode: ModeAndSubmode,
+    ) -> Result<(), ModeError>;
+
+    fn announce_mode(&self, request_id: RequestId, sender_id: ChannelId, recursive: bool);
+    fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError>;
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub mod alloc_mod {
+    use crate::request::{MessageSenderAndReceiver, RequestAndReplySenderAndReceiver};
+
+    use super::*;
+
+    impl<FROM, S: MessageSender<ModeRequest>, R: MessageReceiver<FROM>> ModeRequestSender
+        for MessageSenderAndReceiver<ModeRequest, FROM, S, R>
+    {
+        fn local_channel_id(&self) -> ChannelId {
+            self.local_channel_id_generic()
+        }
+
+        fn send_mode_request(
+            &self,
+            request_id: RequestId,
+            target_id: ChannelId,
+            request: ModeRequest,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.message_sender_map.send_mode_request(
+                request_id,
+                self.local_channel_id(),
+                target_id,
+                request,
+            )
+        }
+    }
+
+    impl<
+            REPLY,
+            S0: MessageSender<ModeRequest>,
+            R0: MessageReceiver<REPLY>,
+            S1: MessageSender<REPLY>,
+            R1: MessageReceiver<ModeRequest>,
+        > RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+    {
+        pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S0) {
+            self.request_sender_map
+                .add_message_target(target_id, request_sender)
+        }
+    }
+
+    impl<
+            REQUEST,
+            S0: MessageSender<REQUEST>,
+            R0: MessageReceiver<ModeReply>,
+            S1: MessageSender<ModeReply>,
+            R1: MessageReceiver<REQUEST>,
+        > RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+    {
+        pub fn add_reply_target(&mut self, target_id: ChannelId, reply_sender: S1) {
+            self.reply_sender_map
+                .add_message_target(target_id, reply_sender)
+        }
+    }
+
+    impl<
+            REPLY,
+            S0: MessageSender<ModeRequest>,
+            R0: MessageReceiver<REPLY>,
+            S1: MessageSender<REPLY>,
+            R1: MessageReceiver<ModeRequest>,
+        > ModeRequestSender
+        for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+    {
+        fn local_channel_id(&self) -> ChannelId {
+            self.local_channel_id_generic()
+        }
+
+        fn send_mode_request(
+            &self,
+            request_id: RequestId,
+            target_id: ChannelId,
+            request: ModeRequest,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.request_sender_map.send_mode_request(
+                request_id,
+                self.local_channel_id(),
+                target_id,
+                request,
+            )
+        }
+    }
+
+    impl<
+            REQUEST,
+            S0: MessageSender<REQUEST>,
+            R0: MessageReceiver<ModeReply>,
+            S1: MessageSender<ModeReply>,
+            R1: MessageReceiver<REQUEST>,
+        > ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+    {
+        fn local_channel_id(&self) -> ChannelId {
+            self.local_channel_id_generic()
+        }
+
+        fn send_mode_reply(
+            &self,
+            request_id: RequestId,
+            target_id: ChannelId,
+            request: ModeReply,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.reply_sender_map.send_mode_reply(
+                request_id,
+                self.local_channel_id(),
+                target_id,
+                request,
+            )
+        }
+    }
+
+    impl<
+            REQUEST,
+            S0: MessageSender<REQUEST>,
+            R0: MessageReceiver<ModeReply>,
+            S1: MessageSender<ModeReply>,
+            R1: MessageReceiver<REQUEST>,
+        > ModeReplyReceiver
+        for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+    {
+        fn try_recv_mode_reply(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
+            self.reply_receiver
+                .try_recv_message(self.local_channel_id_generic())
+        }
+    }
+
+    impl<
+            REPLY,
+            S0: MessageSender<ModeRequest>,
+            R0: MessageReceiver<REPLY>,
+            S1: MessageSender<REPLY>,
+            R1: MessageReceiver<ModeRequest>,
+        > ModeRequestReceiver
+        for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+    {
+        fn try_recv_mode_request(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
+            self.request_receiver
+                .try_recv_message(self.local_channel_id_generic())
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+pub mod std_mod {
+    use std::sync::mpsc;
+
+    use crate::request::{
+        MessageSenderAndReceiver, MessageSenderMap, MessageSenderMapWithId,
+        RequestAndReplySenderAndReceiver,
+    };
+
+    use super::*;
+
+    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(request_id, local_id, target_id, request)
+        }
+
+        pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S) {
+            self.add_message_target(target_id, request_sender)
+        }
+    }
+
+    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(request_id, local_id, target_id, request)
+        }
+
+        pub fn add_reply_target(&mut self, target_id: ChannelId, request_sender: S) {
+            self.add_message_target(target_id, request_sender)
+        }
+    }
+
+    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(request_id, target_channel_id, reply)
+        }
+
+        fn local_channel_id(&self) -> ChannelId {
+            self.local_channel_id
+        }
+    }
+
+    impl<S: MessageSender<ModeRequest>> ModeRequestSender for MessageSenderMapWithId<ModeRequest, S> {
+        fn local_channel_id(&self) -> ChannelId {
+            self.local_channel_id
+        }
+
+        fn send_mode_request(
+            &self,
+            request_id: RequestId,
+            target_id: ChannelId,
+            request: ModeRequest,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.send_message(request_id, target_id, request)
+        }
+    }
+
+    impl<FROM, S: MessageSender<ModeReply>, R: MessageReceiver<FROM>> ModeReplySender
+        for MessageSenderAndReceiver<ModeReply, FROM, S, R>
+    {
+        fn local_channel_id(&self) -> ChannelId {
+            self.local_channel_id_generic()
+        }
+
+        fn send_mode_reply(
+            &self,
+            request_id: RequestId,
+            target_id: ChannelId,
+            request: ModeReply,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.message_sender_map.send_mode_reply(
+                request_id,
+                self.local_channel_id(),
+                target_id,
+                request,
+            )
+        }
+    }
+
+    impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeReply>> ModeReplyReceiver
+        for MessageSenderAndReceiver<TO, ModeReply, S, R>
+    {
+        fn try_recv_mode_reply(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
+            self.message_receiver
+                .try_recv_message(self.local_channel_id_generic())
+        }
+    }
+    impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeRequest>> ModeRequestReceiver
+        for MessageSenderAndReceiver<TO, ModeRequest, S, R>
+    {
+        fn try_recv_mode_request(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
+            self.message_receiver
+                .try_recv_message(self.local_channel_id_generic())
+        }
+    }
+
+    pub type ModeRequestHandlerConnector<S, R> =
+        MessageSenderAndReceiver<ModeReply, ModeRequest, S, R>;
+    pub type MpscModeRequestHandlerConnector = ModeRequestHandlerConnector<
+        mpsc::Sender<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeRequest>>,
+    >;
+    pub type MpscBoundedModeRequestHandlerConnector = ModeRequestHandlerConnector<
+        mpsc::SyncSender<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeRequest>>,
+    >;
+
+    pub type ModeRequestorConnector<S, R> = MessageSenderAndReceiver<ModeRequest, ModeReply, S, R>;
+    pub type MpscModeRequestorConnector = ModeRequestorConnector<
+        mpsc::Sender<GenericMessage<ModeRequest>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+    >;
+    pub type MpscBoundedModeRequestorConnector = ModeRequestorConnector<
+        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<GenericMessage<ModeRequest>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+        mpsc::Sender<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeRequest>>,
+    >;
+    pub type MpscBoundedModeConnector = ModeConnector<
+        mpsc::SyncSender<GenericMessage<ModeRequest>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+        mpsc::SyncSender<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeRequest>>,
+    >;
+}
+
+#[cfg(test)]
+mod tests {}

satrs/src/mode_tree.rs

@@ -1,15 +1,8 @@
 use alloc::vec::Vec;
 use hashbrown::HashMap;
-use std::sync::mpsc;
 
 use crate::{
-    mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, Submode},
+    mode::{Mode, ModeAndSubmode, Submode},
-    queue::GenericTargetedMessagingError,
-    request::{
-        GenericMessage, MessageReceiver, MessageReceiverWithId, MessageSender,
-        MessageSenderAndReceiver, MessageSenderMap, MessageSenderMapWithId,
-        RequestAndReplySenderAndReceiver, RequestId,
-    },
     ChannelId,
 };
 
@@ -40,359 +33,5 @@ pub struct ModeTableMapValue {
 
 pub type ModeTable = HashMap<Mode, ModeTableMapValue>;
 
-pub trait ModeRequestSender {
-    fn local_channel_id(&self) -> ChannelId;
-    fn send_mode_request(
-        &self,
-        request_id: RequestId,
-        target_id: ChannelId,
-        request: ModeRequest,
-    ) -> Result<(), GenericTargetedMessagingError>;
-}
-
-pub trait ModeReplySender {
-    fn local_channel_id(&self) -> ChannelId;
-
-    fn send_mode_reply(
-        &self,
-        request_id: RequestId,
-        target_id: ChannelId,
-        reply: ModeReply,
-    ) -> Result<(), GenericTargetedMessagingError>;
-}
-
-pub trait ModeRequestReceiver {
-    fn try_recv_mode_request(
-        &self,
-    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError>;
-}
-
-pub trait ModeReplyReceiver {
-    fn try_recv_mode_reply(
-        &self,
-    ) -> 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(request_id, local_id, target_id, request)
-    }
-
-    pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S) {
-        self.add_message_target(target_id, request_sender)
-    }
-}
-
-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(request_id, local_id, target_id, request)
-    }
-
-    pub fn add_reply_target(&mut self, target_id: ChannelId, request_sender: S) {
-        self.add_message_target(target_id, request_sender)
-    }
-}
-
-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(request_id, target_channel_id, reply)
-    }
-
-    fn local_channel_id(&self) -> ChannelId {
-        self.local_channel_id
-    }
-}
-
-impl<S: MessageSender<ModeRequest>> ModeRequestSender for MessageSenderMapWithId<ModeRequest, S> {
-    fn local_channel_id(&self) -> ChannelId {
-        self.local_channel_id
-    }
-
-    fn send_mode_request(
-        &self,
-        request_id: RequestId,
-        target_id: ChannelId,
-        request: ModeRequest,
-    ) -> Result<(), GenericTargetedMessagingError> {
-        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<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
-        self.try_recv_message()
-    }
-}
-
-impl<R: MessageReceiver<ModeRequest>> ModeRequestReceiver
-    for MessageReceiverWithId<ModeRequest, R>
-{
-    fn try_recv_mode_request(
-        &self,
-    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
-        self.try_recv_message()
-    }
-}
-
-impl<FROM, S: MessageSender<ModeRequest>, R: MessageReceiver<FROM>> ModeRequestSender
-    for MessageSenderAndReceiver<ModeRequest, FROM, S, R>
-{
-    fn local_channel_id(&self) -> ChannelId {
-        self.local_channel_id_generic()
-    }
-
-    fn send_mode_request(
-        &self,
-        request_id: RequestId,
-        target_id: ChannelId,
-        request: ModeRequest,
-    ) -> Result<(), GenericTargetedMessagingError> {
-        self.message_sender_map.send_mode_request(
-            request_id,
-            self.local_channel_id(),
-            target_id,
-            request,
-        )
-    }
-}
-
-impl<FROM, S: MessageSender<ModeReply>, R: MessageReceiver<FROM>> ModeReplySender
-    for MessageSenderAndReceiver<ModeReply, FROM, S, R>
-{
-    fn local_channel_id(&self) -> ChannelId {
-        self.local_channel_id_generic()
-    }
-
-    fn send_mode_reply(
-        &self,
-        request_id: RequestId,
-        target_id: ChannelId,
-        request: ModeReply,
-    ) -> Result<(), GenericTargetedMessagingError> {
-        self.message_sender_map.send_mode_reply(
-            request_id,
-            self.local_channel_id(),
-            target_id,
-            request,
-        )
-    }
-}
-
-impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeReply>> ModeReplyReceiver
-    for MessageSenderAndReceiver<TO, ModeReply, S, R>
-{
-    fn try_recv_mode_reply(
-        &self,
-    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
-        self.message_receiver
-            .try_recv_message(self.local_channel_id_generic())
-    }
-}
-impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeRequest>> ModeRequestReceiver
-    for MessageSenderAndReceiver<TO, ModeRequest, S, R>
-{
-    fn try_recv_mode_request(
-        &self,
-    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
-        self.message_receiver
-            .try_recv_message(self.local_channel_id_generic())
-    }
-}
-
-pub type ModeRequestHandlerConnector<S, R> = MessageSenderAndReceiver<ModeReply, ModeRequest, S, R>;
-pub type MpscModeRequestHandlerConnector = ModeRequestHandlerConnector<
-    mpsc::Sender<GenericMessage<ModeReply>>,
-    mpsc::Receiver<GenericMessage<ModeRequest>>,
->;
-pub type MpscBoundedModeRequestHandlerConnector = ModeRequestHandlerConnector<
-    mpsc::SyncSender<GenericMessage<ModeReply>>,
-    mpsc::Receiver<GenericMessage<ModeRequest>>,
->;
-
-pub type ModeRequestorConnector<S, R> = MessageSenderAndReceiver<ModeRequest, ModeReply, S, R>;
-pub type MpscModeRequestorConnector = ModeRequestorConnector<
-    mpsc::Sender<GenericMessage<ModeRequest>>,
-    mpsc::Receiver<GenericMessage<ModeReply>>,
->;
-pub type MpscBoundedModeRequestorConnector = ModeRequestorConnector<
-    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<GenericMessage<ModeRequest>>,
-    mpsc::Receiver<GenericMessage<ModeReply>>,
-    mpsc::Sender<GenericMessage<ModeReply>>,
-    mpsc::Receiver<GenericMessage<ModeRequest>>,
->;
-pub type MpscBoundedModeConnector = ModeConnector<
-    mpsc::SyncSender<GenericMessage<ModeRequest>>,
-    mpsc::Receiver<GenericMessage<ModeReply>>,
-    mpsc::SyncSender<GenericMessage<ModeReply>>,
-    mpsc::Receiver<GenericMessage<ModeRequest>>,
->;
-
-impl<
-        REPLY,
-        S0: MessageSender<ModeRequest>,
-        R0: MessageReceiver<REPLY>,
-        S1: MessageSender<REPLY>,
-        R1: MessageReceiver<ModeRequest>,
-    > RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
-{
-    pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S0) {
-        self.request_sender_map
-            .add_message_target(target_id, request_sender)
-    }
-}
-
-impl<
-        REQUEST,
-        S0: MessageSender<REQUEST>,
-        R0: MessageReceiver<ModeReply>,
-        S1: MessageSender<ModeReply>,
-        R1: MessageReceiver<REQUEST>,
-    > RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
-{
-    pub fn add_reply_target(&mut self, target_id: ChannelId, reply_sender: S1) {
-        self.reply_sender_map
-            .add_message_target(target_id, reply_sender)
-    }
-}
-
-impl<
-        REPLY,
-        S0: MessageSender<ModeRequest>,
-        R0: MessageReceiver<REPLY>,
-        S1: MessageSender<REPLY>,
-        R1: MessageReceiver<ModeRequest>,
-    > ModeRequestSender for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
-{
-    fn local_channel_id(&self) -> ChannelId {
-        self.local_channel_id_generic()
-    }
-
-    fn send_mode_request(
-        &self,
-        request_id: RequestId,
-        target_id: ChannelId,
-        request: ModeRequest,
-    ) -> Result<(), GenericTargetedMessagingError> {
-        self.request_sender_map.send_mode_request(
-            request_id,
-            self.local_channel_id(),
-            target_id,
-            request,
-        )
-    }
-}
-
-impl<
-        REQUEST,
-        S0: MessageSender<REQUEST>,
-        R0: MessageReceiver<ModeReply>,
-        S1: MessageSender<ModeReply>,
-        R1: MessageReceiver<REQUEST>,
-    > ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
-{
-    fn local_channel_id(&self) -> ChannelId {
-        self.local_channel_id_generic()
-    }
-
-    fn send_mode_reply(
-        &self,
-        request_id: RequestId,
-        target_id: ChannelId,
-        request: ModeReply,
-    ) -> Result<(), GenericTargetedMessagingError> {
-        self.reply_sender_map.send_mode_reply(
-            request_id,
-            self.local_channel_id(),
-            target_id,
-            request,
-        )
-    }
-}
-
-impl<
-        REQUEST,
-        S0: MessageSender<REQUEST>,
-        R0: MessageReceiver<ModeReply>,
-        S1: MessageSender<ModeReply>,
-        R1: MessageReceiver<REQUEST>,
-    > ModeReplyReceiver for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
-{
-    fn try_recv_mode_reply(
-        &self,
-    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
-        self.reply_receiver
-            .try_recv_message(self.local_channel_id_generic())
-    }
-}
-
-impl<
-        REPLY,
-        S0: MessageSender<ModeRequest>,
-        R0: MessageReceiver<REPLY>,
-        S1: MessageSender<REPLY>,
-        R1: MessageReceiver<ModeRequest>,
-    > ModeRequestReceiver for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
-{
-    fn try_recv_mode_request(
-        &self,
-    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
-        self.request_receiver
-            .try_recv_message(self.local_channel_id_generic())
-    }
-}
-
-pub trait ModeProvider {
-    fn mode_and_submode(&self) -> ModeAndSubmode;
-}
-
-#[derive(Debug, Clone)]
-pub enum ModeError {
-    Messaging(GenericTargetedMessagingError),
-}
-
-impl From<GenericTargetedMessagingError> for ModeError {
-    fn from(value: GenericTargetedMessagingError) -> Self {
-        Self::Messaging(value)
-    }
-}
-
-pub trait ModeRequestHandler: ModeProvider {
-    fn start_transition(
-        &mut self,
-        request_id: RequestId,
-        sender_id: ChannelId,
-        mode_and_submode: ModeAndSubmode,
-    ) -> Result<(), ModeError>;
-
-    fn announce_mode(&self, request_id: RequestId, sender_id: ChannelId, recursive: bool);
-    fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError>;
-}
-
 #[cfg(test)]
 mod tests {}

satrs/src/params.rs

@@ -559,7 +559,7 @@ from_conversions_for_raw!(
 
 /// Generic enumeration for additional parameters, including parameters which rely on heap
 /// allocations.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 #[non_exhaustive]
 pub enum Params {
     Heapless(ParamsHeapless),

satrs/src/pus/action.rs

@@ -365,16 +365,20 @@ mod tests {
         CcsdsPacket, SequenceFlags, SpHeader,
     };
 
-    use crate::pus::{
+    use crate::{
-        tests::{
+        action::ActionRequestVariant,
-            PusServiceHandlerWithVecCommon, PusTestHarness, SimplePusPacketHandler, TestConverter,
+        pus::{
-            TestRouter, TestRoutingErrorHandler, APP_DATA_TOO_SHORT, TEST_APID,
+            tests::{
+                PusServiceHandlerWithVecCommon, PusTestHarness, SimplePusPacketHandler,
+                TestConverter, TestRouter, TestRoutingErrorHandler, APP_DATA_TOO_SHORT, TEST_APID,
+            },
+            verification::{
+                tests::TestVerificationReporter, FailParams, RequestId,
+                VerificationReportingProvider,
+            },
+            EcssTcInVecConverter, GenericRoutingError, MpscTcReceiver, PusPacketHandlerResult,
+            PusPacketHandlingError, TmAsVecSenderWithMpsc,
         },
-        verification::{
-            tests::TestVerificationReporter, FailParams, RequestId, VerificationReportingProvider,
-        },
-        EcssTcInVecConverter, GenericRoutingError, MpscTcReceiver, PusPacketHandlerResult,
-        PusPacketHandlingError, TmAsVecSenderWithMpsc,
     };
 
     use super::*;
@@ -385,12 +389,12 @@ mod tests {
         fn route(
             &self,
             target_id: TargetId,
-            hk_request: ActionRequest,
+            action_request: ActionRequest,
             _token: VerificationToken<TcStateAccepted>,
         ) -> Result<(), Self::Error> {
             self.routing_requests
                 .borrow_mut()
-                .push_back((target_id, hk_request));
+                .push_back((target_id, action_request));
             self.check_for_injected_error()
         }
     }
@@ -429,9 +433,9 @@ mod tests {
                     .expect("start success failure");
                 return Ok((
                     target_id.into(),
-                    ActionRequest::UnsignedIdAndVecData {
+                    ActionRequest {
                         action_id: u32::from_be_bytes(tc.user_data()[0..4].try_into().unwrap()),
-                        data: tc.user_data()[4..].to_vec(),
+                        variant: ActionRequestVariant::VecData(tc.user_data()[4..].to_vec()),
                     },
                 ));
             }
@@ -522,8 +526,8 @@ mod tests {
         action_handler.check_next_conversion(&tc);
         let (target_id, action_req) = action_handler.retrieve_next_request();
         assert_eq!(target_id, TEST_APID.into());
-        if let ActionRequest::UnsignedIdAndVecData { action_id, data } = action_req {
+        assert_eq!(action_req.action_id, 1);
-            assert_eq!(action_id, 1);
+        if let ActionRequestVariant::VecData(data) = action_req.variant {
             assert_eq!(data, &[]);
         }
     }
@@ -560,8 +564,8 @@ mod tests {
         action_handler.check_next_conversion(&tc);
         let (target_id, action_req) = action_handler.retrieve_next_request();
         assert_eq!(target_id, TEST_APID.into());
-        if let ActionRequest::UnsignedIdAndVecData { action_id, data } = action_req {
+        assert_eq!(action_req.action_id, 1);
-            assert_eq!(action_id, 1);
+        if let ActionRequestVariant::VecData(data) = action_req.variant {
             assert_eq!(data, &[]);
         }
 

satrs/src/request.rs

@@ -1,7 +1,13 @@
-use core::fmt;
+use core::{fmt, marker::PhantomData};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 #[cfg(feature = "std")]
 use std::error::Error;
 
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub use alloc_mod::*;
+
 #[cfg(feature = "std")]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub use std_mod::*;
@@ -120,6 +126,8 @@ impl fmt::Display for TargetAndApidId {
 
 /// Generic message type which is associated with a sender using a [ChannelId] and associated
 /// with a request using a [RequestId].
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct GenericMessage<MSG> {
     pub sender_id: ChannelId,
     pub request_id: RequestId,
@@ -146,50 +154,67 @@ pub trait MessageReceiver<MSG> {
     fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError>;
 }
 
-#[cfg(feature = "std")]
+pub struct MessageWithSenderIdReceiver<MSG, R: MessageReceiver<MSG>>(pub R, PhantomData<MSG>);
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+
-mod std_mod {
+impl<MSG, R: MessageReceiver<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> {
+    fn from(receiver: R) -> Self {
+        MessageWithSenderIdReceiver(receiver, PhantomData)
+    }
+}
+
+impl<MSG, R: MessageReceiver<MSG>> MessageWithSenderIdReceiver<MSG, R> {
+    pub fn try_recv_message(
+        &self,
+        _local_id: ChannelId,
+    ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
+        self.0.try_recv()
+    }
+}
+
+impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
+    pub fn new(
+        local_channel_id: ChannelId,
+        reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
+    ) -> Self {
+        Self {
+            local_channel_id,
+            reply_receiver,
+        }
+    }
+
+    pub fn local_channel_id(&self) -> ChannelId {
+        self.local_channel_id
+    }
+}
+
+impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
+    pub fn try_recv_message(
+        &self,
+    ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
+        self.reply_receiver.0.try_recv()
+    }
+}
+
+pub struct MessageReceiverWithId<MSG, R: MessageReceiver<MSG>> {
+    local_channel_id: ChannelId,
+    reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub mod alloc_mod {
     use core::marker::PhantomData;
-    use std::sync::mpsc;
 
+    use crate::queue::GenericSendError;
+
+    use super::*;
     use hashbrown::HashMap;
 
-    use crate::{
-        queue::{GenericReceiveError, GenericSendError, GenericTargetedMessagingError},
-        ChannelId,
-    };
-
-    use super::{GenericMessage, MessageReceiver, MessageSender, RequestId};
-
-    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<GenericMessage<MSG>> {
-        fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError> {
-            if let Err(e) = self.try_send(message) {
-                match e {
-                    mpsc::TrySendError::Full(_) => {
-                        return Err(GenericSendError::QueueFull(None).into());
-                    }
-                    mpsc::TrySendError::Disconnected(_) => todo!(),
-                }
-            }
-            Ok(())
-        }
-    }
-
     pub struct MessageSenderMap<MSG, S: MessageSender<MSG>>(
         pub HashMap<ChannelId, S>,
-        PhantomData<MSG>,
+        pub(crate) PhantomData<MSG>,
     );
 
-    pub type MpscSenderMap<MSG> = MessageReceiverWithId<MSG, mpsc::Sender<MSG>>;
-    pub type MpscBoundedSenderMap<MSG> = MessageReceiverWithId<MSG, mpsc::SyncSender<MSG>>;
-
     impl<MSG, S: MessageSender<MSG>> Default for MessageSenderMap<MSG, S> {
         fn default() -> Self {
             Self(Default::default(), PhantomData)
@@ -253,68 +278,6 @@ mod std_mod {
         }
     }
 
-    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 {
-                    mpsc::TryRecvError::Empty => Ok(None),
-                    mpsc::TryRecvError::Disconnected => {
-                        Err(GenericReceiveError::TxDisconnected(None).into())
-                    }
-                },
-            }
-        }
-    }
-
-    pub struct MessageWithSenderIdReceiver<MSG, R: MessageReceiver<MSG>>(pub R, PhantomData<MSG>);
-
-    impl<MSG, R: MessageReceiver<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> {
-        fn from(receiver: R) -> Self {
-            MessageWithSenderIdReceiver(receiver, PhantomData)
-        }
-    }
-
-    impl<MSG, R: MessageReceiver<MSG>> MessageWithSenderIdReceiver<MSG, R> {
-        pub fn try_recv_message(
-            &self,
-            _local_id: ChannelId,
-        ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
-            self.0.try_recv()
-        }
-    }
-
-    pub struct MessageReceiverWithId<MSG, R: MessageReceiver<MSG>> {
-        local_channel_id: ChannelId,
-        reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
-    }
-
-    pub type MpscMessageReceiverWithId<MSG> = MessageReceiverWithId<MSG, mpsc::Receiver<MSG>>;
-
-    impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
-        pub fn new(
-            local_channel_id: ChannelId,
-            reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
-        ) -> Self {
-            Self {
-                local_channel_id,
-                reply_receiver,
-            }
-        }
-
-        pub fn local_channel_id(&self) -> ChannelId {
-            self.local_channel_id
-        }
-    }
-
-    impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
-        pub fn try_recv_message(
-            &self,
-        ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
-            self.reply_receiver.0.try_recv()
-        }
-    }
-
     pub struct MessageSenderAndReceiver<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>> {
         pub local_channel_id: ChannelId,
         pub message_sender_map: MessageSenderMap<TO, S>,
@@ -383,3 +346,53 @@ mod std_mod {
         }
     }
 }
+
+#[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+pub mod std_mod {
+
+    use super::*;
+    use std::sync::mpsc;
+
+    use crate::queue::{GenericReceiveError, GenericSendError, 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<GenericMessage<MSG>> {
+        fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError> {
+            if let Err(e) = self.try_send(message) {
+                match e {
+                    mpsc::TrySendError::Full(_) => {
+                        return Err(GenericSendError::QueueFull(None).into());
+                    }
+                    mpsc::TrySendError::Disconnected(_) => todo!(),
+                }
+            }
+            Ok(())
+        }
+    }
+
+    pub type MpscSenderMap<MSG> = MessageReceiverWithId<MSG, mpsc::Sender<MSG>>;
+    pub type MpscBoundedSenderMap<MSG> = MessageReceiverWithId<MSG, mpsc::SyncSender<MSG>>;
+
+    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 {
+                    mpsc::TryRecvError::Empty => Ok(None),
+                    mpsc::TryRecvError::Disconnected => {
+                        Err(GenericReceiveError::TxDisconnected(None).into())
+                    }
+                },
+            }
+        }
+    }
+
+    pub type MpscMessageReceiverWithId<MSG> = MessageReceiverWithId<MSG, mpsc::Receiver<MSG>>;
+}