use std::collections::BTreeMap;
use crate::error::{OpError, OpResult};
use crate::operator::Operator;
pub type OperatorConstructor = Box<dyn Fn() -> Box<dyn Operator> + Send + Sync + 'static>;
#[derive(Default)]
pub struct OperatorRegistry {
entries: BTreeMap<&'static str, OperatorConstructor>,
}
impl OperatorRegistry {
#[must_use]
pub fn new() -> Self {
Self {
entries: BTreeMap::new(),
}
}
pub fn from_entries(
entries: impl IntoIterator<Item = (&'static str, OperatorConstructor)>,
) -> OpResult<Self> {
let mut registry = Self::new();
for (name, constructor) in entries {
registry.register(name, constructor)?;
}
Ok(registry)
}
pub fn register(
&mut self,
name: &'static str,
constructor: OperatorConstructor,
) -> OpResult<()> {
if self.entries.contains_key(name) {
return Err(OpError::DuplicateOperator {
name: name.to_owned(),
});
}
self.entries.insert(name, constructor);
Ok(())
}
#[must_use]
pub fn contains(&self, name: &str) -> bool {
self.entries.contains_key(name)
}
pub fn names(&self) -> impl Iterator<Item = &'static str> + '_ {
self.entries.keys().copied()
}
#[must_use]
pub fn len(&self) -> usize {
self.entries.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn build(&self, name: &str) -> OpResult<Box<dyn Operator>> {
let constructor = self
.entries
.get(name)
.ok_or_else(|| OpError::UnknownOperator {
name: name.to_owned(),
})?;
Ok(constructor())
}
}
#[macro_export]
macro_rules! register_operator {
($ty:ty) => {
(
::core::stringify!($ty),
(Box::new(|| -> ::std::boxed::Box<dyn $crate::Operator> {
::std::boxed::Box::new(<$ty as ::core::default::Default>::default())
}) as $crate::OperatorConstructor),
)
};
($name:expr => $ty:ty) => {
(
$name,
(Box::new(|| -> ::std::boxed::Box<dyn $crate::Operator> {
::std::boxed::Box::new(<$ty as ::core::default::Default>::default())
}) as $crate::OperatorConstructor),
)
};
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use crate::event::OpEvent;
use crate::operator::Status;
use crate::output::OpOutput;
#[derive(Default)]
struct Alpha;
impl Operator for Alpha {
fn on_event(&mut self, _event: &OpEvent, _out: &mut OpOutput) -> OpResult<Status> {
Ok(Status::Continue)
}
}
#[derive(Default)]
struct Beta;
impl Operator for Beta {
fn on_event(&mut self, _event: &OpEvent, _out: &mut OpOutput) -> OpResult<Status> {
Ok(Status::Finished)
}
}
#[test]
fn register_operator_produces_the_stringified_name() {
let (name, ctor) = register_operator!(Alpha);
assert_eq!(name, "Alpha");
let mut op = ctor();
let mut out = OpOutput::new();
let status = op.on_event(&OpEvent::Reload, &mut out).unwrap();
assert_eq!(status, Status::Continue);
}
#[test]
fn register_operator_accepts_an_explicit_name() {
let (name, _ctor) = register_operator!("beta-v1" => Beta);
assert_eq!(name, "beta-v1");
}
#[test]
fn registry_lookup_and_registration() {
let mut registry = OperatorRegistry::new();
assert!(registry.is_empty());
let (name, ctor) = register_operator!(Alpha);
registry.register(name, ctor).unwrap();
assert_eq!(registry.len(), 1);
assert!(registry.contains("Alpha"));
assert!(!registry.contains("Beta"));
let mut op = registry.build("Alpha").unwrap();
let mut out = OpOutput::new();
assert_eq!(
op.on_event(&OpEvent::Reload, &mut out).unwrap(),
Status::Continue
);
}
#[test]
fn duplicate_registration_is_rejected() {
let mut registry = OperatorRegistry::new();
let (name, ctor) = register_operator!(Alpha);
registry.register(name, ctor).unwrap();
let (name2, ctor2) = register_operator!(Alpha);
let err = registry.register(name2, ctor2).unwrap_err();
match err {
OpError::DuplicateOperator { name } => assert_eq!(name, "Alpha"),
other => panic!("expected DuplicateOperator, got {other:?}"),
}
}
#[test]
fn unknown_operator_is_reported() {
let registry = OperatorRegistry::new();
match registry.build("nope") {
Err(OpError::UnknownOperator { name }) => assert_eq!(name, "nope"),
other => panic!("expected Err(UnknownOperator), got {}", other.is_ok()),
}
}
#[test]
fn from_entries_builds_a_multi_operator_table() {
let registry =
OperatorRegistry::from_entries([register_operator!(Alpha), register_operator!(Beta)])
.unwrap();
assert_eq!(registry.len(), 2);
let names: Vec<&str> = registry.names().collect();
assert_eq!(names, ["Alpha", "Beta"]);
let mut out = OpOutput::new();
let mut beta = registry.build("Beta").unwrap();
assert_eq!(
beta.on_event(&OpEvent::Reload, &mut out).unwrap(),
Status::Finished
);
}
#[test]
fn from_entries_rejects_duplicate_names_from_the_same_type() {
match OperatorRegistry::from_entries([register_operator!(Alpha), register_operator!(Alpha)])
{
Err(OpError::DuplicateOperator { name }) => assert_eq!(name, "Alpha"),
Ok(_) => panic!("expected a duplicate-name error"),
Err(other) => panic!(
"expected DuplicateOperator, got a different OpError variant instead: {other}"
),
}
}
}