Add workable version 001. Remain many tests.

Author: johnteee

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lua_actor"
-version = "0.1.2"
+version = "0.1.3"
 license = "MIT"
 authors = ["JunYi JohnTeee Lee <johnteee@gmail.com>"]
 include = ["src/**/*.rs", "Cargo.toml"]

src/actor.rs

@@ -1,48 +1,13 @@
 
-use rlua::Value::Integer;
 use std::sync::{Arc,Mutex};
 
 use fp_rust::{
     common::{RawFunc,},
     sync::{CountDownLatch},
     handler::{Handler,HandlerThread},
 };
-use rlua::{Lua,Value,FromLua,ToLua,UserData,Error,Error::RuntimeError,Function};
-
-#[derive(Clone)]
-pub struct TypeI8(i8);
-impl UserData for TypeI8 {
-}
-impl From<TypeI8> for i8 {
-    fn from(v: TypeI8) -> i8 {
-        v.0
-    }
-}
-// pub struct TypeI16(i16);
-// impl <'lua> ToLua<'lua> for TypeI16 {
-//
-// }
-// pub struct TypeI32(i32);
-// impl <'lua> ToLua<'lua> for TypeI32 {
-//
-// }
-// pub struct TypeI64(i64);
-// impl <'lua> ToLua<'lua> for TypeI64 {
-//
-// }
-// pub struct TypeI128(i128);
-// impl <'lua> ToLua<'lua> for TypeI128 {
-//
-// }
-//
-// pub struct TypeF32(f32);
-// impl <'lua> ToLua<'lua> for TypeF32 {
-//
-// }
-// pub struct TypeF64(f64);
-// impl <'lua> ToLua<'lua> for TypeF64 {
-//
-// }
+use rlua::{Lua,Error,Error::RuntimeError,Function};
+use message::LuaMessage;
 
 #[derive(Clone)]
 pub struct Actor {
@@ -74,7 +39,7 @@ impl Actor {
         self.lua.clone()
     }
 
-    pub fn set_global<T: UserData + Send + Sync + Clone>(&self, key: String, value: T) -> Result<(), Error> {
+    pub fn set_global(&self, key: String, value: LuaMessage) -> Result<(), Error> {
         match self.handler.clone() {
             Some(_handler) => {
                 let lua = self.lua.clone();
@@ -89,17 +54,17 @@ impl Actor {
             }
         }
     }
-    fn _set_global<T: UserData + Send>(lua: Arc<Mutex<Lua>>, key: String, value: T) -> Result<(), Error> {
+    fn _set_global(lua: Arc<Mutex<Lua>>, key: String, value: LuaMessage) -> Result<(), Error> {
         let vm = lua.lock().unwrap();
         let globals = vm.globals();
         Ok(globals.set(key, value)?)
     }
 
-    pub fn get_global<T: UserData + Send + Clone>(&self, key: String) -> Result<T, Error> {
+    pub fn get_global(&self, key: String) -> Result<LuaMessage, Error> {
         match self.handler.clone() {
             Some(_handler) => {
-                let _result : Arc<Mutex<Result<T, Error>>> = Arc::new(Mutex::new(Err(RuntimeError(String::from("")))));
-                let result : Arc<Mutex<Result<T, Error>>> = _result.clone();
+                let _result : Arc<Mutex<Result<LuaMessage, Error>>> = Arc::new(Mutex::new(Err(RuntimeError(String::from("")))));
+                let result : Arc<Mutex<Result<LuaMessage, Error>>> = _result.clone();
                 let lua = self.lua.clone();
 
                 let done_latch = CountDownLatch::new(1);
@@ -136,10 +101,10 @@ impl Actor {
             },
         }
     }
-    fn _get_global<T: UserData + Clone>(lua: Arc<Mutex<Lua>>, key: String) -> Result<T, Error> {
+    fn _get_global(lua: Arc<Mutex<Lua>>, key: String) -> Result<LuaMessage, Error> {
         let vm = lua.lock().unwrap();
         let globals = vm.globals();
-        Ok(globals.get::<_, T>(key)?)
+        Ok(globals.get::<_, LuaMessage>(key)?)
     }
 
     pub fn load(&self, source: &'static str, name: Option<&'static str>) -> Result<(), Error> {
@@ -157,19 +122,19 @@ impl Actor {
             }
         }
     }
-    pub fn _load(lua: Arc<Mutex<Lua>>, source: &str, name: Option<&str>) -> Result<(), Error> {
+    fn _load(lua: Arc<Mutex<Lua>>, source: &str, name: Option<&str>) -> Result<(), Error> {
         let vm = lua.lock().unwrap();
         vm.load(source, name)?;
         Ok(())
     }
     // pub fn _load<'lua>(vm: &'lua Lua, source: &str, name: Option<&str>) -> Result<Function<'lua>, Error> {
     //     Ok(vm.load(source, name)?)
     // }
-    pub fn exec<T: UserData + Send + Clone>(&self, source: &'static str, name: Option<&'static str>) -> Result<T, Error> {
+    pub fn exec(&self, source: &'static str, name: Option<&'static str>) -> Result<LuaMessage, Error> {
         match self.handler.clone() {
             Some(_handler) => {
-                let _result : Arc<Mutex<Result<T, Error>>> = Arc::new(Mutex::new(Err(RuntimeError(String::from("")))));
-                let result : Arc<Mutex<Result<T, Error>>> = _result.clone();
+                let _result : Arc<Mutex<Result<LuaMessage, Error>>> = Arc::new(Mutex::new(Err(RuntimeError(String::from("")))));
+                let result : Arc<Mutex<Result<LuaMessage, Error>>> = _result.clone();
                 let lua = self.lua.clone();
 
                 let done_latch = CountDownLatch::new(1);
@@ -202,29 +167,66 @@ impl Actor {
             }
         }
     }
-    pub fn _exec<T: UserData + Clone>(lua: Arc<Mutex<Lua>>, source: &str, name: Option<&str>) -> Result<T, Error> {
+    fn _exec(lua: Arc<Mutex<Lua>>, source: &str, name: Option<&str>) -> Result<LuaMessage, Error> {
         let vm = lua.lock().unwrap();
         Ok(vm.exec(source, name)?)
     }
 
-    pub fn _call<T: UserData + Clone, X: UserData + Send>(lua: Arc<Mutex<Lua>>, name: String, args: X) -> Result<T, Error> {
+    pub fn call(&self, name: String, args: LuaMessage) -> Result<LuaMessage, Error> {
+        match self.handler.clone() {
+            Some(_handler) => {
+                let _result : Arc<Mutex<Result<LuaMessage, Error>>> = Arc::new(Mutex::new(Err(RuntimeError(String::from("")))));
+                let result : Arc<Mutex<Result<LuaMessage, Error>>> = _result.clone();
+                let lua = self.lua.clone();
+
+                let done_latch = CountDownLatch::new(1);
+
+                let done_latch2 = done_latch.clone();
+                _handler.lock().unwrap().post(RawFunc::new(move ||{
+                    let lua = lua.clone();
+                    {
+                        (*result.lock().unwrap()) = Self::_call(lua, name.clone(), args.clone());
+                    }
+                    done_latch2.countdown();
+                }));
+
+                done_latch.wait();
+
+                {
+                    let _result = &*_result.lock().unwrap();
+                    match _result {
+                        Ok(_result) => {
+                            Ok(_result.clone())
+                        },
+                        Err(_err) => {
+                            Err(_err.clone())
+                        }
+                    }
+                }
+            },
+            None => {
+                Self::_call(self.lua.clone(), name, args)
+            }
+        }
+    }
+    pub fn _call(lua: Arc<Mutex<Lua>>, name: String, args: LuaMessage) -> Result<LuaMessage, Error> {
         let vm = lua.lock().unwrap();
         let func: Function = vm.globals().get(name)?;
-        Ok(func.call::<_, T>(args)?)
+        Ok(func.call::<_, LuaMessage>(args)?)
     }
 }
 
 #[test]
-fn test_handler_new() {
+fn test_actor_new() {
     use std::time;
     use std::thread;
 
     let act = Actor::new_with_handler(None);
 
-    let i: TypeI8 = act.exec(r#"
-        let i = 1
-        return 1
-    "#, None).ok().unwrap_or(TypeI8(0));
+    // let i: LuaMessage = act.exec(r#"
+    //     let i = 1
+    //     return "1"
+    // "#, None).ok().unwrap_or(LuaMessage::String(String::from("")));
     // assert_eq!(30, i8::from(i));
 
     thread::sleep(time::Duration::from_millis(100));