Implmeent call_variadic()

Author: johnteee

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lua_actor"
-version = "0.2.0"
+version = "0.2.1"
 license = "MIT"
 authors = ["JunYi JohnTeee Lee <[email protected]>"]
 include = ["src/**/*.rs", "Cargo.toml"]

src/actor.rs

@@ -6,7 +6,9 @@ use fp_rust::{
     sync::{CountDownLatch, Will, WillAsync},
 };
 use message::LuaMessage;
-use rlua::{Chunk, Context, Error, FromLua, FromLuaMulti, Function, Lua, Table, ToLua, ToLuaMulti};
+use rlua::{
+    Chunk, Context, Error, FromLua, FromLuaMulti, Function, Lua, Table, ToLua, ToLuaMulti, Variadic,
+};
 
 #[derive(Clone)]
 pub struct Actor {
@@ -282,43 +284,91 @@ impl Actor {
         lua.load(source).eval()
     }
 
-    pub fn call(&self, name: &'static str, args: LuaMessage) -> Result<LuaMessage, Error> {
+    pub fn call_one(&self, name: &'static str, args: LuaMessage) -> Result<LuaMessage, Error> {
+        match self.handler.clone() {
+            Some(_handler) => {
+                let lua = self.lua.clone();
+                self.wait_async_lua_message_result(&_handler, move || {
+                    Self::_call_one(&lua, name, args.clone())
+                })
+            }
+            None => Self::_call_one(&self.lua.clone(), name, args),
+        }
+    }
+    pub fn call_one_nowait(&self, name: &'static str, args: LuaMessage) -> Result<(), Error> {
+        match self.handler.clone() {
+            Some(_handler) => {
+                let lua = self.lua.clone();
+                _handler.lock().unwrap().post(RawFunc::new(move || {
+                    let _ = Self::_call_one(&lua.clone(), name, args.clone());
+                }));
+            }
+            None => {
+                Self::_call_one(&self.lua.clone(), name, args)?;
+            }
+        }
+        Ok(())
+    }
+    #[inline]
+    fn _call_one(lua: &Arc<Mutex<Lua>>, name: &str, args: LuaMessage) -> Result<LuaMessage, Error> {
+        let vm = lua.lock().unwrap();
+        vm.context(|lua| {
+            lua.globals()
+                .get::<_, Function>(name)
+                .unwrap()
+                .call::<_, _>(args)
+        })
+    }
+    pub fn call_variadic(
+        &self,
+        name: &'static str,
+        args: Variadic<LuaMessage>,
+    ) -> Result<LuaMessage, Error> {
         match self.handler.clone() {
             Some(_handler) => {
                 let lua = self.lua.clone();
                 self.wait_async_lua_message_result(&_handler, move || {
-                    Self::_call(&lua, name, args.clone())
+                    Self::_call_variadic(&lua, name, args.clone())
                 })
             }
-            None => Self::_call(&self.lua.clone(), name, args),
+            None => Self::_call_variadic(&self.lua.clone(), name, args),
         }
     }
-    pub fn call_nowait(&self, name: &'static str, args: LuaMessage) -> Result<(), Error> {
+    pub fn call_variadic_nowait(
+        &self,
+        name: &'static str,
+        args: Variadic<LuaMessage>,
+    ) -> Result<(), Error> {
         match self.handler.clone() {
             Some(_handler) => {
                 let lua = self.lua.clone();
                 _handler.lock().unwrap().post(RawFunc::new(move || {
-                    let _ = Self::_call(&lua.clone(), name, args.clone());
+                    let _ = Self::_call_variadic(&lua.clone(), name, args.clone());
                 }));
             }
             None => {
-                Self::_call(&self.lua.clone(), name, args)?;
+                Self::_call_variadic(&self.lua.clone(), name, args)?;
             }
         }
         Ok(())
     }
     #[inline]
-    fn _call(lua: &Arc<Mutex<Lua>>, name: &str, args: LuaMessage) -> Result<LuaMessage, Error> {
+    fn _call_variadic(
+        lua: &Arc<Mutex<Lua>>,
+        name: &str,
+        args: Variadic<LuaMessage>,
+    ) -> Result<LuaMessage, Error> {
         let vm = lua.lock().unwrap();
         vm.context(|lua| {
             lua.globals()
                 .get::<_, Function>(name)
                 .unwrap()
-                .call::<_, LuaMessage>(args)
+                .call::<_, _>(args)
         })
     }
+    /*
     #[inline]
-    pub fn call_multi<'lua, A, R>(lua: Context<'lua>, name: &str, args: A) -> Result<R, Error>
+    pub fn call_variadic<'lua, A, R>(lua: Context<'lua>, name: &str, args: A) -> Result<R, Error>
     where
         A: ToLuaMulti<'lua> + Send + Sync + Clone + 'static,
         R: FromLuaMulti<'lua>,
@@ -327,11 +377,12 @@ impl Actor {
 
         func.call::<_, R>(args)
     }
+    // */
 }
 
 #[test]
 fn test_actor_new() {
-    use rlua::Variadic;
+    use std::iter::FromIterator;
 
     fn test_actor(act: Actor) {
         let _ = act.exec_nowait(
@@ -358,7 +409,7 @@ fn test_actor_new() {
         )
         .ok()
         .unwrap();
-        match act.call("testit", LuaMessage::from(1)) {
+        match act.call_one("testit", LuaMessage::from(1)) {
             Ok(_v) => {
                 assert_eq!(Some(2), Option::from(_v));
             }
@@ -367,6 +418,48 @@ fn test_actor_new() {
                 std::panic::panic_any(_err);
             }
         }
+        act.exec(
+            r#"
+            function testlist (vlist)
+                return #vlist
+            end
+        "#,
+        )
+        .ok()
+        .unwrap();
+        match act.call_one(
+            "testlist",
+            Vec::<LuaMessage>::from_iter([3.into(), 2.into()]).into(),
+        ) {
+            Ok(_v) => {
+                assert_eq!(Some(2), Option::from(_v));
+            }
+            Err(_err) => {
+                println!("{:?}", _err);
+                std::panic::panic_any(_err);
+            }
+        };
+        act.exec(
+            r#"
+            function testvargs (v1, v2)
+                return v1 + v2
+            end
+        "#,
+        )
+        .ok()
+        .unwrap();
+        match act.call_variadic(
+            "testvargs",
+            Variadic::<LuaMessage>::from_iter([6.into(), 7.into()]).into(),
+        ) {
+            Ok(_v) => {
+                assert_eq!(Some(13), Option::from(_v));
+            }
+            Err(_err) => {
+                println!("{:?}", _err);
+                std::panic::panic_any(_err);
+            }
+        };
 
         {
             act.lua.lock().unwrap().context(|lua| {

src/message.rs

@@ -3,9 +3,11 @@ Credits(mainly, except Array & reverse conversions):
 https://github.com/poga/actix-lua/blob/master/src/message.rs
 */
 
-use rlua::Result as LuaResult;
-use rlua::{Context, FromLua, ToLua, Value};
 use std::collections::HashMap;
+use std::iter::FromIterator;
+
+use rlua::Result as LuaResult;
+use rlua::{Context, FromLua, ToLua, Value, Variadic};
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum LuaMessage {
@@ -64,6 +66,22 @@ impl From<LuaMessage> for Option<String> {
     }
 }
 
+impl From<Variadic<LuaMessage>> for LuaMessage {
+    fn from(s: Variadic<LuaMessage>) -> Self {
+        LuaMessage::from(
+            s.into_iter()
+                .map(|v| LuaMessage::from(v.clone()))
+                .collect::<Vec<LuaMessage>>(),
+        )
+    }
+}
+
+impl Into<Variadic<LuaMessage>> for LuaMessage {
+    fn into(self) -> Variadic<LuaMessage> {
+        return Variadic::from_iter([self]);
+    }
+}
+
 macro_rules! lua_message_number_convert {
     ($x:ty) => {
         impl From<LuaMessage> for Option<$x> {

test.sh

@@ -1,2 +1,2 @@
-# RUST_BACKTRACE=1 cargo test -- --color always --nocapture
-cargo test -- --color always --nocapture
+RUST_BACKTRACE=1 cargo test -- --color always --nocapture
+# cargo test -- --color always --nocapture