Add TryFrom to convert from Varargs to tuples

godot-rust#886

Author: B-head

gdnative-core/src/export/method.rs

@@ -300,6 +300,117 @@ impl<'a> Iterator for Varargs<'a> {
     }
 }
 
+// Return a second token.
+macro_rules! replace_expr {
+    ($_t:tt $sub:expr) => {
+        $sub
+    };
+}
+
+// Count parameters.
+macro_rules! count_tts {
+    ($($tts:tt)*) => {
+        0usize $(+ replace_expr!($tts 1usize))*
+    };
+}
+
+// Convert from Varargs to tuples, implement traits.
+macro_rules! varargs_into_tuple {
+    ($($params:ident),*) => {
+        impl<'a, $($params: FromVariant),*> std::convert::TryFrom<Varargs<'a>> for ($($params,)*) {
+            type Error = VarargsError;
+
+            #[inline]
+            fn try_from(value: Varargs<'a>) -> Result<Self, Self::Error> {
+                const EXPECTED: usize = count_tts!($($params)*);
+                let args = &value.args;
+                if args.len() == EXPECTED {
+                    #[allow(unused_variables, unused_mut)]
+                    let mut i: usize = 0;
+                    #[allow(clippy::eval_order_dependence)]
+                    Ok((
+                        $({
+                            i += 1;
+                            $params::from_variant(args[i - 1])?
+                        },)*
+                    ))
+                } else {
+                    Err(ArgumentLengthError{
+                        passed: args.len(),
+                        expected: EXPECTED,
+                    }.into())
+                }
+            }
+        }
+    };
+}
+
+// Define up to the length supported by standard library.
+varargs_into_tuple!();
+varargs_into_tuple!(A);
+varargs_into_tuple!(A, B);
+varargs_into_tuple!(A, B, C);
+varargs_into_tuple!(A, B, C, D);
+varargs_into_tuple!(A, B, C, D, E);
+varargs_into_tuple!(A, B, C, D, E, F);
+varargs_into_tuple!(A, B, C, D, E, F, G);
+varargs_into_tuple!(A, B, C, D, E, F, G, H);
+varargs_into_tuple!(A, B, C, D, E, F, G, H, I);
+varargs_into_tuple!(A, B, C, D, E, F, G, H, I, J);
+varargs_into_tuple!(A, B, C, D, E, F, G, H, I, J, K);
+varargs_into_tuple!(A, B, C, D, E, F, G, H, I, J, K, L);
+
+/// All possible error types for convert from Varargs.
+#[derive(Debug)]
+pub enum VarargsError {
+    ArgumentLengthError(ArgumentLengthError),
+    FromVariantError(FromVariantError),
+}
+
+impl std::error::Error for VarargsError {}
+impl std::fmt::Display for VarargsError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self {
+            VarargsError::ArgumentLengthError(e) => e.fmt(f),
+            VarargsError::FromVariantError(e) => e.fmt(f),
+        }
+    }
+}
+
+impl From<ArgumentLengthError> for VarargsError {
+    #[inline]
+    fn from(value: ArgumentLengthError) -> Self {
+        Self::ArgumentLengthError(value)
+    }
+}
+
+impl From<FromVariantError> for VarargsError {
+    #[inline]
+    fn from(value: FromVariantError) -> Self {
+        Self::FromVariantError(value)
+    }
+}
+
+/// Error to argument lengths do not match.
+#[derive(Debug)]
+pub struct ArgumentLengthError {
+    passed: usize,
+    expected: usize,
+}
+
+impl std::error::Error for ArgumentLengthError {}
+impl std::fmt::Display for ArgumentLengthError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "Argument lengths do not match. passed {}, expected {}",
+            self.passed, self.expected
+        )
+    }
+}
+
 /// Trait for structures that can be parsed from `Varargs`.
 ///
 /// This trait can be derived for structure types where each type implements `FromVariant`.