rename

Author: dignifiedquire

Cargo.toml

@@ -60,12 +60,12 @@ futures-buffered = "0.2.4"
 hyper-transport = ["dep:flume", "dep:hyper", "dep:bincode", "dep:bytes", "dep:tokio-serde", "dep:tokio-util"]
 quinn-transport = ["dep:flume", "dep:quinn", "dep:bincode", "dep:tokio-serde", "dep:tokio-util"]
 flume-transport = ["dep:flume"]
-async-channel-transport = ["dep:tokio-util", "dep:tokio-stream"]
+tokio-mpsc-transport = ["dep:tokio-util", "dep:tokio-stream"]
 interprocess-transport = ["quinn-transport", "quinn-flume-socket", "dep:quinn-udp", "dep:interprocess", "dep:bytes", "dep:tokio-util", "dep:futures"]
 combined-transport = []
 quinn-flume-socket = ["dep:flume", "dep:quinn", "dep:quinn-udp", "dep:bytes", "dep:tokio-util"]
 macros = []
-default = ["flume-transport", "async-channel-transport"]
+default = ["flume-transport", "tokio-mpsc-transport"]
 
 [package.metadata.docs.rs]
 all-features = true

src/transport/mod.rs

@@ -7,8 +7,6 @@ use std::{
     fmt::{self, Debug, Display},
     net::SocketAddr,
 };
-#[cfg(feature = "async-channel-transport")]
-pub mod async_channel;
 #[cfg(feature = "flume-transport")]
 pub mod boxed;
 #[cfg(feature = "combined-transport")]
@@ -23,6 +21,8 @@ pub mod interprocess;
 pub mod quinn;
 #[cfg(feature = "quinn-flume-socket")]
 pub mod quinn_flume_socket;
+#[cfg(feature = "tokio-mpsc-transport")]
+pub mod tokio_mpsc;
 
 pub mod misc;
 

src/transport/async_channel.rs renamed to src/transport/tokio_mpsc.rs

@@ -4,7 +4,7 @@ use futures_lite::Stream;
 use futures_sink::Sink;
 
 use crate::{
-    transport::{Connection, ConnectionErrors, LocalAddr, ServerEndpoint},
+    transport::{self, ConnectionErrors, LocalAddr},
     RpcMessage, Service,
 };
 use core::fmt;
@@ -100,28 +100,28 @@ impl error::Error for RecvError {}
 /// A `tokio::sync::mpsc` based server endpoint.
 ///
 /// Created using [connection].
-pub struct MpscServerEndpoint<S: Service> {
+pub struct ServerEndpoint<S: Service> {
     #[allow(clippy::type_complexity)]
     stream: Arc<Mutex<mpsc::Receiver<(SendSink<S::Res>, RecvStream<S::Req>)>>>,
 }
 
-impl<S: Service> Clone for MpscServerEndpoint<S> {
+impl<S: Service> Clone for ServerEndpoint<S> {
     fn clone(&self) -> Self {
         Self {
             stream: self.stream.clone(),
         }
     }
 }
 
-impl<S: Service> fmt::Debug for MpscServerEndpoint<S> {
+impl<S: Service> fmt::Debug for ServerEndpoint<S> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("MpscServerEndpoint")
+        f.debug_struct("ServerEndpoint")
             .field("stream", &self.stream)
             .finish()
     }
 }
 
-impl<S: Service> ConnectionErrors for MpscServerEndpoint<S> {
+impl<S: Service> ConnectionErrors for ServerEndpoint<S> {
     type SendError = self::SendError;
 
     type RecvError = self::RecvError;
@@ -131,12 +131,12 @@ impl<S: Service> ConnectionErrors for MpscServerEndpoint<S> {
 
 type Socket<In, Out> = (self::SendSink<Out>, self::RecvStream<In>);
 
-impl<S: Service> ConnectionCommon<S::Req, S::Res> for MpscServerEndpoint<S> {
+impl<S: Service> ConnectionCommon<S::Req, S::Res> for ServerEndpoint<S> {
     type SendSink = SendSink<S::Res>;
     type RecvStream = RecvStream<S::Req>;
 }
 
-impl<S: Service> ServerEndpoint<S::Req, S::Res> for MpscServerEndpoint<S> {
+impl<S: Service> transport::ServerEndpoint<S::Req, S::Res> for ServerEndpoint<S> {
     async fn accept_bi(&self) -> Result<(Self::SendSink, Self::RecvStream), AcceptBiError> {
         let (send, recv) = self
             .stream
@@ -153,20 +153,20 @@ impl<S: Service> ServerEndpoint<S::Req, S::Res> for MpscServerEndpoint<S> {
     }
 }
 
-impl<S: Service> ConnectionErrors for MpscConnection<S> {
+impl<S: Service> ConnectionErrors for Connection<S> {
     type SendError = self::SendError;
 
     type RecvError = self::RecvError;
 
     type OpenError = self::OpenBiError;
 }
 
-impl<S: Service> ConnectionCommon<S::Res, S::Req> for MpscConnection<S> {
+impl<S: Service> ConnectionCommon<S::Res, S::Req> for Connection<S> {
     type SendSink = SendSink<S::Req>;
     type RecvStream = RecvStream<S::Res>;
 }
 
-impl<S: Service> Connection<S::Res, S::Req> for MpscConnection<S> {
+impl<S: Service> transport::Connection<S::Res, S::Req> for Connection<S> {
     async fn open_bi(&self) -> result::Result<Socket<S::Res, S::Req>, self::OpenBiError> {
         let (local_send, remote_recv) = mpsc::channel::<S::Req>(128);
         let (remote_send, local_recv) = mpsc::channel::<S::Res>(128);
@@ -186,25 +186,25 @@ impl<S: Service> Connection<S::Res, S::Req> for MpscConnection<S> {
     }
 }
 
-/// A mpsc based connection to a server endpoint.
+/// A tokio::sync::mpsc based connection to a server endpoint.
 ///
 /// Created using [connection].
-pub struct MpscConnection<S: Service> {
+pub struct Connection<S: Service> {
     #[allow(clippy::type_complexity)]
     sink: mpsc::Sender<(SendSink<S::Res>, RecvStream<S::Req>)>,
 }
 
-impl<S: Service> Clone for MpscConnection<S> {
+impl<S: Service> Clone for Connection<S> {
     fn clone(&self) -> Self {
         Self {
             sink: self.sink.clone(),
         }
     }
 }
 
-impl<S: Service> fmt::Debug for MpscConnection<S> {
+impl<S: Service> fmt::Debug for Connection<S> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("MpscClientChannel")
+        f.debug_struct("ClientChannel")
             .field("sink", &self.sink)
             .finish()
     }
@@ -277,12 +277,12 @@ impl std::error::Error for CreateChannelError {}
 /// Create a mpsc server endpoint and a connected mpsc client channel.
 ///
 /// `buffer` the size of the buffer for each channel. Keep this at a low value to get backpressure
-pub fn connection<S: Service>(buffer: usize) -> (MpscServerEndpoint<S>, MpscConnection<S>) {
+pub fn connection<S: Service>(buffer: usize) -> (ServerEndpoint<S>, Connection<S>) {
     let (sink, stream) = mpsc::channel(buffer);
     (
-        MpscServerEndpoint {
+        ServerEndpoint {
             stream: Arc::new(Mutex::new(stream)),
         },
-        MpscConnection { sink },
+        Connection { sink },
     )
 }