Add From<Vec> and Into<Vec> support to MultiValue and Variadic types

Author: khvzak

src/multi.rs

@@ -124,6 +124,23 @@ impl MultiValue {
         MultiValue(VecDeque::with_capacity(capacity))
     }
 
+    /// Creates a `MultiValue` container from vector of values.
+    ///
+    /// This methods needs *O*(*n*) data movement if the circular buffer doesn't happen to be at the
+    /// beginning of the allocation.
+    #[inline]
+    pub fn from_vec(vec: Vec<Value>) -> MultiValue {
+        vec.into()
+    }
+
+    /// Consumes the `MultiValue` and returns a vector of values.
+    ///
+    /// This methods works in *O*(1) time and does not allocate any additional memory.
+    #[inline]
+    pub fn into_vec(self) -> Vec<Value> {
+        self.into()
+    }
+
     #[inline]
     pub(crate) fn from_lua_iter<T: IntoLua>(lua: &Lua, iter: impl IntoIterator<Item = T>) -> Result<Self> {
         let iter = iter.into_iter();
@@ -135,6 +152,20 @@ impl MultiValue {
     }
 }
 
+impl From<Vec<Value>> for MultiValue {
+    #[inline]
+    fn from(value: Vec<Value>) -> Self {
+        MultiValue(value.into())
+    }
+}
+
+impl From<MultiValue> for Vec<Value> {
+    #[inline]
+    fn from(value: MultiValue) -> Self {
+        value.0.into()
+    }
+}
+
 impl FromIterator<Value> for MultiValue {
     #[inline]
     fn from_iter<I: IntoIterator<Item = Value>>(iter: I) -> Self {
@@ -203,19 +234,46 @@ impl FromLuaMulti for MultiValue {
 /// # Ok(())
 /// # }
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Default, Debug, Clone)]
 pub struct Variadic<T>(Vec<T>);
 
 impl<T> Variadic<T> {
     /// Creates an empty `Variadic` wrapper containing no values.
     pub const fn new() -> Variadic<T> {
         Variadic(Vec::new())
     }
+
+    /// Creates an empty `Variadic` container with space for at least `capacity` elements.
+    pub fn with_capacity(capacity: usize) -> Variadic<T> {
+        Variadic(Vec::with_capacity(capacity))
+    }
+}
+
+impl<T> Deref for Variadic<T> {
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
 }
 
-impl<T> Default for Variadic<T> {
-    fn default() -> Variadic<T> {
-        const { Variadic::new() }
+impl<T> DerefMut for Variadic<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T> From<Vec<T>> for Variadic<T> {
+    #[inline]
+    fn from(vec: Vec<T>) -> Self {
+        Variadic(vec)
+    }
+}
+
+impl<T> From<Variadic<T>> for Vec<T> {
+    #[inline]
+    fn from(value: Variadic<T>) -> Self {
+        value.0
     }
 }
 
@@ -234,20 +292,6 @@ impl<T> IntoIterator for Variadic<T> {
     }
 }
 
-impl<T> Deref for Variadic<T> {
-    type Target = Vec<T>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<T> DerefMut for Variadic<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
 impl<T: IntoLua> IntoLuaMulti for Variadic<T> {
     #[inline]
     fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {

tests/multi.rs

@@ -1,4 +1,4 @@
-use mlua::{Error, ExternalError, IntoLuaMulti, Lua, Result, String, Value};
+use mlua::{Error, ExternalError, IntoLuaMulti, Lua, MultiValue, Result, String, Value, Variadic};
 
 #[test]
 fn test_result_conversions() -> Result<()> {
@@ -58,3 +58,28 @@ fn test_result_conversions() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_multivalue() {
+    let mut multi = MultiValue::with_capacity(3);
+    multi.push_back(Value::Integer(1));
+    multi.push_back(Value::Integer(2));
+    multi.push_front(Value::Integer(3));
+    assert_eq!(multi.iter().filter_map(|v| v.as_integer()).sum::<i64>(), 6);
+
+    let vec = multi.into_vec();
+    assert_eq!(&vec, &[Value::Integer(3), Value::Integer(1), Value::Integer(2)]);
+    let _multi2 = MultiValue::from_vec(vec);
+}
+
+#[test]
+fn test_variadic() {
+    let mut var = Variadic::with_capacity(3);
+    var.extend_from_slice(&[1, 2, 3]);
+    assert_eq!(var.iter().sum::<u32>(), 6);
+
+    let vec = Vec::<u32>::from(var);
+    assert_eq!(&vec, &[1, 2, 3]);
+    let var2 = Variadic::from(vec);
+    assert_eq!(var2.as_slice(), &[1, 2, 3]);
+}