1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
use fnv::FnvHasher;
use futures::lock::Mutex;
use once_cell::sync::OnceCell;
use std::{
any::{Any, TypeId},
cell::RefCell,
collections::HashMap,
hash::BuildHasherDefault,
};
use crate::{error::Result, lifecycle::LifeCycle, Actor, Addr};
/// Trait define a global service.
///
/// The service is a global actor.
/// You can use `Actor::from_registry` to get the address `Addr<A>` of the service.
///
/// # Examples
///
/// ```rust
/// use hannibal::*;
///
/// #[message(result = i32)]
/// struct AddMsg(i32);
///
/// #[derive(Default)]
/// struct MyService(i32);
///
/// impl Actor for MyService {}
///
/// impl Service for MyService {}
///
/// impl Handler<AddMsg> for MyService {
/// async fn handle(&mut self, ctx: &mut Context<Self>, msg: AddMsg) -> i32 {
/// self.0 += msg.0;
/// self.0
/// }
/// }
///
/// #[hannibal::main]
/// async fn main() -> Result<()> {
/// let mut addr = MyService::from_registry().await?;
/// assert_eq!(addr.call(AddMsg(1)).await?, 1);
/// assert_eq!(addr.call(AddMsg(5)).await?, 6);
/// Ok(())
/// }
/// ```
pub trait Service: Actor + Default {
fn from_registry() -> impl std::future::Future<Output = Result<Addr<Self>>> + Send {
async {
static REGISTRY: OnceCell<
Mutex<HashMap<TypeId, Box<dyn Any + Send>, BuildHasherDefault<FnvHasher>>>,
> = OnceCell::new();
let registry = REGISTRY.get_or_init(Default::default);
let mut registry = registry.lock().await;
match registry.get_mut(&TypeId::of::<Self>()) {
Some(addr) => Ok(addr.downcast_ref::<Addr<Self>>().unwrap().clone()),
None => {
let life_cycle = LifeCycle::new();
registry.insert(TypeId::of::<Self>(), Box::new(life_cycle.address()));
drop(registry);
life_cycle.start_actor(Self::default()).await
}
}
}
}
}
thread_local! {
static LOCAL_REGISTRY: RefCell<HashMap<TypeId, Box<dyn Any + Send>, BuildHasherDefault<FnvHasher>>> = RefCell::default();
}
/// Trait define a local service.
///
/// The service is a thread local actor.
/// You can use `Actor::from_registry` to get the address `Addr<A>` of the service.
pub trait LocalService: Actor + Default {
fn from_registry() -> impl std::future::Future<Output = Result<Addr<Self>>> + Send {
async {
let res = LOCAL_REGISTRY.with(|registry| {
registry
.borrow_mut()
.get_mut(&TypeId::of::<Self>())
.map(|addr| addr.downcast_ref::<Addr<Self>>().unwrap().clone())
});
match res {
Some(addr) => Ok(addr),
None => {
let addr = LifeCycle::new().start_actor(Self::default()).await?;
LOCAL_REGISTRY.with(|registry| {
registry
.borrow_mut()
.insert(TypeId::of::<Self>(), Box::new(addr.clone()));
});
Ok(addr)
}
}
}
}
}