add: more functions and macros

Author: Pure-Peace

src/macros.rs

@@ -1,13 +1,13 @@
 #[macro_export]
 macro_rules! pyo3_py_methods {
-    ($type:ident, impl {$($others:item)*}) => {
+    ($type:ident, impl {$($others:tt)*}) => {
         #[pymethods] impl $type {
             $($others)*
             #[getter]pub fn attrs(&self) -> String { self.as_string() }
             #[getter]pub fn attrs_dict<'a>(&self, py: Python<'a>) -> PyResult<&'a PyDict> { self.as_dict(py) }
         }
     };
-    ($type:ident, {$($attr:ident: $returns:ident),*}, impl {$($others:item)*}) => {
+    ($type:ident, {$($attr:ident: $returns:ident),*}, impl {$($others:tt)*}) => {
         #[pymethods] impl $type {
             $(#[getter]pub fn $attr(&self) -> $returns {self.0.$attr})* $($others)*
             #[getter]pub fn attrs(&self) -> String { self.as_string() }
@@ -29,7 +29,7 @@ macro_rules! pyo3_py_methods {
             #[getter]pub fn attrs_dict<'a>(&self, py: Python<'a>) -> PyResult<&'a PyDict> { self.as_dict(py) }
         }
     };
-    ($type:ident, {$($attr:ident: $returns:ident),*}; fn {$( $func:ident: $ret:ident),*}; impl {$($others:item)*}) => {
+    ($type:ident, {$($attr:ident: $returns:ident),*}; fn {$( $func:ident: $ret:ident),*}; impl {$($others:tt)*}) => {
         #[pymethods] impl $type {
             $(#[getter]pub fn $attr(&self) -> $returns {self.0.$attr})*
             $(#[getter]pub fn $func(&self) -> $ret {self.0.$func()})*
@@ -73,6 +73,13 @@ macro_rules! async_not_enabled_err {
     };
 }
 
+#[macro_export]
+macro_rules! invalid_gamemode_err {
+    () => {
+        crate::python::exceptions::InvalidGameMode::new_err("Invalid osu! gamemode")
+    };
+}
+
 #[macro_export]
 macro_rules! set_calculator {
     ($target:ident.$attr:ident, $calculator:ident) => {
@@ -123,3 +130,16 @@ macro_rules! pyo3_add_classes {
         $($m.add_class::<$class>()?;)*
     };
 }
+
+#[macro_export]
+macro_rules! set_with_py_str {
+    ($obj:ident, $attr:ident, $value:ident; {$($a:ident),*}) => {
+        match $attr {
+            $(stringify!($a) => $obj.$a = match $value {
+                Some(v) => v.extract()?,
+                None => None
+            },)*
+            _ => {}
+        }
+    };
+}

src/methods/common.rs

@@ -1,5 +1,5 @@
 use peace_performance::GameMode;
-use pyo3::PyErr;
+use pyo3::{PyAny, PyErr};
 use std::path::PathBuf;
 
 use std::fs::File as SyncFile;
@@ -64,6 +64,37 @@ pub fn osu_mode_int_str(mode: u8) -> String {
     .into()
 }
 
+#[inline(always)]
+pub fn str_into_osu_mode(str: &str) -> Result<GameMode, PyErr> {
+    Ok(match str {
+        "std" => GameMode::STD,
+        "taiko" => GameMode::TKO,
+        "ctb" => GameMode::CTB,
+        "mania" => GameMode::MNA,
+        _ => return Err(crate::invalid_gamemode_err!()),
+    })
+}
+
+#[inline(always)]
+pub fn int_into_osu_mode(int: u8) -> Result<GameMode, PyErr> {
+    Ok(match int {
+        0 => GameMode::STD,
+        1 => GameMode::TKO,
+        2 => GameMode::CTB,
+        3 => GameMode::MNA,
+        _ => return Err(crate::invalid_gamemode_err!()),
+    })
+}
+
+pub fn py_any_into_osu_mode(py_input: &PyAny) -> Result<GameMode, PyErr> {
+    if let Ok(str) = py_input.extract::<String>() {
+        return str_into_osu_mode(&str);
+    } else if let Ok(int) = py_input.extract::<u8>() {
+        return int_into_osu_mode(int);
+    }
+    Err(crate::invalid_gamemode_err!())
+}
+
 #[cfg(any(feature = "async_tokio", feature = "async_std"))]
 /// Async sleep
 #[inline(always)]

src/python/exceptions.rs

@@ -3,3 +3,4 @@ use pyo3::{create_exception, exceptions::PyException};
 create_exception!(peace_performance, ParseBeatmapError, PyException);
 create_exception!(peace_performance, ReadFileError, PyException);
 create_exception!(peace_performance, AsyncNotEnabledError, PyException);
+create_exception!(peace_performance, InvalidGameMode, PyException);

src/python/functions.rs

@@ -62,5 +62,5 @@ pub fn read_beatmap_async(_py: Python, _path: PathBuf) -> PyResult<&PyAny> {
 
 #[pyfunction]
 pub fn new_calculator() -> Calculator {
-    Calculator::new()
+    Calculator::new_empty()
 }