use crate::{
DynamicScriptFunction, docgen::typed_through::ThroughTypeInfo, error::InteropError,
script_value::ScriptValue,
};
use bevy_ecs::resource::Resource;
use bevy_mod_scripting_world::WorldGuard;
use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
use std::{borrow::Cow, collections::BTreeMap, sync::Arc};
pub mod catalogue;
pub mod core;
pub use catalogue::*;
pub use core::*;
pub struct NamespaceMembers;
pub type NamespaceValueMaker =
dyn Fn(WorldGuard) -> Result<ScriptValue, InteropError> + 'static + Send + Sync;
#[derive(Clone)]
pub struct NamespaceValue {
pub maker: Arc<NamespaceValueMaker>,
pub type_information: ThroughTypeInfo,
pub documentation: Option<Cow<'static, str>>,
}
#[derive(Default, Clone)]
pub struct NamespaceContents {
pub functions: BTreeMap<Cow<'static, str>, DynamicScriptFunction>,
pub values: BTreeMap<Cow<'static, str>, NamespaceValue>,
}
#[derive(Default)]
pub struct ScriptNamespaceMembers {
namespaces: BTreeMap<Cow<'static, str>, NamespaceContents>,
}
impl ScriptNamespaceMembers {
pub fn register_function(
&mut self,
namespace: impl Into<Cow<'static, str>>,
name: impl Into<Cow<'static, str>>,
function: DynamicScriptFunction,
) {
self.namespaces
.entry(namespace.into())
.or_default()
.functions
.insert(name.into(), function);
}
pub fn register_value(
&mut self,
namespace: impl Into<Cow<'static, str>>,
name: impl Into<Cow<'static, str>>,
value: NamespaceValue,
) {
self.namespaces
.entry(namespace.into())
.or_default()
.values
.insert(name.into(), value);
}
pub fn get(&self, namespace: &str) -> Option<&NamespaceContents> {
self.namespaces.get(namespace)
}
pub fn iter(&self) -> impl Iterator<Item = (&Cow<'static, str>, &NamespaceContents)> {
self.namespaces.iter()
}
}
#[derive(Default, Resource, Clone)]
pub struct AppScriptNamespaceMembers(Arc<RwLock<ScriptNamespaceMembers>>);
#[profiling::all_functions]
impl AppScriptNamespaceMembers {
pub fn read(&self) -> RwLockReadGuard<'_, ScriptNamespaceMembers> {
self.0.read()
}
pub fn write(&self) -> RwLockWriteGuard<'_, ScriptNamespaceMembers> {
self.0.write()
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::{docgen::TypedThrough, function::script_function::DynamicScriptFunction};
#[test]
fn members_are_grouped_by_namespace() {
let mut members = ScriptNamespaceMembers::default();
let function: DynamicScriptFunction = (|_, _| ScriptValue::Unit).into();
members.register_function("my_game", "spawn", function);
members.register_value(
"my_game",
"difficulty",
NamespaceValue {
maker: Arc::new(|_| Ok(ScriptValue::Integer(1))),
type_information: i64::through_type_info(),
documentation: None,
},
);
let contents = members.get("my_game").expect("namespace exists");
assert!(contents.functions.contains_key("spawn"));
assert!(contents.values.contains_key("difficulty"));
assert!(members.get("other").is_none());
}
}