764 lines
24 KiB
Rust
764 lines
24 KiB
Rust
use core::mem::size_of;
|
|
use satrs_shared::res_code::ResultU16;
|
|
#[cfg(feature = "serde")]
|
|
use serde::{Deserialize, Serialize};
|
|
use spacepackets::ByteConversionError;
|
|
|
|
#[cfg(feature = "alloc")]
|
|
pub use alloc_mod::*;
|
|
|
|
#[cfg(feature = "std")]
|
|
pub use std_mod::*;
|
|
|
|
use crate::{
|
|
queue::{GenericReceiveError, GenericSendError},
|
|
request::{
|
|
GenericMessage, MessageMetadata, MessageReceiverProvider, MessageReceiverWithId, RequestId,
|
|
},
|
|
ComponentId,
|
|
};
|
|
|
|
pub type Mode = u32;
|
|
pub type Submode = u16;
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub struct ModeAndSubmode {
|
|
mode: Mode,
|
|
submode: Submode,
|
|
}
|
|
|
|
pub const INVALID_MODE_VAL: Mode = Mode::MAX;
|
|
pub const UNKNOWN_MODE_VAL: Mode = Mode::MAX - 1;
|
|
pub const INVALID_MODE: ModeAndSubmode = ModeAndSubmode::new(INVALID_MODE_VAL, 0);
|
|
pub const UNKNOWN_MODE: ModeAndSubmode = ModeAndSubmode::new(UNKNOWN_MODE_VAL, 0);
|
|
|
|
impl ModeAndSubmode {
|
|
pub const RAW_LEN: usize = size_of::<Mode>() + size_of::<Submode>();
|
|
|
|
pub const fn new_mode_only(mode: Mode) -> Self {
|
|
Self { mode, submode: 0 }
|
|
}
|
|
|
|
pub const fn new(mode: Mode, submode: Submode) -> Self {
|
|
Self { mode, submode }
|
|
}
|
|
|
|
pub fn from_be_bytes(buf: &[u8]) -> Result<Self, ByteConversionError> {
|
|
if buf.len() < 6 {
|
|
return Err(ByteConversionError::FromSliceTooSmall {
|
|
expected: Self::RAW_LEN,
|
|
found: buf.len(),
|
|
});
|
|
}
|
|
Ok(Self {
|
|
mode: Mode::from_be_bytes(buf[0..size_of::<Mode>()].try_into().unwrap()),
|
|
submode: Submode::from_be_bytes(
|
|
buf[size_of::<Mode>()..size_of::<Mode>() + size_of::<Submode>()]
|
|
.try_into()
|
|
.unwrap(),
|
|
),
|
|
})
|
|
}
|
|
|
|
pub fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
|
|
if buf.len() < Self::RAW_LEN {
|
|
return Err(ByteConversionError::ToSliceTooSmall {
|
|
expected: Self::RAW_LEN,
|
|
found: buf.len(),
|
|
});
|
|
}
|
|
buf[0..size_of::<Mode>()].copy_from_slice(&self.mode.to_be_bytes());
|
|
buf[size_of::<Mode>()..Self::RAW_LEN].copy_from_slice(&self.submode.to_be_bytes());
|
|
Ok(Self::RAW_LEN)
|
|
}
|
|
|
|
pub fn mode(&self) -> Mode {
|
|
self.mode
|
|
}
|
|
|
|
pub fn submode(&self) -> Submode {
|
|
self.submode
|
|
}
|
|
}
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub struct TargetedModeCommand {
|
|
pub address: ComponentId,
|
|
pub mode_submode: ModeAndSubmode,
|
|
}
|
|
|
|
impl TargetedModeCommand {
|
|
pub const fn new(address: ComponentId, mode_submode: ModeAndSubmode) -> Self {
|
|
Self {
|
|
address,
|
|
mode_submode,
|
|
}
|
|
}
|
|
|
|
pub fn address(&self) -> ComponentId {
|
|
self.address
|
|
}
|
|
|
|
pub fn mode_submode(&self) -> ModeAndSubmode {
|
|
self.mode_submode
|
|
}
|
|
|
|
pub fn mode(&self) -> u32 {
|
|
self.mode_submode.mode
|
|
}
|
|
|
|
pub fn submode(&self) -> u16 {
|
|
self.mode_submode.submode
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub enum ModeRequest {
|
|
/// Mode information. Can be used to notify other components of changed modes.
|
|
ModeInfo(ModeAndSubmode),
|
|
SetMode {
|
|
mode_and_submode: ModeAndSubmode,
|
|
forced: bool,
|
|
},
|
|
ReadMode,
|
|
AnnounceMode,
|
|
AnnounceModeRecursive,
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub struct TargetedModeRequest {
|
|
target_id: ComponentId,
|
|
mode_request: ModeRequest,
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub enum ModeReply {
|
|
/// Mode information. Can be used to notify other components of changed modes.
|
|
ModeInfo(ModeAndSubmode),
|
|
/// Reply to a mode request to confirm the commanded mode was reached.
|
|
ModeReply(ModeAndSubmode),
|
|
// Can not reach the commanded mode. Contains a reason as a [ResultU16].
|
|
CantReachMode(ResultU16),
|
|
/// We are in the wrong mode for unknown reasons. Contains the expected and reached mode.
|
|
WrongMode {
|
|
expected: ModeAndSubmode,
|
|
reached: ModeAndSubmode,
|
|
},
|
|
}
|
|
|
|
pub type GenericModeReply = GenericMessage<ModeReply>;
|
|
|
|
pub trait ModeRequestSender {
|
|
fn local_channel_id(&self) -> ComponentId;
|
|
fn send_mode_request(
|
|
&self,
|
|
request_id: RequestId,
|
|
target_id: ComponentId,
|
|
request: ModeRequest,
|
|
) -> Result<(), GenericSendError>;
|
|
}
|
|
|
|
pub trait ModeRequestReceiver {
|
|
fn try_recv_mode_request(
|
|
&self,
|
|
) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError>;
|
|
}
|
|
|
|
impl<R: MessageReceiverProvider<ModeRequest>> ModeRequestReceiver
|
|
for MessageReceiverWithId<ModeRequest, R>
|
|
{
|
|
fn try_recv_mode_request(
|
|
&self,
|
|
) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError> {
|
|
self.try_recv_message()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, thiserror::Error)]
|
|
pub enum ModeError {
|
|
#[error("Messaging send error: {0}")]
|
|
Send(#[from] GenericSendError),
|
|
#[error("Messaging receive error: {0}")]
|
|
Receive(#[from] GenericReceiveError),
|
|
#[error("busy with other mode request")]
|
|
Busy,
|
|
}
|
|
|
|
pub trait ModeProvider {
|
|
fn mode_and_submode(&self) -> ModeAndSubmode;
|
|
|
|
fn mode(&self) -> Mode {
|
|
self.mode_and_submode().mode()
|
|
}
|
|
|
|
fn submode(&self) -> Submode {
|
|
self.mode_and_submode().submode()
|
|
}
|
|
}
|
|
|
|
pub trait ModeRequestHandler: ModeProvider {
|
|
type Error;
|
|
|
|
fn start_transition(
|
|
&mut self,
|
|
requestor: MessageMetadata,
|
|
mode_and_submode: ModeAndSubmode,
|
|
forced: bool,
|
|
) -> Result<(), Self::Error>;
|
|
|
|
fn announce_mode(&self, requestor_info: Option<MessageMetadata>, recursive: bool);
|
|
|
|
fn handle_mode_reached(
|
|
&mut self,
|
|
requestor_info: Option<MessageMetadata>,
|
|
) -> Result<(), Self::Error>;
|
|
|
|
fn handle_mode_info(
|
|
&mut self,
|
|
requestor_info: MessageMetadata,
|
|
info: ModeAndSubmode,
|
|
) -> Result<(), Self::Error>;
|
|
|
|
fn send_mode_reply(
|
|
&self,
|
|
requestor_info: MessageMetadata,
|
|
reply: ModeReply,
|
|
) -> Result<(), Self::Error>;
|
|
|
|
fn handle_mode_request(
|
|
&mut self,
|
|
request: GenericMessage<ModeRequest>,
|
|
) -> Result<(), Self::Error> {
|
|
match request.message {
|
|
ModeRequest::SetMode {
|
|
mode_and_submode,
|
|
forced,
|
|
} => self.start_transition(request.requestor_info, mode_and_submode, forced),
|
|
ModeRequest::ReadMode => self.send_mode_reply(
|
|
request.requestor_info,
|
|
ModeReply::ModeReply(self.mode_and_submode()),
|
|
),
|
|
ModeRequest::AnnounceMode => {
|
|
self.announce_mode(Some(request.requestor_info), false);
|
|
Ok(())
|
|
}
|
|
ModeRequest::AnnounceModeRecursive => {
|
|
self.announce_mode(Some(request.requestor_info), true);
|
|
Ok(())
|
|
}
|
|
ModeRequest::ModeInfo(info) => self.handle_mode_info(request.requestor_info, info),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait ModeReplyReceiver {
|
|
fn try_recv_mode_reply(&self)
|
|
-> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError>;
|
|
}
|
|
|
|
impl<R: MessageReceiverProvider<ModeReply>> ModeReplyReceiver
|
|
for MessageReceiverWithId<ModeReply, R>
|
|
{
|
|
fn try_recv_mode_reply(
|
|
&self,
|
|
) -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError> {
|
|
self.try_recv_message()
|
|
}
|
|
}
|
|
|
|
pub trait ModeReplySender {
|
|
fn local_channel_id(&self) -> ComponentId;
|
|
|
|
/// The requestor is assumed to be the target of the reply.
|
|
fn send_mode_reply(
|
|
&self,
|
|
requestor_info: MessageMetadata,
|
|
reply: ModeReply,
|
|
) -> Result<(), GenericSendError>;
|
|
}
|
|
|
|
#[cfg(feature = "alloc")]
|
|
pub mod alloc_mod {
|
|
use crate::{
|
|
queue::{GenericReceiveError, GenericSendError},
|
|
request::{
|
|
MessageSenderAndReceiver, MessageSenderMap, MessageSenderProvider,
|
|
MessageSenderStoreProvider, RequestAndReplySenderAndReceiver,
|
|
},
|
|
};
|
|
|
|
use super::*;
|
|
|
|
impl<S: MessageSenderProvider<ModeReply>> MessageSenderMap<ModeReply, S> {
|
|
pub fn send_mode_reply(
|
|
&self,
|
|
requestor_info: MessageMetadata,
|
|
target_id: ComponentId,
|
|
request: ModeReply,
|
|
) -> Result<(), GenericSendError> {
|
|
self.send_message(requestor_info, target_id, request)
|
|
}
|
|
|
|
pub fn add_reply_target(&mut self, target_id: ComponentId, request_sender: S) {
|
|
self.add_message_target(target_id, request_sender)
|
|
}
|
|
}
|
|
|
|
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()
|
|
}
|
|
|
|
fn send_mode_reply(
|
|
&self,
|
|
requestor_info: MessageMetadata,
|
|
request: ModeReply,
|
|
) -> Result<(), GenericSendError> {
|
|
self.message_sender_store.send_message(
|
|
MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()),
|
|
requestor_info.sender_id(),
|
|
request,
|
|
)
|
|
}
|
|
}
|
|
|
|
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,
|
|
) -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError> {
|
|
self.message_receiver.try_recv_message()
|
|
}
|
|
}
|
|
|
|
impl<
|
|
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: ReplySender) {
|
|
self.reply_sender_store
|
|
.add_message_target(target_id, reply_sender)
|
|
}
|
|
}
|
|
|
|
impl<
|
|
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()
|
|
}
|
|
|
|
fn send_mode_reply(
|
|
&self,
|
|
requestor_info: MessageMetadata,
|
|
reply: ModeReply,
|
|
) -> Result<(), GenericSendError> {
|
|
self.reply_sender_store.send_message(
|
|
MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()),
|
|
requestor_info.sender_id(),
|
|
reply,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl<
|
|
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,
|
|
ReqSender,
|
|
ReqReceiver,
|
|
ReqSenderStore,
|
|
ModeReply,
|
|
ReplySender,
|
|
ReplyReceiver,
|
|
ReplySenderStore,
|
|
>
|
|
{
|
|
fn try_recv_mode_reply(
|
|
&self,
|
|
) -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError> {
|
|
self.reply_receiver.try_recv_message()
|
|
}
|
|
}
|
|
|
|
/// Helper type definition for a mode handler which can handle mode requests.
|
|
pub type ModeRequestHandlerInterface<Sender, Receiver, ReplySenderStore> =
|
|
MessageSenderAndReceiver<ModeReply, ModeRequest, Sender, Receiver, ReplySenderStore>;
|
|
|
|
impl<
|
|
Sender: MessageSenderProvider<ModeReply>,
|
|
Receiver: MessageReceiverProvider<ModeRequest>,
|
|
ReplySenderStore: MessageSenderStoreProvider<ModeReply, Sender>,
|
|
> ModeRequestHandlerInterface<Sender, Receiver, ReplySenderStore>
|
|
{
|
|
pub fn try_recv_mode_request(
|
|
&self,
|
|
) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError> {
|
|
self.try_recv_message()
|
|
}
|
|
|
|
pub fn send_mode_reply(
|
|
&self,
|
|
requestor_info: MessageMetadata,
|
|
reply: ModeReply,
|
|
) -> Result<(), GenericSendError> {
|
|
self.send_message(
|
|
requestor_info.request_id(),
|
|
requestor_info.sender_id(),
|
|
reply,
|
|
)
|
|
}
|
|
}
|
|
|
|
/// Helper type defintion for a mode handler object which can send mode requests and receive
|
|
/// mode replies.
|
|
pub type ModeRequestorInterface<Sender, Receiver, RequestSenderStore> =
|
|
MessageSenderAndReceiver<ModeRequest, ModeReply, Sender, Receiver, RequestSenderStore>;
|
|
|
|
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>>, GenericReceiveError> {
|
|
self.try_recv_message()
|
|
}
|
|
|
|
pub fn send_mode_request(
|
|
&self,
|
|
request_id: RequestId,
|
|
target_id: ComponentId,
|
|
reply: ModeRequest,
|
|
) -> Result<(), GenericSendError> {
|
|
self.send_message(request_id, target_id, reply)
|
|
}
|
|
}
|
|
|
|
/// Helper type defintion for a mode handler object which can both send mode requests and
|
|
/// process mode requests.
|
|
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(
|
|
&self,
|
|
requestor_info: MessageMetadata,
|
|
target_id: ComponentId,
|
|
request: ModeRequest,
|
|
) -> Result<(), GenericSendError> {
|
|
self.send_message(requestor_info, target_id, request)
|
|
}
|
|
|
|
pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S) {
|
|
self.add_message_target(target_id, request_sender)
|
|
}
|
|
}
|
|
|
|
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,
|
|
) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError> {
|
|
self.message_receiver.try_recv_message()
|
|
}
|
|
}
|
|
|
|
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()
|
|
}
|
|
|
|
fn send_mode_request(
|
|
&self,
|
|
request_id: RequestId,
|
|
target_id: ComponentId,
|
|
request: ModeRequest,
|
|
) -> Result<(), GenericSendError> {
|
|
self.message_sender_store.send_message(
|
|
MessageMetadata::new(request_id, self.local_channel_id()),
|
|
target_id,
|
|
request,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl<
|
|
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: ReqSender) {
|
|
self.request_sender_store
|
|
.add_message_target(target_id, request_sender)
|
|
}
|
|
}
|
|
|
|
impl<
|
|
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,
|
|
ReqSender,
|
|
ReqReceiver,
|
|
ReqSenderStore,
|
|
Reply,
|
|
ReplySender,
|
|
ReplyReceiver,
|
|
ReplySenderStore,
|
|
>
|
|
{
|
|
fn local_channel_id(&self) -> ComponentId {
|
|
self.local_channel_id_generic()
|
|
}
|
|
|
|
fn send_mode_request(
|
|
&self,
|
|
request_id: RequestId,
|
|
target_id: ComponentId,
|
|
request: ModeRequest,
|
|
) -> Result<(), GenericSendError> {
|
|
self.request_sender_store.send_message(
|
|
MessageMetadata::new(request_id, self.local_channel_id()),
|
|
target_id,
|
|
request,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl<
|
|
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,
|
|
ReqSender,
|
|
ReqReceiver,
|
|
ReqSenderStore,
|
|
Reply,
|
|
ReplySender,
|
|
ReplyReceiver,
|
|
ReplySenderStore,
|
|
>
|
|
{
|
|
fn try_recv_mode_request(
|
|
&self,
|
|
) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError> {
|
|
self.request_receiver.try_recv_message()
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "std")]
|
|
pub mod std_mod {
|
|
use std::sync::mpsc;
|
|
|
|
use crate::request::{MessageSenderList, OneMessageSender};
|
|
|
|
use super::*;
|
|
|
|
pub type ModeRequestHandlerMpsc = ModeRequestHandlerInterface<
|
|
mpsc::Sender<GenericMessage<ModeReply>>,
|
|
mpsc::Receiver<GenericMessage<ModeRequest>>,
|
|
MessageSenderList<ModeReply, mpsc::Sender<GenericMessage<ModeReply>>>,
|
|
>;
|
|
pub type ModeRequestHandlerMpscBounded = ModeRequestHandlerInterface<
|
|
mpsc::SyncSender<GenericMessage<ModeReply>>,
|
|
mpsc::Receiver<GenericMessage<ModeRequest>>,
|
|
MessageSenderList<ModeReply, mpsc::SyncSender<GenericMessage<ModeReply>>>,
|
|
>;
|
|
|
|
pub type ModeRequestorOneChildMpsc = ModeRequestorInterface<
|
|
mpsc::Sender<GenericMessage<ModeRequest>>,
|
|
mpsc::Receiver<GenericMessage<ModeReply>>,
|
|
OneMessageSender<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
|
|
>;
|
|
pub type ModeRequestorOneChildBoundedMpsc = ModeRequestorInterface<
|
|
mpsc::SyncSender<GenericMessage<ModeRequest>>,
|
|
mpsc::Receiver<GenericMessage<ModeReply>>,
|
|
OneMessageSender<ModeRequest, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
|
|
>;
|
|
pub type ModeRequestorChildListMpsc = ModeRequestorInterface<
|
|
mpsc::Sender<GenericMessage<ModeRequest>>,
|
|
mpsc::Receiver<GenericMessage<ModeReply>>,
|
|
MessageSenderList<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
|
|
>;
|
|
pub type ModeRequestorChildListBoundedMpsc = ModeRequestorInterface<
|
|
mpsc::SyncSender<GenericMessage<ModeRequest>>,
|
|
mpsc::Receiver<GenericMessage<ModeReply>>,
|
|
MessageSenderList<ModeRequest, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
|
|
>;
|
|
|
|
pub type ModeRequestorAndHandlerMpsc = ModeInterface<
|
|
mpsc::Sender<GenericMessage<ModeRequest>>,
|
|
mpsc::Receiver<GenericMessage<ModeRequest>>,
|
|
MessageSenderList<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
|
|
mpsc::Sender<GenericMessage<ModeReply>>,
|
|
mpsc::Receiver<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>>>,
|
|
>;
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) mod tests {
|
|
use core::cell::RefCell;
|
|
use std::collections::VecDeque;
|
|
|
|
use crate::{request::RequestId, ComponentId};
|
|
|
|
use super::*;
|
|
|
|
pub struct ModeReqWrapper {
|
|
pub request_id: RequestId,
|
|
pub target_id: ComponentId,
|
|
pub request: ModeRequest,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct ModeReqSenderMock {
|
|
pub requests: RefCell<VecDeque<ModeReqWrapper>>,
|
|
}
|
|
|
|
impl ModeRequestSender for ModeReqSenderMock {
|
|
fn local_channel_id(&self) -> crate::ComponentId {
|
|
0
|
|
}
|
|
|
|
fn send_mode_request(
|
|
&self,
|
|
request_id: RequestId,
|
|
target_id: ComponentId,
|
|
request: ModeRequest,
|
|
) -> Result<(), GenericSendError> {
|
|
self.requests.borrow_mut().push_back(ModeReqWrapper {
|
|
request_id,
|
|
target_id,
|
|
request,
|
|
});
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|