rust/sat-rs
rust/sat-rs
5
1
Fork 0
Code Issues 9 Pull Requests Projects Releases 22 Wiki Activity

that was hard

Browse Source
This commit is contained in:
Robin Müller 2024-02-22 17:19:32 +01:00
parent 7967b95553
commit e7c0d33ccb
Signed by: muellerr
GPG Key ID: A649FB78196E3849
2 changed files with 227 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
satrs/src/mode_tree.rs
View File

@ -7,8 +7,9 @@ use crate::{
mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, Submode},
queue::GenericTargetedMessagingError,
request::{
MessageWithSenderId, MpscMessageReceiverWithIds, MpscMessageSenderAndReceiver,
MpscMessageSenderMap, MpscMessageSenderWithId, MpscRequestAndReplySenderAndReceiver,
MessageReceiver, MessageReceiverWithId, MessageSender, MessageSenderAndReceiver,
MessageSenderMap, MessageSenderMapWithId, MessageWithSenderId,
RequestAndReplySenderAndReceiver,
},
ChannelId,
};
@ -71,7 +72,7 @@ pub trait ModeReplyReceiver {
) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError>;
}
impl MpscMessageSenderMap<ModeRequest> {
impl<S: MessageSender<ModeRequest>> MessageSenderMap<ModeRequest, S> {
pub fn send_mode_request(
&self,
local_id: ChannelId,
@ -81,16 +82,12 @@ impl MpscMessageSenderMap<ModeRequest> {
self.send_message(local_id, target_id, request)
}
pub fn add_request_target(
&mut self,
target_id: ChannelId,
request_sender: mpsc::Sender<MessageWithSenderId<ModeRequest>>,
) {
pub fn add_request_target(&mut self, target_id: ChannelId, request_sender: S) {
self.add_message_target(target_id, request_sender)
}
}
impl MpscMessageSenderMap<ModeReply> {
impl<S: MessageSender<ModeReply>> MessageSenderMap<ModeReply, S> {
pub fn send_mode_reply(
&self,
local_id: ChannelId,
@ -100,16 +97,12 @@ impl MpscMessageSenderMap<ModeReply> {
self.send_message(local_id, target_id, request)
}
pub fn add_reply_target(
&mut self,
target_id: ChannelId,
request_sender: mpsc::Sender<MessageWithSenderId<ModeReply>>,
) {
pub fn add_reply_target(&mut self, target_id: ChannelId, request_sender: S) {
self.add_message_target(target_id, request_sender)
}
}
impl ModeReplySender for MpscMessageSenderWithId<ModeReply> {
impl<S: MessageSender<ModeReply>> ModeReplySender for MessageSenderMapWithId<ModeReply, S> {
fn send_mode_reply(
&self,
target_channel_id: ChannelId,
@ -123,7 +116,7 @@ impl ModeReplySender for MpscMessageSenderWithId<ModeReply> {
}
}
impl ModeRequestSender for MpscMessageSenderWithId<ModeRequest> {
impl<S: MessageSender<ModeRequest>> ModeRequestSender for MessageSenderMapWithId<ModeRequest, S> {
fn local_channel_id(&self) -> ChannelId {
self.local_channel_id
}
@ -137,14 +130,16 @@ impl ModeRequestSender for MpscMessageSenderWithId<ModeRequest> {
}
}
impl ModeReplyReceiver for MpscMessageReceiverWithIds<ModeReply> {
impl<R: MessageReceiver<ModeReply>> ModeReplyReceiver for MessageReceiverWithId<ModeReply, R> {
fn try_recv_mode_reply(
&self,
) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError> {
self.try_recv_message()
}
}
impl ModeRequestReceiver for MpscMessageReceiverWithIds<ModeRequest> {
impl<R: MessageReceiver<ModeRequest>> ModeRequestReceiver
for MessageReceiverWithId<ModeRequest, R>
{
fn try_recv_mode_request(
&self,
) -> Result<Option<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError> {
@ -152,7 +147,9 @@ impl ModeRequestReceiver for MpscMessageReceiverWithIds<ModeRequest> {
}
}
impl<FROM> ModeRequestSender for MpscMessageSenderAndReceiver<ModeRequest, FROM> {
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()
}
@ -167,7 +164,9 @@ impl<FROM> ModeRequestSender for MpscMessageSenderAndReceiver<ModeRequest, FROM>
}
}
impl<FROM> ModeReplySender for MpscMessageSenderAndReceiver<ModeReply, FROM> {
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()
}
@ -182,7 +181,9 @@ impl<FROM> ModeReplySender for MpscMessageSenderAndReceiver<ModeReply, FROM> {
}
}
impl<TO> ModeReplyReceiver for MpscMessageSenderAndReceiver<TO, ModeReply> {
impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeReply>> ModeReplyReceiver
for MessageSenderAndReceiver<TO, ModeReply, S, R>
{
fn try_recv_mode_reply(
&self,
) -> Result<Option<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError> {
@ -190,7 +191,9 @@ impl<TO> ModeReplyReceiver for MpscMessageSenderAndReceiver<TO, ModeReply> {
.try_recv_message(self.local_channel_id_generic())
}
}
impl<TO> ModeRequestReceiver for MpscMessageSenderAndReceiver<TO, ModeRequest> {
impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeRequest>> ModeRequestReceiver
for MessageSenderAndReceiver<TO, ModeRequest, S, R>
{
fn try_recv_mode_request(
&self,
) -> Result<Option<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError> {
@ -199,33 +202,63 @@ impl<TO> ModeRequestReceiver for MpscMessageSenderAndReceiver<TO, ModeRequest> {
}
}
pub type MpscModeRequestHandlerConnector = MpscMessageSenderAndReceiver<ModeReply, ModeRequest>;
pub type MpscModeRequestorConnector = MpscMessageSenderAndReceiver<ModeRequest, ModeReply>;
pub type MpscModeConnector = MpscRequestAndReplySenderAndReceiver<ModeRequest, ModeReply>;
pub type ModeRequestHandlerConnector<S, R> = MessageSenderAndReceiver<ModeReply, ModeRequest, S, R>;
pub type MpscModeRequestHandlerConnector = ModeRequestHandlerConnector<
mpsc::Sender<MessageWithSenderId<ModeReply>>,
mpsc::Receiver<MessageWithSenderId<ModeRequest>>,
>;
impl<REPLY> MpscRequestAndReplySenderAndReceiver<ModeRequest, REPLY> {
pub fn add_request_target(
&mut self,
target_id: ChannelId,
request_sender: mpsc::Sender<MessageWithSenderId<ModeRequest>>,
) {
pub type ModeRequestorConnector<S, R> = MessageSenderAndReceiver<ModeRequest, ModeReply, S, R>;
pub type MpscModeRequestorConnector = ModeRequestorConnector<
mpsc::Sender<MessageWithSenderId<ModeRequest>>,
mpsc::Receiver<MessageWithSenderId<ModeReply>>,
>;
pub type ModeConnector<S0, R0, S1, R1> =
RequestAndReplySenderAndReceiver<ModeRequest, ModeReply, S0, R0, S1, R1>;
pub type MpscModeConnector = ModeConnector<
mpsc::Sender<MessageWithSenderId<ModeRequest>>,
mpsc::Receiver<MessageWithSenderId<ModeReply>>,
mpsc::Sender<MessageWithSenderId<ModeReply>>,
mpsc::Receiver<MessageWithSenderId<ModeRequest>>,
>;
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> MpscRequestAndReplySenderAndReceiver<REQUEST, ModeReply> {
pub fn add_reply_target(
&mut self,
target_id: ChannelId,
reply_sender: mpsc::Sender<MessageWithSenderId<ModeReply>>,
) {
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> ModeRequestSender for MpscRequestAndReplySenderAndReceiver<ModeRequest, REPLY> {
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()
}
@ -240,7 +273,14 @@ impl<REPLY> ModeRequestSender for MpscRequestAndReplySenderAndReceiver<ModeReque
}
}
impl<REQUEST> ModeReplySender for MpscRequestAndReplySenderAndReceiver<REQUEST, ModeReply> {
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()
}
@ -255,7 +295,14 @@ impl<REQUEST> ModeReplySender for MpscRequestAndReplySenderAndReceiver<REQUEST,
}
}
impl<REQUEST> ModeReplyReceiver for MpscRequestAndReplySenderAndReceiver<REQUEST, ModeReply> {
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<MessageWithSenderId<ModeReply>>, GenericTargetedMessagingError> {
@ -264,7 +311,14 @@ impl<REQUEST> ModeReplyReceiver for MpscRequestAndReplySenderAndReceiver<REQUEST
}
}
impl<REPLY> ModeRequestReceiver for MpscRequestAndReplySenderAndReceiver<ModeRequest, REPLY> {
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<MessageWithSenderId<ModeRequest>>, GenericTargetedMessagingError> {

231
satrs/src/request.rs
View File

@ -11,7 +11,7 @@ use spacepackets::{
ByteConversionError, CcsdsPacket,
};
use crate::{ChannelId, TargetId};
use crate::{queue::GenericTargetedMessagingError, ChannelId, TargetId};
pub type Apid = u16;
@ -113,20 +113,31 @@ impl fmt::Display for TargetAndApidId {
}
}
pub struct MessageWithSenderId<MESSAGE> {
pub struct MessageWithSenderId<MSG> {
pub sender_id: ChannelId,
pub message: MESSAGE,
pub message: MSG,
}
impl<MESSAGE> MessageWithSenderId<MESSAGE> {
pub fn new(sender_id: ChannelId, message: MESSAGE) -> Self {
impl<MSG> MessageWithSenderId<MSG> {
pub fn new(sender_id: ChannelId, message: MSG) -> Self {
Self { sender_id, message }
}
}
/// Generic trait for objects which can send targeted messages.
pub trait MessageSender<MSG>: Send {
fn send(&self, message: MessageWithSenderId<MSG>) -> Result<(), GenericTargetedMessagingError>;
}
// Generic trait for objects which can receive targeted messages.
pub trait MessageReceiver<MSG> {
fn try_recv(&self) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError>;
}
#[cfg(feature = "std")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
mod std_mod {
use core::marker::PhantomData;
use std::sync::mpsc;
use hashbrown::HashMap;
@ -136,24 +147,59 @@ mod std_mod {
ChannelId,
};
use super::MessageWithSenderId;
use super::{MessageReceiver, MessageSender, MessageWithSenderId};
pub struct MpscMessageSenderMap<MESSAGE>(
pub HashMap<ChannelId, mpsc::Sender<MessageWithSenderId<MESSAGE>>>,
);
impl<MESSAGE> Default for MpscMessageSenderMap<MESSAGE> {
fn default() -> Self {
Self(Default::default())
impl<MSG: Send> MessageSender<MSG> for mpsc::Sender<MessageWithSenderId<MSG>> {
fn send(
&self,
message: MessageWithSenderId<MSG>,
) -> Result<(), GenericTargetedMessagingError> {
self.send(message)
.map_err(|_| GenericSendError::RxDisconnected)?;
Ok(())
}
}
impl<MSG: Send> MessageSender<MSG> for mpsc::SyncSender<MessageWithSenderId<MSG>> {
fn send(
&self,
message: MessageWithSenderId<MSG>,
) -> Result<(), GenericTargetedMessagingError> {
if let Err(e) = self.try_send(message) {
match e {
mpsc::TrySendError::Full(_) => {
return Err(GenericSendError::QueueFull(None).into());
}
mpsc::TrySendError::Disconnected(_) => todo!(),
}
}
Ok(())
}
}
impl<MESSAGE> MpscMessageSenderMap<MESSAGE> {
pub struct MessageSenderMap<MSG, S: MessageSender<MSG>>(
pub HashMap<ChannelId, S>,
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)
}
}
impl<MSG, S: MessageSender<MSG>> MessageSenderMap<MSG, S> {
pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
self.0.insert(target_id, message_sender);
}
pub fn send_message(
&self,
local_channel_id: ChannelId,
target_channel_id: ChannelId,
message: MESSAGE,
message: MSG,
) -> Result<(), GenericTargetedMessagingError> {
if self.0.contains_key(&target_channel_id) {
self.0
@ -167,22 +213,14 @@ mod std_mod {
target_channel_id,
))
}
pub fn add_message_target(
&mut self,
target_id: ChannelId,
message_sender: mpsc::Sender<MessageWithSenderId<MESSAGE>>,
) {
self.0.insert(target_id, message_sender);
}
}
pub struct MpscMessageSenderWithId<MESSAGE> {
pub struct MessageSenderMapWithId<MSG, S: MessageSender<MSG>> {
pub local_channel_id: ChannelId,
pub message_sender_map: MpscMessageSenderMap<MESSAGE>,
pub message_sender_map: MessageSenderMap<MSG, S>,
}
impl<MESSAGE> MpscMessageSenderWithId<MESSAGE> {
impl<MSG, S: MessageSender<MSG>> MessageSenderMapWithId<MSG, S> {
pub fn new(local_channel_id: ChannelId) -> Self {
Self {
local_channel_id,
@ -193,62 +231,62 @@ mod std_mod {
pub fn send_message(
&self,
target_channel_id: ChannelId,
message: MESSAGE,
message: MSG,
) -> Result<(), GenericTargetedMessagingError> {
self.message_sender_map
.send_message(self.local_channel_id, target_channel_id, message)
}
pub fn add_message_target(
&mut self,
target_id: ChannelId,
message_sender: mpsc::Sender<MessageWithSenderId<MESSAGE>>,
) {
pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
self.message_sender_map
.add_message_target(target_id, message_sender)
}
}
pub struct MpscMessageWithSenderReceiver<MESSAGE>(
pub mpsc::Receiver<MessageWithSenderId<MESSAGE>>,
);
impl<MESSAGE> From<mpsc::Receiver<MessageWithSenderId<MESSAGE>>>
for MpscMessageWithSenderReceiver<MESSAGE>
{
fn from(value: mpsc::Receiver<MessageWithSenderId<MESSAGE>>) -> Self {
Self(value)
impl<MSG> MessageReceiver<MSG> for mpsc::Receiver<MessageWithSenderId<MSG>> {
fn try_recv(
&self,
) -> Result<Option<MessageWithSenderId<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())
}
},
}
}
}
impl<MESSAGE> MpscMessageWithSenderReceiver<MESSAGE> {
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<MessageWithSenderId<MESSAGE>>, GenericTargetedMessagingError> {
match self.0.try_recv() {
Ok(reply) => {
return Ok(Some(reply));
}
Err(e) => {
if e == mpsc::TryRecvError::Disconnected {
return Err(GenericReceiveError::TxDisconnected(Some(local_id)).into());
}
}
}
Ok(None)
_local_id: ChannelId,
) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError> {
self.0.try_recv()
}
}
pub struct MpscMessageReceiverWithIds<MESSAGE> {
pub struct MessageReceiverWithId<MSG, R: MessageReceiver<MSG>> {
local_channel_id: ChannelId,
reply_receiver: MpscMessageWithSenderReceiver<MESSAGE>,
reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
}
impl<MESSAGE> MpscMessageReceiverWithIds<MESSAGE> {
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: MpscMessageWithSenderReceiver<MESSAGE>,
reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
) -> Self {
Self {
local_channel_id,
@ -259,50 +297,34 @@ mod std_mod {
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<MessageWithSenderId<MESSAGE>>, GenericTargetedMessagingError> {
match self.reply_receiver.0.try_recv() {
Ok(reply) => {
return Ok(Some(reply));
}
Err(e) => {
if e == mpsc::TryRecvError::Disconnected {
return Err(GenericReceiveError::TxDisconnected(Some(
self.local_channel_id(),
))
.into());
}
}
}
Ok(None)
) -> Result<Option<MessageWithSenderId<MSG>>, GenericTargetedMessagingError> {
self.reply_receiver.0.try_recv()
}
}
pub struct MpscMessageSenderAndReceiver<TO, FROM> {
pub struct MessageSenderAndReceiver<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>> {
pub local_channel_id: ChannelId,
pub message_sender_map: MpscMessageSenderMap<TO>,
pub message_receiver: MpscMessageWithSenderReceiver<FROM>,
pub message_sender_map: MessageSenderMap<TO, S>,
pub message_receiver: MessageWithSenderIdReceiver<FROM, R>,
}
impl<TO, FROM> MpscMessageSenderAndReceiver<TO, FROM> {
pub fn new(
local_channel_id: ChannelId,
message_receiver: mpsc::Receiver<MessageWithSenderId<FROM>>,
) -> Self {
impl<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>>
MessageSenderAndReceiver<TO, FROM, S, R>
{
pub fn new(local_channel_id: ChannelId, message_receiver: R) -> Self {
Self {
local_channel_id,
message_sender_map: Default::default(),
message_receiver: MpscMessageWithSenderReceiver::from(message_receiver),
message_receiver: MessageWithSenderIdReceiver::from(message_receiver),
}
}
pub fn add_message_target(
&mut self,
target_id: ChannelId,
message_sender: mpsc::Sender<MessageWithSenderId<TO>>,
) {
pub fn add_message_target(&mut self, target_id: ChannelId, message_sender: S) {
self.message_sender_map
.add_message_target(target_id, message_sender)
}
@ -312,22 +334,33 @@ mod std_mod {
}
}
pub struct MpscRequestAndReplySenderAndReceiver<REQUEST, REPLY> {
pub struct RequestAndReplySenderAndReceiver<
REQUEST,
REPLY,
S0: MessageSender<REQUEST>,
R0: MessageReceiver<REPLY>,
S1: MessageSender<REPLY>,
R1: MessageReceiver<REQUEST>,
> {
pub local_channel_id: ChannelId,
// These 2 are a functional group.
pub request_sender_map: MpscMessageSenderMap<REQUEST>,
pub reply_receiver: MpscMessageWithSenderReceiver<REPLY>,
pub request_sender_map: MessageSenderMap<REQUEST, S0>,
pub reply_receiver: MessageWithSenderIdReceiver<REPLY, R0>,
// These 2 are a functional group.
pub request_receiver: MpscMessageWithSenderReceiver<REQUEST>,
pub reply_sender_map: MpscMessageSenderMap<REPLY>,
pub request_receiver: MessageWithSenderIdReceiver<REQUEST, R1>,
pub reply_sender_map: MessageSenderMap<REPLY, S1>,
}
impl<REQUEST, REPLY> MpscRequestAndReplySenderAndReceiver<REQUEST, REPLY> {
pub fn new(
local_channel_id: ChannelId,
request_receiver: mpsc::Receiver<MessageWithSenderId<REQUEST>>,
reply_receiver: mpsc::Receiver<MessageWithSenderId<REPLY>>,
) -> Self {
impl<
REQUEST,
REPLY,
S0: MessageSender<REQUEST>,
R0: MessageReceiver<REPLY>,
S1: MessageSender<REPLY>,
R1: MessageReceiver<REQUEST>,
> RequestAndReplySenderAndReceiver<REQUEST, REPLY, S0, R0, S1, R1>
{
pub fn new(local_channel_id: ChannelId, request_receiver: R1, reply_receiver: R0) -> Self {
Self {
local_channel_id,
request_receiver: request_receiver.into(),