185 lines
8.4 KiB
Rust
185 lines
8.4 KiB
Rust
/// Macro to adapt a Rust function taking a specific integer type (e.g., u32)
|
|
/// to a Rhai function that expects an i64 argument.
|
|
#[macro_export]
|
|
macro_rules! adapt_rhai_i64_input_fn {
|
|
($rust_fn:path, $rust_int_ty:ty) => {
|
|
move |context: ::rhai::NativeCallContext, rhai_val: i64| -> Result<_, Box<::rhai::EvalAltResult>> {
|
|
let rust_val: $rust_int_ty = rhai_val.try_into().map_err(|_e| {
|
|
Box::new(::rhai::EvalAltResult::ErrorArithmetic(
|
|
format!("Conversion error for arg in '{}' from i64 to {}", stringify!($rust_fn), stringify!($rust_int_ty)),
|
|
context.position(),
|
|
))
|
|
})?;
|
|
Ok($rust_fn(rust_val))
|
|
}
|
|
};
|
|
}
|
|
|
|
/// Macro to adapt a Rust instance method (taking self by value, one int arg, returns Self)
|
|
/// to a Rhai function that expects an i64 for that integer argument.
|
|
#[macro_export]
|
|
macro_rules! adapt_rhai_i64_input_method {
|
|
($struct_ty:ty, $rust_method_name:ident, $rust_int_ty:ty) => {
|
|
move |context: ::rhai::NativeCallContext, instance: $struct_ty, rhai_val: i64| -> Result<$struct_ty, Box<::rhai::EvalAltResult>> {
|
|
let rust_val: $rust_int_ty = rhai_val.try_into().map_err(|_e| {
|
|
Box::new(::rhai::EvalAltResult::ErrorArithmetic(
|
|
format!("Conversion error for arg in '{}::{}' from i64 to {}", stringify!($struct_ty), stringify!($rust_method_name), stringify!($rust_int_ty)),
|
|
context.position(),
|
|
))
|
|
})?;
|
|
Ok(instance.$rust_method_name(rust_val))
|
|
}
|
|
};
|
|
}
|
|
|
|
// --- Rhai Timestamp Helper Functions ---
|
|
pub mod rhai_timestamp_helpers {
|
|
use rhai::{INT, EvalAltResult, Position};
|
|
use chrono::{DateTime, Utc, TimeZone};
|
|
|
|
pub fn datetime_to_rhai_timestamp(dt: &DateTime<Utc>) -> INT {
|
|
dt.timestamp()
|
|
}
|
|
|
|
pub fn option_datetime_to_rhai_timestamp(dt_opt: &Option<DateTime<Utc>>) -> Option<INT> {
|
|
dt_opt.as_ref().map(datetime_to_rhai_timestamp)
|
|
}
|
|
|
|
pub fn rhai_timestamp_to_datetime(ts: INT) -> Result<DateTime<Utc>, Box<EvalAltResult>> {
|
|
Utc.timestamp_opt(ts, 0).single()
|
|
.ok_or_else(|| Box::new(EvalAltResult::ErrorArithmetic(format!("Invalid Unix timestamp: {}", ts), Position::NONE)))
|
|
}
|
|
|
|
pub fn option_rhai_timestamp_to_datetime(ts_opt: Option<INT>) -> Result<Option<DateTime<Utc>>, Box<EvalAltResult>> {
|
|
match ts_opt {
|
|
Some(ts) => rhai_timestamp_to_datetime(ts).map(Some),
|
|
None => Ok(None),
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Macro for Enum Accessors (String Conversion) ---
|
|
#[macro_export]
|
|
macro_rules! register_rhai_enum_accessors {
|
|
($engine:expr, $struct_type:ty, $field_name:ident, $rhai_name:expr, $to_string_fn:path, $from_string_fn:path) => {
|
|
$engine.register_get_set(
|
|
$rhai_name,
|
|
move |obj: &mut $struct_type| -> rhai::ImmutableString { $to_string_fn(&obj.$field_name) },
|
|
move |obj: &mut $struct_type, val: rhai::ImmutableString| -> Result<(), Box<rhai::EvalAltResult>> {
|
|
obj.$field_name = $from_string_fn(val.as_str())?;
|
|
Ok(())
|
|
}
|
|
);
|
|
};
|
|
}
|
|
|
|
// --- Macro for DateTime Accessors (Unix Timestamp INT) ---
|
|
#[macro_export]
|
|
macro_rules! register_rhai_datetime_accessors {
|
|
($engine:expr, $struct_type:ty, $field_path:ident, $rhai_name:expr, _required) => {
|
|
$engine.register_get_set(
|
|
$rhai_name,
|
|
move |obj: &mut $struct_type| -> rhai::INT {
|
|
let field_value = &obj.$field_path;
|
|
$crate::rhai_timestamp_helpers::datetime_to_rhai_timestamp(field_value)
|
|
},
|
|
move |obj: &mut $struct_type, val: rhai::INT| -> Result<(), Box<rhai::EvalAltResult>> {
|
|
obj.$field_path = $crate::rhai_timestamp_helpers::rhai_timestamp_to_datetime(val)?;
|
|
Ok(())
|
|
}
|
|
);
|
|
};
|
|
($engine:expr, $struct_type:ty, base_data.$field_name:ident, $rhai_name:expr, _required) => {
|
|
$engine.register_get_set(
|
|
$rhai_name,
|
|
move |obj: &mut $struct_type| -> rhai::INT {
|
|
let field_value = &obj.base_data.$field_name;
|
|
$crate::rhai_timestamp_helpers::datetime_to_rhai_timestamp(field_value)
|
|
},
|
|
move |obj: &mut $struct_type, val: rhai::INT| -> Result<(), Box<rhai::EvalAltResult>> {
|
|
obj.base_data.$field_name = $crate::rhai_timestamp_helpers::rhai_timestamp_to_datetime(val)?;
|
|
Ok(())
|
|
}
|
|
);
|
|
};
|
|
($engine:expr, $struct_type:ty, $field_path:ident, $rhai_name:expr) => {
|
|
$engine.register_get_set(
|
|
$rhai_name,
|
|
move |obj: &mut $struct_type| -> Option<rhai::INT> {
|
|
let field_value = &obj.$field_path;
|
|
$crate::rhai_timestamp_helpers::option_datetime_to_rhai_timestamp(field_value)
|
|
},
|
|
move |obj: &mut $struct_type, val_opt: Option<rhai::INT>| -> Result<(), Box<rhai::EvalAltResult>> {
|
|
obj.$field_path = $crate::rhai_timestamp_helpers::option_rhai_timestamp_to_datetime(val_opt)?;
|
|
Ok(())
|
|
}
|
|
);
|
|
};
|
|
($engine:expr, $struct_type:ty, base_data.$field_name:ident, $rhai_name:expr) => {
|
|
$engine.register_get_set(
|
|
$rhai_name,
|
|
move |obj: &mut $struct_type| -> Option<rhai::INT> {
|
|
let field_value = &obj.base_data.$field_name;
|
|
$crate::rhai_timestamp_helpers::option_datetime_to_rhai_timestamp(field_value)
|
|
},
|
|
move |obj: &mut $struct_type, val_opt: Option<rhai::INT>| -> Result<(), Box<rhai::EvalAltResult>> {
|
|
obj.base_data.$field_name = $crate::rhai_timestamp_helpers::option_rhai_timestamp_to_datetime(val_opt)?;
|
|
Ok(())
|
|
}
|
|
);
|
|
};
|
|
}
|
|
|
|
// --- Macro for Vec<String> Accessors ---
|
|
#[macro_export]
|
|
macro_rules! register_rhai_vec_string_accessors {
|
|
($engine:expr, $struct_type:ty, $field_name:ident, $rhai_name:expr) => {
|
|
$engine.register_get_set(
|
|
$rhai_name,
|
|
move |obj: &mut $struct_type| -> rhai::Array {
|
|
obj.$field_name.iter().map(|s| rhai::Dynamic::from(rhai::ImmutableString::from(s.as_str()))).collect()
|
|
},
|
|
move |obj: &mut $struct_type, val: rhai::Array| {
|
|
obj.$field_name = val.into_iter().map(|d| d.into_string().unwrap_or_default()).collect();
|
|
}
|
|
);
|
|
};
|
|
}
|
|
|
|
// --- Macro for Generic Field Accessors (Example: ImmutableString) ---
|
|
#[macro_export]
|
|
macro_rules! register_rhai_field_accessors {
|
|
($engine:expr, $struct_type:ty, $field_name:ident, $rhai_name:expr) => {
|
|
$engine.register_get_set(
|
|
$rhai_name,
|
|
move |obj: &mut $struct_type| obj.$field_name.clone(), // Assuming cloneable and directly Rhai compatible
|
|
move |obj: &mut $struct_type, val: rhai::Dynamic| { // Or specific type like ImmutableString
|
|
// This part would need more specific handling based on expected type
|
|
// For example, if it's always ImmutableString:
|
|
// if let Ok(s) = val.into_immutable_string() { obj.$field_name = s.into_owned(); }
|
|
// For now, let's assume it's a type that can be directly assigned from Dynamic if Dynamic holds the right type
|
|
// This is a simplification; real use might need obj.$field_name = val.try_cast().unwrap_or_default();
|
|
// However, register_get_set usually infers setter type from getter type.
|
|
// If getter is T, setter is fn(&mut S, T)
|
|
// So if getter is |obj| obj.field.clone() -> String, setter should be |obj, val: String|
|
|
// Let's assume string for now if using ImmutableString for Rhai
|
|
if let Ok(s_val) = val.into_immutable_string() {
|
|
obj.$field_name = s_val.into(); // Assumes field_name is String
|
|
} else {
|
|
// Handle error or default
|
|
eprintln!("Failed to cast for field {}", $rhai_name);
|
|
}
|
|
}
|
|
);
|
|
};
|
|
($engine:expr, $struct_type:ty, $field_name:ident, $rhai_name:expr, $rhai_type:ty) => {
|
|
$engine.register_get_set(
|
|
$rhai_name,
|
|
move |obj: &mut $struct_type| obj.$field_name.clone(),
|
|
move |obj: &mut $struct_type, val: $rhai_type| {
|
|
obj.$field_name = val;
|
|
}
|
|
);
|
|
};
|
|
}
|