use std::collections::HashMap;
use crate::{ServiceError, Value};
pub trait Service: Send + Sync {
fn call(&self, method: &str, args: &[Value]) -> Result<Value, ServiceError>;
}
#[derive(Default)]
pub struct ServiceRegistry {
services: HashMap<String, Box<dyn Service>>,
}
impl ServiceRegistry {
#[must_use]
pub fn new() -> Self {
Self {
services: HashMap::new(),
}
}
pub fn register(
&mut self,
domain: &str,
service: Box<dyn Service>,
) -> Result<(), ServiceError> {
let domain = domain.to_owned();
if self.services.contains_key(&domain) {
return Err(ServiceError::Internal(format!(
"service domain '{domain}' is already registered"
)));
}
self.services.insert(domain, service);
Ok(())
}
pub fn get(&self, domain: &str) -> Result<&dyn Service, ServiceError> {
self.services
.get(domain)
.map(std::convert::AsRef::as_ref)
.ok_or_else(|| ServiceError::DomainNotFound(domain.into()))
}
#[must_use]
pub fn has(&self, domain: &str) -> bool {
self.services.contains_key(domain)
}
pub fn unregister(&mut self, domain: &str) -> Option<Box<dyn Service>> {
self.services.remove(domain)
}
#[must_use]
pub fn len(&self) -> usize {
self.services.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.services.is_empty()
}
pub fn domains(&self) -> impl Iterator<Item = &str> {
self.services.keys().map(std::string::String::as_str)
}
}
#[cfg(test)]
mod tests {
use super::*;
struct TestService;
impl Service for TestService {
fn call(&self, method: &str, _args: &[Value]) -> Result<Value, ServiceError> {
match method {
"ping" => Ok(Value::String("pong".into())),
_ => Err(ServiceError::UnknownMethod(method.into())),
}
}
}
#[test]
fn test_register_and_get() {
let mut registry = ServiceRegistry::new();
registry.register("test", Box::new(TestService)).unwrap();
let svc = registry.get("test").unwrap();
let result = svc.call("ping", &[]).unwrap();
assert_eq!(result, Value::String("pong".into()));
}
#[test]
fn test_get_unknown_domain() {
let registry = ServiceRegistry::new();
let result = registry.get("nonexistent");
assert!(result.is_err());
}
#[test]
fn test_register_duplicate() {
let mut registry = ServiceRegistry::new();
registry.register("test", Box::new(TestService)).unwrap();
let err = registry.register("test", Box::new(TestService)).unwrap_err();
assert!(matches!(err, ServiceError::Internal(..)));
}
#[test]
fn test_has() {
let mut registry = ServiceRegistry::new();
assert!(!registry.has("test"));
registry.register("test", Box::new(TestService)).unwrap();
assert!(registry.has("test"));
}
#[test]
fn test_unregister() {
let mut registry = ServiceRegistry::new();
registry.register("test", Box::new(TestService)).unwrap();
assert!(registry.unregister("test").is_some());
assert!(!registry.has("test"));
}
#[test]
fn test_domains_iter() {
let mut registry = ServiceRegistry::new();
registry.register("a", Box::new(TestService)).unwrap();
registry.register("b", Box::new(TestService)).unwrap();
let domains: Vec<&str> = registry.domains().collect();
assert_eq!(domains.len(), 2);
assert!(domains.contains(&"a"));
assert!(domains.contains(&"b"));
}
}