Renamed plexmpsc to mpsc and Sender to IntoSender

4 files changed, 15 insertions, 15 deletions

diff --git a/mullvad_daemon/src/main.rs b/mullvad_daemon/src/main.rs
index 23590e4a46..04c4f79cbd 100644
--- a/mullvad_daemon/src/main.rs
+++ b/mullvad_daemon/src/main.rs
@@ -31,7 +31,7 @@ use std::sync::{Arc, Mutex, mpsc};
 use std::thread;
 
 use talpid_core::net::RemoteAddr;
-use talpid_core::plexmpsc;
+use talpid_core::mpsc::IntoSender;
 use talpid_core::tunnel::{self, TunnelEvent, TunnelMonitor};
 
 error_chain!{
@@ -138,14 +138,14 @@ impl Daemon {
     // Returns a handle that allows notifying all subscribers on events.
     fn start_management_interface(event_tx: mpsc::Sender<DaemonEvent>)
                                   -> Result<management_interface::EventBroadcaster> {
-        let multiplex_event_tx = plexmpsc::Sender::from(event_tx.clone());
+        let multiplex_event_tx = IntoSender::from(event_tx.clone());
         let server = Self::start_management_interface_server(multiplex_event_tx)?;
         let event_broadcaster = server.event_broadcaster();
         Self::spawn_management_interface_wait_thread(server, event_tx);
         Ok(event_broadcaster)
     }
 
-    fn start_management_interface_server(event_tx: plexmpsc::Sender<TunnelCommand, DaemonEvent>)
+    fn start_management_interface_server(event_tx: IntoSender<TunnelCommand, DaemonEvent>)
                                          -> Result<ManagementInterfaceServer> {
         let server =
             ManagementInterfaceServer::start(event_tx)
diff --git a/mullvad_daemon/src/management_interface.rs b/mullvad_daemon/src/management_interface.rs
index 6f5067c9cc..6c41c85793 100644
--- a/mullvad_daemon/src/management_interface.rs
+++ b/mullvad_daemon/src/management_interface.rs
@@ -11,7 +11,7 @@ use std::collections::hash_map::Entry;
 use std::net::{IpAddr, Ipv4Addr};
 use std::sync::{Arc, Mutex, RwLock};
 
-use talpid_core::plexmpsc;
+use talpid_core::mpsc::IntoSender;
 use talpid_ipc;
 use uuid;
 
@@ -110,7 +110,7 @@ pub struct ManagementInterfaceServer {
 }
 
 impl ManagementInterfaceServer {
-    pub fn start<T>(tunnel_tx: plexmpsc::Sender<TunnelCommand, T>) -> talpid_ipc::Result<Self>
+    pub fn start<T>(tunnel_tx: IntoSender<TunnelCommand, T>) -> talpid_ipc::Result<Self>
         where T: From<TunnelCommand> + 'static + Send
     {
         let rpc = ManagementInterface::new(tunnel_tx);
@@ -160,11 +160,11 @@ impl EventBroadcaster {
 
 struct ManagementInterface<T: From<TunnelCommand> + 'static + Send> {
     active_subscriptions: ActiveSubscriptions,
-    tx: Mutex<plexmpsc::Sender<TunnelCommand, T>>,
+    tx: Mutex<IntoSender<TunnelCommand, T>>,
 }
 
 impl<T: From<TunnelCommand> + 'static + Send> ManagementInterface<T> {
-    pub fn new(tx: plexmpsc::Sender<TunnelCommand, T>) -> Self {
+    pub fn new(tx: IntoSender<TunnelCommand, T>) -> Self {
         ManagementInterface {
             active_subscriptions: Default::default(),
             tx: Mutex::new(tx),
diff --git a/talpid_core/src/lib.rs b/talpid_core/src/lib.rs
index 3ebb24d1ec..52213ebee0 100644
--- a/talpid_core/src/lib.rs
+++ b/talpid_core/src/lib.rs
@@ -31,5 +31,5 @@ pub mod net;
 /// Abstracts over different VPN tunnel technologies
 pub mod tunnel;
 
-/// Multiplexing abstractions over `std::mpsc`
-pub mod plexmpsc;
+/// Abstractions and extra features on `std::mpsc`
+pub mod mpsc;
diff --git a/talpid_core/src/plexmpsc.rs b/talpid_core/src/mpsc.rs
index be1904bdb2..d63956c452 100644
--- a/talpid_core/src/plexmpsc.rs
+++ b/talpid_core/src/mpsc.rs
@@ -3,12 +3,12 @@ use std::sync::mpsc;
 
 /// Abstraction over an `mpsc::Sender` that first converts the value to another type before sending.
 #[derive(Debug, Clone)]
-pub struct Sender<T, U> {
+pub struct IntoSender<T, U> {
     sender: mpsc::Sender<U>,
     _marker: PhantomData<T>,
 }
 
-impl<T, U> Sender<T, U>
+impl<T, U> IntoSender<T, U>
     where T: Into<U>
 {
     /// Converts the `T` into a `U` and sends it on the channel.
@@ -17,11 +17,11 @@ impl<T, U> Sender<T, U>
     }
 }
 
-impl<T, U> From<mpsc::Sender<U>> for Sender<T, U>
+impl<T, U> From<mpsc::Sender<U>> for IntoSender<T, U>
     where T: Into<U>
 {
     fn from(sender: mpsc::Sender<U>) -> Self {
-        Sender {
+        IntoSender {
             sender: sender,
             _marker: PhantomData,
         }
@@ -55,7 +55,7 @@ mod tests {
     #[test]
     fn sender() {
         let (tx, rx) = mpsc::channel::<Outer>();
-        let inner_tx: Sender<Inner, Outer> = tx.clone().into();
+        let inner_tx: IntoSender<Inner, Outer> = tx.clone().into();
 
         tx.send(Outer::Other).unwrap();
         inner_tx.send(Inner::Two).unwrap();
@@ -67,7 +67,7 @@ mod tests {
     #[test]
     fn send_between_thread() {
         let (tx, rx) = mpsc::channel::<Outer>();
-        let inner_tx: Sender<Inner, Outer> = tx.clone().into();
+        let inner_tx: IntoSender<Inner, Outer> = tx.clone().into();
 
         thread::spawn(move || { inner_tx.send(Inner::One).unwrap(); });