Improve Tuple Variadic params and Tuple as Array

johnteee · johnteee · commit bb731d808693 · 2021-07-26T22:08:52.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lua_actor"
-version = "0.2.3"
+version = "0.2.4"
 license = "MIT"
 authors = ["JunYi JohnTeee Lee <johnteee@gmail.com>"]
 include = ["src/**/*.rs", "Cargo.toml"]
diff --git a/src/actor.rs b/src/actor.rs
@@ -396,10 +396,12 @@ fn test_actor_new() {
             "testlist",
             // Vec::<LuaMessage>::from_iter([3.into(), 2.into()]).into(),
             // LuaMessage::from_iter([3.into(), 2.into()]),
-            LuaMessage::from_slice([3, 2]),
+            // LuaMessage::from_slice([3, 2]),
+            // LuaMessage::from((3, 2.0, "", vec![4, 5])),
+            ((3, 2.0, "", vec![4, 5]),), // <= This is an array
         ) {
             Ok(_v) => {
-                assert_eq!(Some(2), Option::from(_v));
+                assert_eq!(Some(4), Option::from(_v));
             }
             Err(_err) => {
                 println!("{:?}", _err);
@@ -421,7 +423,7 @@ fn test_actor_new() {
             // Variadic::<LuaMessage>::from_iter([6.into(), 7.into()]),
             // Vec::<LuaMessage>::from([6.into(), 7.into()]),
             // MultiLuaMessage::from_slice([6, 7]),
-            (6, 7.0, ""),
+            (6, 7.0, "", vec![8, 9]), // <= Variadic params
         ) {
             Ok(_v) => {
                 assert_eq!(Some(13), Option::from(_v));
diff --git a/src/message.rs b/src/message.rs
@@ -17,7 +17,7 @@ pub enum LuaMessage {
     Boolean(bool),
     Nil,
     Table(HashMap<String, LuaMessage>),
-    Array(Vec<LuaMessage>),
+    Array(VecDeque<LuaMessage>),
     Variadic(VariadicLuaMessage),
 }
 
@@ -310,12 +310,12 @@ impl From<LuaMessage> for Option<HashMap<String, LuaMessage>> {
 }
 impl From<Vec<LuaMessage>> for LuaMessage {
     fn from(s: Vec<LuaMessage>) -> Self {
-        LuaMessage::Array(s)
+        LuaMessage::Array(VecDeque::from(s))
     }
 }
 impl FromIterator<LuaMessage> for LuaMessage {
     fn from_iter<I: IntoIterator<Item = LuaMessage>>(iter: I) -> Self {
-        LuaMessage::Array(Vec::<LuaMessage>::from_iter(iter))
+        LuaMessage::Array(VecDeque::<LuaMessage>::from_iter(iter))
     }
 }
 /*
@@ -341,7 +341,7 @@ impl From<LuaMessage> for Option<Vec<LuaMessage>> {
                 }
                 Some(new_one)
             }
-            LuaMessage::Array(_h) => Some(_h),
+            LuaMessage::Array(_h) => Some(_h.into()),
             LuaMessage::Variadic(_h) => Some(_h.0.into()),
         }
     }
@@ -374,7 +374,10 @@ impl<'lua> FromLua<'lua> for LuaMessage {
                     && t.clone().pairs::<i32, LuaMessage>().count()
                         == t.clone().sequence_values::<LuaMessage>().count()
                 {
-                    Ok(LuaMessage::Array(Vec::from_lua(Value::Table(t), lua)?))
+                    Ok(LuaMessage::Array(VecDeque::from(Vec::from_lua(
+                        Value::Table(t),
+                        lua,
+                    )?)))
                 } else {
                     Ok(LuaMessage::Table(HashMap::from_lua(Value::Table(t), lua)?))
                 }
@@ -497,22 +500,47 @@ macro_rules! impl_tuple {
                 MultiLuaMessage::from_iter([])
             }
         }
+        impl Into<LuaMessage> for () {
+            fn into(self) -> LuaMessage {
+                LuaMessage::from_iter([])
+            }
+        }
     );
 
     ($last:ident $($name:ident)*) => (
         impl<$($name,)* $last> Into<MultiLuaMessage> for ($($name,)* $last,)
             where $($name: Into<LuaMessage>,)*
                   $last: Into<MultiLuaMessage>
         {
-            #[allow(unused_mut)]
-            #[allow(unused_variables)]
             #[allow(non_snake_case)]
             fn into(self) -> MultiLuaMessage {
                 let ($($name,)* $last,) = self;
 
-                let mut results = $last.into();
-                push_reverse!(results, $($name.into(),)*);
-                results
+                let mut v = MultiLuaMessage::from_iter([]);
+                let lastOne = $last.into().0;
+                v.push_front(lastOne);
+                push_reverse!(v, $($name.into(),)*);
+
+                // println!("{:?}", v);
+                v
+            }
+        }
+        impl<$($name,)* $last> From<($($name,)* $last,)> for LuaMessage
+            where $($name: Into<LuaMessage>,)*
+                  $last: Into<LuaMessage>
+        {
+            #[allow(non_snake_case)]
+            fn from(s: ($($name,)* $last,)) -> LuaMessage {
+                let ($($name,)* $last,) = s;
+
+                let last_instance = $last.into();
+
+                let mut v = VecDeque::<LuaMessage>::from_iter([]);
+                v.push_front(last_instance);
+                push_reverse!(v, $($name.into(),)*);
+
+                // println!("{:?}", v);
+                LuaMessage::Array(v)
             }
         }
     );
@@ -661,7 +689,7 @@ mod tests {
                     )
                     .unwrap()
                 ),
-                discriminant(&LuaMessage::Array(t.clone()))
+                discriminant(&LuaMessage::Array(VecDeque::from(t.clone())))
             );
 
             // println!("{:?}\n{:?}", LuaMessage::Array(t.clone()), LuaMessage::from_lua(
