Dioxusのuse_signalについて

#[track_caller]
pub fn use_hook<State: Clone + 'static>(initializer: impl FnOnce() -> State) -> State {
    Runtime::with_current_scope(|cx| cx.use_hook(initializer)).unwrap()
}

pub struct InnerCustomState(usize);

impl Drop for InnerCustomState {
    fn drop(&mut self) {
        println!("Component has been dropped.");
    }
}

#[derive(Clone, Copy)]
pub struct CustomState {
    inner: Signal<InnerCustomState>,
}

pub fn use_custom_state() -> CustomState {
    use_hook(|| CustomState {
        inner: Signal::new(InnerCustomState(0))
    })
}

#[doc = include_str!("../docs/rules_of_hooks.md")]
pub fn use_callback<T: 'static, O: 'static>(f: impl FnMut(T) -> O + 'static) -> Callback<T, O> {
    let mut callback = Some(f);

    // Create a copyvalue with no contents
    // This copyvalue is generic over F so that it can be sized properly
    let mut inner = use_hook(|| Callback::new(callback.take().unwrap()));

    if let Some(callback) = callback.take() {
        // Every time this hook is called replace the inner callback with the new callback
        inner.replace(Box::new(callback));
    }

    inner
}

pub struct Callback<Args = (), Ret = ()> {
    pub(crate) origin: ScopeId,
    /// During diffing components with EventHandler, we move the EventHandler over in place instead of rerunning the child component.
    ///
    /// ```rust
    /// # use dioxus::prelude::*;
    /// #[component]
    /// fn Child(onclick: EventHandler<MouseEvent>) -> Element {
    ///     rsx! {
    ///         button {
    ///             // Diffing Child will not rerun this component, it will just update the callback in place so that if this callback is called, it will run the latest version of the callback
    ///             onclick: move |evt| onclick(evt),
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// This is both more efficient and allows us to avoid out of date EventHandlers.
    ///
    /// We double box here because we want the data to be copy (GenerationalBox) and still update in place (ExternalListenerCallback)
    /// This isn't an ideal solution for performance, but it is non-breaking and fixes the issues described in <https://github.com/DioxusLabs/dioxus/pull/2298>
    pub(super) callback: GenerationalBox<Option<ExternalListenerCallback<Args, Ret>>>,
}

impl<Args, Ret> std::fmt::Debug for Callback<Args, Ret> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Callback")
            .field("origin", &self.origin)
            .field("callback", &self.callback)
            .finish()
    }
}

impl<T: 'static, Ret: Default + 'static> Default for Callback<T, Ret> {
    fn default() -> Self {
        Callback::new(|_| Ret::default())
    }
}

pub(super) struct ExternalListenerCallback<Args, Ret> {
    callback: Box<dyn FnMut(Args) -> Ret>,
    runtime: std::rc::Weak<Runtime>,
}

if let Some(callback) = callback.take() {
        // Every time this hook is called replace the inner callback with the new callback
        inner.replace(Box::new(callback));
    }

pub struct GenerationalBoxId {
    data_ptr: *const (),
    generation: NonZeroU64,
}

// Safety: GenerationalBoxId is Send and Sync because there is no way to access the pointer.
unsafe impl Send for GenerationalBoxId {}
unsafe impl Sync for GenerationalBoxId {}

#[component]
fn ButtonComponent() -> Element {
    let mut count = use_signal(|| 0);

    let on_click = move |_| {
        println!("Button clicked!");
        count.set((*count)() + 1);
        
    };

    rsx!(
        button { onclick: on_click, "Click me! Count: {count}" }
    )
}

# 1回目
Listeners: [Listener(EventHandler { origin: ScopeId(1, "ButtonComponent"), callback: 0x133dfc@0 })]
# 2回目
 Listeners: [Listener(EventHandler { origin: ScopeId(1, "ButtonComponent"), callback: 0x133d5c@0 })]

impl<T, S: Storage<SignalData<T>>> Readable for Signal<T, S> {
    type Target = T;
    type Storage = S;

    #[track_caller]
    fn try_read_unchecked(&self) -> BorrowResult<ReadableRef<'static, Self>> {
        let inner = self.inner.try_read_unchecked()?;

        if let Some(reactive_context) = ReactiveContext::current() {
            tracing::trace!("Subscribing to the reactive context {}", reactive_context);
            reactive_context.subscribe(inner.subscribers.clone());
        }

        Ok(S::map(inner, |v| &v.value))
    }

    /// Get the current value of the signal. **Unlike read, this will not subscribe the current scope to the signal which can cause parts of your UI to not update.**
    ///
    /// If the signal has been dropped, this will panic.
    #[track_caller]
    fn try_peek_unchecked(&self) -> BorrowResult<ReadableRef<'static, Self>> {
        self.inner
            .try_read_unchecked()
            .map(|inner| S::map(inner, |v| &v.value))
    }
}

pub struct ReactiveContext {
    scope: ScopeId,
    inner: GenerationalBox<Inner, SyncStorage>,
}

// `use_callback`
if let Some(callback) = callback.take() {
        // Every time this hook is called replace the inner callback with the new callback
        inner.replace(Box::new(callback));
    }

// use_signal
if let Some(reactive_context) = ReactiveContext::current() {
            tracing::trace!("Subscribing to the reactive context {}", reactive_context);
            reactive_context.subscribe(inner.subscribers.clone());
    }