polyhorn_core/
hooks.rs

1use serde::{Deserialize, Serialize};
2use std::future::Future;
3
4use super::{Context, EffectLink, Key, Platform, Reference, State};
5
6#[macro_export]
7macro_rules! use_id {
8    () => {{
9        struct ID;
10        std::rc::Rc::new(std::any::TypeId::of::<ID>())
11    }};
12}
13
14pub trait UseState {
15    fn use_state<S>(&mut self, key: Key, initial_value: S) -> State<S>
16    where
17        S: Serialize + for<'b> Deserialize<'b> + 'static;
18}
19
20#[macro_export]
21macro_rules! use_state {
22    ($manager:expr) => {
23        use_state!($manager, Default::default())
24    };
25    ($manager:expr, $initial_value:expr) => {
26        $crate::UseState::use_state::<_>($manager, $crate::use_id!().into(), $initial_value)
27    };
28}
29
30pub trait UseReference {
31    fn use_reference<R, I>(&mut self, key: Key, initializer: I) -> Reference<R>
32    where
33        R: 'static,
34        I: FnOnce() -> R;
35}
36
37#[macro_export]
38macro_rules! use_reference {
39    ($manager:expr, $value:expr) => {
40        $crate::UseReference::use_reference($manager, $crate::use_id!().into(), || $value)
41    };
42}
43
44pub trait UseEffect<P>
45where
46    P: Platform + ?Sized,
47{
48    fn use_effect<F>(&mut self, key: Key, conditions: Option<Key>, effect: F)
49    where
50        F: FnOnce(&EffectLink<P>) + 'static;
51}
52
53#[macro_export]
54macro_rules! use_effect {
55    ($manager:expr, $effect:expr) => {
56        $crate::UseEffect::use_effect($manager, $crate::use_id!().into(), None, $effect)
57    };
58}
59
60pub trait UseLayoutEffect<P>
61where
62    P: Platform + ?Sized,
63{
64    fn use_layout_effect<F>(&mut self, key: Key, conditions: Option<Key>, effect: F)
65    where
66        F: FnOnce(&EffectLink<P>, &mut P::CommandBuffer) + 'static;
67}
68
69#[macro_export]
70macro_rules! use_layout_effect {
71    ($manager:expr, $effect:expr) => {
72        $crate::UseLayoutEffect::use_layout_effect(
73            $manager,
74            $crate::use_id!().into(),
75            None,
76            $effect,
77        )
78    };
79}
80
81pub trait UseAsync {
82    fn use_async<F>(&mut self, key: Key, task: F)
83    where
84        F: Future<Output = ()> + 'static;
85}
86
87#[macro_export]
88macro_rules! use_async {
89    ($manager:expr, $future:expr) => {
90        $crate::UseAsync::use_async($manager, $crate::use_id!().into(), $future)
91    };
92}
93
94pub trait UseContext {
95    fn use_context<T>(&mut self) -> Option<Context<T>>
96    where
97        T: 'static;
98}
99
100#[macro_export]
101macro_rules! use_context {
102    ($manager:expr) => {
103        $crate::UseContext::use_context($manager)
104    };
105}