Auto merge of #249 - Manishearth:opaque-receiver, r=jdm

Make OpaqueIpcReceiver useful

Currently it can't be converted to an IpcReceiver and isn't serializable, which makes it rather useless.

r? @pcwalton

src/ipc.rs

@@ -218,13 +218,7 @@ impl<T> IpcReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
 
 impl<'de, T> Deserialize<'de> for IpcReceiver<T> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
-        let index: usize = Deserialize::deserialize(deserializer)?;
-        let os_receiver =
-            OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| {
-                // FIXME(pcwalton): This could panic if the data was corrupt and the index was out
-                // of bounds. We should return an `Err` result instead.
-                os_ipc_channels_for_deserialization.borrow_mut()[index].to_receiver()
-            });
+        let os_receiver = deserialize_os_ipc_receiver(deserializer)?;
         Ok(IpcReceiver {
             os_receiver: os_receiver,
             phantom: PhantomData,
@@ -234,15 +228,7 @@ impl<'de, T> Deserialize<'de> for IpcReceiver<T> {
 
 impl<T> Serialize for IpcReceiver<T> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
-        let index = OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| {
-            let mut os_ipc_channels_for_serialization =
-                os_ipc_channels_for_serialization.borrow_mut();
-            let index = os_ipc_channels_for_serialization.len();
-            os_ipc_channels_for_serialization.push(OsIpcChannel::Receiver(self.os_receiver
-                                                                              .consume()));
-            index
-        });
-        index.serialize(serializer)
+        serialize_os_ipc_receiver(&self.os_receiver, serializer)
     }
 }
 
@@ -644,6 +630,30 @@ pub struct OpaqueIpcReceiver {
     os_receiver: OsIpcReceiver,
 }
 
+impl OpaqueIpcReceiver {
+    pub fn to<'de, T>(self) -> IpcReceiver<T> where T: Deserialize<'de> + Serialize {
+        IpcReceiver {
+            os_receiver: self.os_receiver,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OpaqueIpcReceiver {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+        let os_receiver = deserialize_os_ipc_receiver(deserializer)?;
+        Ok(OpaqueIpcReceiver {
+            os_receiver: os_receiver,
+        })
+    }
+}
+
+impl Serialize for OpaqueIpcReceiver {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+        serialize_os_ipc_receiver(&self.os_receiver, serializer)
+    }
+}
+
 /// A server associated with a given name.
 ///
 /// # Examples
@@ -736,13 +746,7 @@ impl IpcBytesReceiver {
 
 impl<'de> Deserialize<'de> for IpcBytesReceiver {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
-        let index: usize = Deserialize::deserialize(deserializer)?;
-        let os_receiver =
-            OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| {
-                // FIXME(pcwalton): This could panic if the data was corrupt and the index was out
-                // of bounds. We should return an `Err` result instead.
-                os_ipc_channels_for_deserialization.borrow_mut()[index].to_receiver()
-            });
+        let os_receiver = deserialize_os_ipc_receiver(deserializer)?;
         Ok(IpcBytesReceiver {
             os_receiver: os_receiver,
         })
@@ -751,15 +755,7 @@ impl<'de> Deserialize<'de> for IpcBytesReceiver {
 
 impl Serialize for IpcBytesReceiver {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
-        let index = OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| {
-            let mut os_ipc_channels_for_serialization =
-                os_ipc_channels_for_serialization.borrow_mut();
-            let index = os_ipc_channels_for_serialization.len();
-            os_ipc_channels_for_serialization.push(OsIpcChannel::Receiver(self.os_receiver
-                                                                              .consume()));
-            index
-        });
-        index.serialize(serializer)
+        serialize_os_ipc_receiver(&self.os_receiver, serializer)
     }
 }
 
@@ -820,3 +816,27 @@ fn deserialize_os_ipc_sender<'de, D>(deserializer: D)
         Ok(os_ipc_channels_for_deserialization.borrow_mut()[index].to_sender())
     })
 }
+
+fn serialize_os_ipc_receiver<S>(os_receiver: &OsIpcReceiver, serializer: S)
+                              -> Result<S::Ok, S::Error> where S: Serializer {
+    let index = OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| {
+        let mut os_ipc_channels_for_serialization =
+            os_ipc_channels_for_serialization.borrow_mut();
+        let index = os_ipc_channels_for_serialization.len();
+        os_ipc_channels_for_serialization.push(OsIpcChannel::Receiver(os_receiver
+                                                                          .consume()));
+        index
+    });
+    index.serialize(serializer)
+}
+
+fn deserialize_os_ipc_receiver<'de, D>(deserializer: D)
+                                -> Result<OsIpcReceiver, D::Error> where D: Deserializer<'de> {
+    let index: usize = Deserialize::deserialize(deserializer)?;
+
+    OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| {
+        // FIXME(pcwalton): This could panic if the data was corrupt and the index was out
+        // of bounds. We should return an `Err` result instead.
+        Ok(os_ipc_channels_for_deserialization.borrow_mut()[index].to_receiver())
+    })
+}