renaming

Author: stneng

examples/protocol_variable_transfer.rs

@@ -26,7 +26,7 @@ impl ProtocolEntry for Receiver {
         param: Vec<u8>,
         participants: Vec<Participant>,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-        let msg = cl.receive_variable("output", &participants[0]).await?;
+        let msg = cl.recv_variable("output", &participants[0]).await?;
         println!("{}", String::from_utf8_lossy(&msg));
         cl.create_entry(&format!("tasks:{}:output", cl.get_task_id()?), &msg)
             .await?;

src/extensions/variable_transfer.rs

@@ -47,25 +47,19 @@ impl crate::application::CoLink {
         Ok(())
     }
 
-    #[deprecated(note = "please use `receive_variable` instead")]
+    #[deprecated(note = "please use `recv_variable` instead")]
     pub async fn get_variable(&self, key: &str, sender: &Participant) -> Result<Vec<u8>, Error> {
-        self.receive_variable(key, sender).await
+        self.recv_variable(key, sender).await
     }
 
-    pub async fn receive_variable(
-        &self,
-        key: &str,
-        sender: &Participant,
-    ) -> Result<Vec<u8>, Error> {
+    pub async fn recv_variable(&self, key: &str, sender: &Participant) -> Result<Vec<u8>, Error> {
         if self.task_id.is_empty() {
             Err("task_id not found".to_string())?;
         }
-        if let Ok(res) = self._receive_variable_p2p(key, sender).await {
+        if let Ok(res) = self._recv_variable_p2p(key, sender).await {
             return Ok(res);
         }
-        let res = self
-            .receive_variable_with_remote_storage(key, sender)
-            .await?;
+        let res = self.recv_variable_with_remote_storage(key, sender).await?;
         Ok(res)
     }
 }

src/extensions/variable_transfer/p2p_inbox.rs

@@ -165,7 +165,7 @@ impl crate::application::CoLink {
             .contains_key(&receiver.user_id)
         {
             let inbox = self
-                .receive_variable_with_remote_storage("inbox", receiver)
+                .recv_variable_with_remote_storage("inbox", receiver)
                 .await?;
             let inbox: VTInbox = serde_json::from_slice(&inbox)?;
             let inbox = if inbox.addr.is_empty() {
@@ -218,7 +218,7 @@ impl crate::application::CoLink {
         Ok(())
     }
 
-    pub(crate) async fn _receive_variable_p2p(
+    pub(crate) async fn _recv_variable_p2p(
         &self,
         key: &str,
         sender: &Participant,

src/extensions/variable_transfer/remote_storage.rs

@@ -60,16 +60,16 @@ impl crate::application::CoLink {
         Ok(())
     }
 
-    #[deprecated(note = "please use `receive_variable_with_remote_storage` instead")]
+    #[deprecated(note = "please use `recv_variable_with_remote_storage` instead")]
     pub async fn get_variable_with_remote_storage(
         &self,
         key: &str,
         sender: &Participant,
     ) -> Result<Vec<u8>, Error> {
-        self.receive_variable_with_remote_storage(key, sender).await
+        self.recv_variable_with_remote_storage(key, sender).await
     }
 
-    pub async fn receive_variable_with_remote_storage(
+    pub async fn recv_variable_with_remote_storage(
         &self,
         key: &str,
         sender: &Participant,

tests/test_protocol_variable_transfer.rs

@@ -40,11 +40,11 @@ impl ProtocolEntry for Receiver {
         for i in 0..8 {
             let key = &format!("output{}", i);
             let key2 = &format!("output_remote_storage{}", i);
-            let msg = cl.receive_variable(key, &participants[0]).await?;
+            let msg = cl.recv_variable(key, &participants[0]).await?;
             cl.create_entry(&format!("tasks:{}:output{}", cl.get_task_id()?, i), &msg)
                 .await?;
             let msg = cl
-                .receive_variable_with_remote_storage(key2, &participants[0])
+                .recv_variable_with_remote_storage(key2, &participants[0])
                 .await?;
             cl.create_entry(
                 &format!("tasks:{}:output_remote_storage{}", cl.get_task_id()?, i),