Add Array() type of LuaMessage. Add def_fn() (a wrapper and shortcut for create_function())

johnteee · johnteee · commit 5b1cfbeaca3c · 2018-08-06T13:36:02.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lua_actor"
-version = "0.1.5"
+version = "0.1.6"
 license = "MIT"
 authors = ["JunYi JohnTeee Lee <johnteee@gmail.com>"]
 include = ["src/**/*.rs", "Cargo.toml"]
diff --git a/src/actor.rs b/src/actor.rs
@@ -6,7 +6,7 @@ use fp_rust::{
     sync::{CountDownLatch},
     handler::{Handler,HandlerThread},
 };
-use rlua::{Lua,Error,Error::RuntimeError,Function};
+use rlua::{Lua,Error,Error::RuntimeError,Function,FromLuaMulti,ToLuaMulti,Variadic};
 use message::LuaMessage;
 
 #[derive(Clone)]
@@ -47,7 +47,7 @@ impl Actor {
         }
     }
 
-    pub fn set_global(&self, key: String, value: LuaMessage) -> Result<(), Error> {
+    pub fn set_global(&self, key: &'static str, value: LuaMessage) -> Result<(), Error> {
         match self.handler.clone() {
             Some(_handler) => {
                 let lua = self.lua.clone();
@@ -62,13 +62,13 @@ impl Actor {
             }
         }
     }
-    fn _set_global(lua: Arc<Mutex<Lua>>, key: String, value: LuaMessage) -> Result<(), Error> {
+    fn _set_global(lua: Arc<Mutex<Lua>>, key: &str, value: LuaMessage) -> Result<(), Error> {
         let vm = lua.lock().unwrap();
         let globals = vm.globals();
         Ok(globals.set(key, value)?)
     }
 
-    pub fn get_global(&self, key: String) -> Result<LuaMessage, Error> {
+    pub fn get_global(&self, key: &'static str) -> Result<LuaMessage, Error> {
         match self.handler.clone() {
             Some(_handler) => {
                 let _result : Arc<Mutex<Result<LuaMessage, Error>>> = Arc::new(Mutex::new(Err(RuntimeError(String::from("")))));
@@ -109,11 +109,29 @@ impl Actor {
             },
         }
     }
-    fn _get_global(lua: Arc<Mutex<Lua>>, key: String) -> Result<LuaMessage, Error> {
+    fn _get_global(lua: Arc<Mutex<Lua>>, key: &str) -> Result<LuaMessage, Error> {
         let vm = lua.lock().unwrap();
         let globals = vm.globals();
         Ok(globals.get::<_, LuaMessage>(key)?)
     }
+    pub fn def_fn<'lua, 'callback, F, A, R>(lua: &'lua Lua, func: F) -> Result<Function<'lua>, Error>
+        where
+            A: FromLuaMulti<'callback>,
+            R: ToLuaMulti<'callback>,
+            F: 'static + Send + Fn(&'callback Lua, A) -> Result<R, Error>
+    {
+        Ok(lua.create_function(func)?)
+    }
+    pub fn def_fn_with_name<'lua, 'callback, F, A, R>(lua: &'lua Lua, func: F, key: &str) -> Result<Function<'lua>, Error>
+        where
+            A: FromLuaMulti<'callback>,
+            R: ToLuaMulti<'callback>,
+            F: 'static + Send + Fn(&'callback Lua, A) -> Result<R, Error>
+    {
+        let def = lua.create_function(func)?;
+        lua.globals().set(key, def)?;
+        Ok(lua.globals().get::<_, Function<'lua>>(key)?)
+    }
 
     pub fn load<'lua>(lua: &'lua Lua, source: &str, name: Option<&str>) -> Result<Function<'lua>, Error> {
         let vm = lua;
@@ -244,38 +262,72 @@ impl Actor {
     }
     pub fn _call(lua: Arc<Mutex<Lua>>, name: &str, args: LuaMessage) -> Result<LuaMessage, Error> {
         let vm = lua.lock().unwrap();
-        let func: Function = vm.globals().get(name)?;
+        let func: Function = vm.globals().get::<_, Function>(name)?;
+
+        println!("{:?}", 1234);
         Ok(func.call::<_, LuaMessage>(args)?)
     }
 }
 
 #[test]
 fn test_actor_new() {
 
-    fn test_actor(act: Actor) -> Result<(), Error> {
-        act.exec(r#"
+    fn test_actor(act: Actor) {
+        let _ = act.exec(r#"
             i = 1
-        "#, None)?;
-        assert_eq!(Some(1), Option::from(act.get_global("i".to_string())?));
+        "#, None);
+        assert_eq!(Some(1), Option::from(act.get_global("i").ok().unwrap()));
 
         let v = act.eval(r#"
             3
         "#, None);
-        assert_eq!(Some(3), Option::from(v?));
+        assert_eq!(Some(3), Option::from(v.ok().unwrap()));
+
+        act.exec(r#"
+            function testit (i)
+                return i + 1
+            end
+        "#, None).ok().unwrap();
+        match act.call("testit", LuaMessage::from(1)) {
+            Ok(_v) => {
+                assert_eq!(Some(2), Option::from(_v));
+            },
+            Err(_err) => {
+                println!("{:?}", _err);
+                panic!(_err);
+            },
+        }
 
         {
             let vm = act.lua();
-            let vm = &*vm.lock().unwrap();
-            Actor::load(&vm, r#"
-                function test(i)
-                    return i + 1
-                end
-            "#, None)?;
+            let vm = vm.lock().unwrap();
+            Actor::def_fn_with_name(&vm, |_, (list1, list2): (Vec<String>, Vec<String>)| {
+                // This function just checks whether two string lists are equal, and in an inefficient way.
+                // Lua callbacks return `rlua::Result`, an Ok value is a normal return, and an Err return
+                // turns into a Lua 'error'.  Again, any type that is convertible to lua may be returned.
+                Ok(list1 == list2)
+            }, "check_equal").ok().unwrap();
+            Actor::def_fn_with_name(&vm, |_, strings: Variadic<String>| {
+                // (This is quadratic!, it's just an example!)
+                Ok(strings.iter().fold("".to_owned(), |a, b| a + b))
+            }, "join").ok().unwrap();
+            assert_eq!(
+                vm.eval::<bool>(r#"check_equal({"a", "b", "c"}, {"a", "b", "c"})"#, None).ok().unwrap(),
+                true
+            );
+            assert_eq!(
+                vm.eval::<bool>(r#"check_equal({"a", "b", "c"}, {"d", "e", "f"})"#, None).ok().unwrap(),
+                false
+            );
+            assert_eq!(vm.eval::<String>(r#"join("a", "b", "c")"#, None).ok().unwrap(), "abc");
         }
-        assert_eq!(Some(2), Option::from(act.call("test", LuaMessage::from(1))?));
-        assert_eq!(Some(3), Option::from(act.call("test", LuaMessage::from(2))?));
 
-        Ok(())
+        act.set_global("arr1", LuaMessage::from(vec!(LuaMessage::from(1), LuaMessage::from(2)))).ok().unwrap();
+
+        let v = Option::<Vec<LuaMessage>>::from(act.get_global("arr1").ok().unwrap());
+        assert_eq!(LuaMessage::from(1), v.clone().unwrap()[0]);
+        assert_eq!(LuaMessage::from(2), v.clone().unwrap()[1]);
+        assert_eq!(2, v.clone().unwrap().len());
     }
 
     let _ = test_actor(Actor::new_with_handler(None));
diff --git a/src/message.rs b/src/message.rs
@@ -1,5 +1,6 @@
 /*!
-Credits: https://github.com/poga/actix-lua/blob/master/src/message.rs
+Credits(mainly, except Array & reverse convertions):
+https://github.com/poga/actix-lua/blob/master/src/message.rs
 */
 
 use rlua::Result as LuaResult;
@@ -14,6 +15,7 @@ pub enum LuaMessage {
     Boolean(bool),
     Nil,
     Table(HashMap<String, LuaMessage>),
+    Array(Vec<LuaMessage>),
 }
 
 impl From<bool> for LuaMessage {
@@ -45,6 +47,9 @@ impl From<LuaMessage> for Option<bool> {
             LuaMessage::Table(_h) => {
                 Some(_h.len() > 0)
             },
+            LuaMessage::Array(_h) => {
+                Some(_h.len() > 0)
+            },
         }
     }
 }
@@ -80,6 +85,9 @@ impl From<LuaMessage> for Option<String> {
             LuaMessage::Table(_h) => {
                 Some(format!("{:?}",_h))
             },
+            LuaMessage::Array(_h) => {
+                Some(format!("{:?}",_h))
+            },
         }
     }
 }
@@ -114,6 +122,9 @@ macro_rules! lua_message_number_convert {
                     LuaMessage::Table(_h) => {
                         None
                     },
+                    LuaMessage::Array(_h) => {
+                        None
+                    },
                 }
             }
         }
@@ -175,6 +186,50 @@ impl From<LuaMessage> for Option<HashMap<String, LuaMessage>> {
             LuaMessage::Table(_h) => {
                 Some(_h)
             },
+            LuaMessage::Array(_h) => {
+                let mut new_one = HashMap::new();
+                for (k, v) in _h.into_iter().enumerate() {
+                    new_one.insert(k.to_string(), v);
+                }
+                Some(new_one)
+            },
+        }
+    }
+}
+impl From<Vec<LuaMessage>> for LuaMessage {
+    fn from(s: Vec<LuaMessage>) -> Self {
+        LuaMessage::Array(s)
+    }
+}
+impl From<LuaMessage> for Option<Vec<LuaMessage>> {
+    fn from(s: LuaMessage) -> Self {
+        match s {
+            LuaMessage::String(s) => {
+                Some(vec!(LuaMessage::from(s)))
+            },
+            LuaMessage::Integer(i) => {
+                Some(vec!(LuaMessage::from(i)))
+            },
+            LuaMessage::Number(f) => {
+                Some(vec!(LuaMessage::from(f)))
+            },
+            LuaMessage::Boolean(b) => {
+                Some(vec!(LuaMessage::from(b)))
+            },
+            LuaMessage::Nil => {
+                None
+            },
+            LuaMessage::Table(_h) => {
+                let mut new_one = vec!();
+                for (_k, v) in _h.into_iter() {
+                    new_one.push(LuaMessage::from(_k));
+                    new_one.push(v);
+                }
+                Some(new_one)
+            },
+            LuaMessage::Array(_h) => {
+                Some(_h)
+            },
         }
     }
 }
@@ -202,8 +257,14 @@ impl<'lua> FromLua<'lua> for LuaMessage {
             Value::Boolean(b) => Ok(LuaMessage::Boolean(b)),
             Value::Nil => Ok(LuaMessage::Nil),
             Value::Table(t) => {
-                Ok(LuaMessage::Table(HashMap::from_lua(Value::Table(t), lua)?))
-            }
+                if t.len()? > 0
+                && t.clone().pairs::<i32, LuaMessage>().count() == t.clone().sequence_values::<LuaMessage>().count()
+                {
+                    Ok(LuaMessage::Array(Vec::from_lua(Value::Table(t), lua)?))
+                } else {
+                    Ok(LuaMessage::Table(HashMap::from_lua(Value::Table(t), lua)?))
+                }
+            },
 
             _ => unimplemented!(),
         }
@@ -219,6 +280,7 @@ impl<'lua> ToLua<'lua> for LuaMessage {
             LuaMessage::Boolean(x) => Ok(Value::Boolean(x)),
             LuaMessage::Nil => Ok(Value::Nil),
             LuaMessage::Table(x) => Ok(Value::Table(lua.create_table_from(x)?)),
+            LuaMessage::Array(x) => Ok(Value::Table(lua.create_sequence_from(x)?)),
 
             // You should not create RPCNotifyLater from outside of lua
             // _ => unimplemented!(),
@@ -317,5 +379,19 @@ mod tests {
             ),
             discriminant(&LuaMessage::Table(t))
         );
+
+        let t = vec!(LuaMessage::from(1),LuaMessage::from(2));
+        assert_eq!(
+            discriminant(
+                &LuaMessage::from_lua(
+                    Value::Table(lua.create_sequence_from(vec!(LuaMessage::from(1),LuaMessage::from(2))).unwrap()), &lua
+                ).unwrap()
+            ),
+            discriminant(&LuaMessage::Array(t.clone()))
+        );
+
+        // println!("{:?}\n{:?}", LuaMessage::Array(t.clone()), LuaMessage::from_lua(
+        //     Value::Table(lua.create_sequence_from(vec!(LuaMessage::from(12),LuaMessage::from(2))).unwrap()), &lua
+        // ).unwrap());
     }
 }
