firewheel_core/diff/

notify.rs

use bevy_platform::sync::atomic::Ordering;

use crate::{
    diff::{Diff, Patch, RealtimeClone},
    event::ParamData,
};

// Increment a realtime-safe atomic counter.
//
// This is gauranteed to never return zero.
fn increment_counter() -> NotifyID {
    portable_atomic::cfg_has_atomic_64! {
        use portable_atomic::AtomicU64;

        static NOTIFY_COUNTER: AtomicU64 = AtomicU64::new(1);

        portable_atomic::cfg_has_atomic_cas! {
            NotifyID(NOTIFY_COUNTER.fetch_add(1, Ordering::Relaxed))
        }

        portable_atomic::cfg_no_atomic_cas! {
            let val = NOTIFY_COUNTER.load(Ordering::Relaxed) + 1;
            NOTIFY_COUNTER.store(val, Ordering::Relaxed);
            NotifyID(val)
        }
    }

    portable_atomic::cfg_no_atomic_64! {
        portable_atomic::cfg_has_atomic_32! {
            use portable_atomic::AtomicU32;

            // While it is technically possible that the high and low bits in the counter
            // get desynced, in practice this is only ever used for diffing, so it is
            // exceedingly unlikely that a desync in the counter will have an effect on
            // the desired diffing behavior.
            static NOTIFY_COUNTER_0: AtomicU32 = AtomicU32::new(1);
            static NOTIFY_COUNTER_1: AtomicU32 = AtomicU32::new(0);

            let val_0 = NOTIFY_COUNTER_0.load(Ordering::Relaxed);
            let val_1 = NOTIFY_COUNTER_1.load(Ordering::Relaxed);

            let val = val_0 as u64 + ((val_1 as u64) << 32) + 1u64;

            NOTIFY_COUNTER_0.store((val & (u32::MAX as u64)) as u32, Ordering::Relaxed);
            NOTIFY_COUNTER_1.store((val >> 32) as u32, Ordering::Relaxed);

            NotifyID(val)
        }

        portable_atomic::cfg_no_atomic_32! {
            use portable_atomic::AtomicU64;

            // Just accept the locking behavior for these esoteric platforms.
            static NOTIFY_COUNTER: AtomicU64 = AtomicU64::new(1);
            NotifyID(NOTIFY_COUNTER.fetch_add(1, Ordering::Relaxed))
        }
    }
}

/// An identifier representing the "generation" of a [`Notify`] parameter.
///
/// Whenever a `Notify` parameter is mutated, it will be assigned a new [`NotifyID`].
/// For all practical purposes, the ID can be considered unique among all [`Notify`]
/// instances.
///
/// Valid (non-dangling) [`NotifyID`]s are guaranteed to never be 0, so it can be
/// used as a sentinel value.
#[repr(transparent)]
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "bevy_reflect", derive(bevy_reflect::Reflect))]
#[cfg_attr(feature = "bevy_reflect", reflect(opaque))]
pub struct NotifyID(pub u64);

impl NotifyID {
    pub const DANGLING: Self = Self(0);
}

/// A lightweight wrapper that guarantees an event
/// will be generated every time the inner value is accessed mutably,
/// even if the value doesn't change.
///
/// This is useful for types like a play head
/// where periodically writing the same value
/// carries useful information.
///
/// [`Notify`] implements [`core::ops::Deref`] and [`core::ops::DerefMut`]
/// for the inner `T`.
#[derive(Debug, Clone)]
pub struct Notify<T> {
    value: T,
    id: NotifyID,
}

impl<T> Notify<T> {
    /// Construct a new [`Notify`].
    ///
    /// If two instances of [`Notify`] are constructed separately,
    /// a call to [`Diff::diff`] will produce an event, even if the
    /// value is the same.
    ///
    /// ```
    /// # use firewheel_core::diff::Notify;
    /// // Diffing `a` and `b` will produce an event
    /// let a = Notify::new(1);
    /// let b = Notify::new(1);
    ///
    /// // whereas `b` and `c` will not.
    /// let c = b.clone();
    /// ```
    pub fn new(value: T) -> Self {
        Self {
            value,
            id: increment_counter(),
        }
    }

    pub(crate) fn from_raw(value: T, id: NotifyID) -> Self {
        Self { value, id }
    }

    /// An identifier representing the "generation" of this [`Notify`] parameter.
    ///
    /// Whenever this parameter is mutated, it will be assigned a new [`NotifyID`].
    /// For all practical purposes, the ID can be considered unique among all [`Notify`]
    /// instances.
    ///
    /// Valid (non-dangling) [`NotifyID`]s are guaranteed to never be 0, so it can be
    /// used as a sentinel value.
    #[inline(always)]
    pub fn id(&self) -> NotifyID {
        self.id
    }

    /// Get mutable access to the inner value without updating the ID.
    pub fn as_mut_unsync(&mut self) -> &mut T {
        &mut self.value
    }

    /// Manually update the internal ID without modifying the internals.
    pub fn notify(&mut self) {
        self.id = increment_counter();
    }
}

impl<T> AsRef<T> for Notify<T> {
    fn as_ref(&self) -> &T {
        &self.value
    }
}

impl<T> AsMut<T> for Notify<T> {
    fn as_mut(&mut self) -> &mut T {
        self.id = increment_counter();

        &mut self.value
    }
}

impl<T: Default> Default for Notify<T> {
    fn default() -> Self {
        Self::new(T::default())
    }
}

impl<T> core::ops::Deref for Notify<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.value
    }
}

impl<T> core::ops::DerefMut for Notify<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.id = increment_counter();

        &mut self.value
    }
}

impl<T: Copy> Copy for Notify<T> {}

impl<T> PartialEq for Notify<T> {
    fn eq(&self, other: &Self) -> bool {
        // under normal usage, it is not possible that the inner value
        // can change without incrementing the counter
        self.id == other.id
    }
}

impl<T: RealtimeClone + Send + Sync + 'static> Diff for Notify<T> {
    fn diff<E: super::EventQueue>(
        &self,
        baseline: &Self,
        path: super::PathBuilder,
        event_queue: &mut E,
    ) {
        if self.id != baseline.id {
            event_queue.push_param(ParamData::any(self.clone()), path);
        }
    }
}

impl<T: RealtimeClone + Send + Sync + 'static> Patch for Notify<T> {
    type Patch = Self;

    fn patch(data: &ParamData, _: &[u32]) -> Result<Self::Patch, super::PatchError> {
        data.downcast_ref()
            .ok_or(super::PatchError::InvalidData)
            .cloned()
    }

    fn apply(&mut self, patch: Self::Patch) {
        *self = patch;
    }
}

#[cfg(test)]
mod test {
    use crate::diff::PathBuilder;

    use super::*;

    #[test]
    fn test_identical_write() {
        #[cfg(not(feature = "std"))]
        use bevy_platform::prelude::Vec;

        let baseline = Notify::new(0.5f32);
        let mut value = baseline;

        let mut events = Vec::new();
        value.diff(&baseline, PathBuilder::default(), &mut events);
        assert_eq!(events.len(), 0);

        *value = 0.5f32;

        value.diff(&baseline, PathBuilder::default(), &mut events);
        assert_eq!(events.len(), 1);
    }
}

#[cfg(feature = "bevy_reflect")]
mod reflect {
    use super::Notify;

    #[cfg(not(feature = "std"))]
    use bevy_platform::prelude::{Box, ToString};

    impl<T> bevy_reflect::GetTypeRegistration for Notify<T>
    where
        Notify<T>: ::core::any::Any + ::core::marker::Send + ::core::marker::Sync,
        T: Clone
            + Default
            + bevy_reflect::FromReflect
            + bevy_reflect::TypePath
            + bevy_reflect::MaybeTyped
            + bevy_reflect::__macro_exports::RegisterForReflection,
    {
        fn get_type_registration() -> bevy_reflect::TypeRegistration {
            let mut registration = bevy_reflect::TypeRegistration::of::<Self>();
            registration.insert:: <bevy_reflect::ReflectFromPtr>(bevy_reflect::FromType:: <Self> ::from_type());
            registration.insert::<bevy_reflect::ReflectFromReflect>(
                bevy_reflect::FromType::<Self>::from_type(),
            );
            registration
                .insert::<bevy_reflect::prelude::ReflectDefault>(
                    bevy_reflect::FromType::<Self>::from_type(),
                );
            registration
        }

        #[inline(never)]
        fn register_type_dependencies(registry: &mut bevy_reflect::TypeRegistry) {
            <T as bevy_reflect::__macro_exports::RegisterForReflection>::__register(registry);
            <u64 as bevy_reflect::__macro_exports::RegisterForReflection>::__register(registry);
        }
    }

    impl<T> bevy_reflect::Typed for Notify<T>
    where
        Notify<T>: ::core::any::Any + ::core::marker::Send + ::core::marker::Sync,
        T: Clone
            + bevy_reflect::FromReflect
            + bevy_reflect::TypePath
            + bevy_reflect::MaybeTyped
            + bevy_reflect::__macro_exports::RegisterForReflection,
    {
        #[inline]
        fn type_info() -> &'static bevy_reflect::TypeInfo {
            static CELL: bevy_reflect::utility::GenericTypeInfoCell =
                bevy_reflect::utility::GenericTypeInfoCell::new();
            CELL.get_or_insert::<Self, _>(|| {
                bevy_reflect::TypeInfo::Struct(
                    bevy_reflect::structs::StructInfo::new::<Self>(&[
                        bevy_reflect::NamedField::new::<T>("value").with_custom_attributes(
                            bevy_reflect::attributes::CustomAttributes::default(),
                        ),
                    ])
                    .with_custom_attributes(bevy_reflect::attributes::CustomAttributes::default())
                    .with_generics(bevy_reflect::Generics::from_iter([
                        bevy_reflect::GenericInfo::Type(bevy_reflect::TypeParamInfo::new::<T>(
                            // TODO: Use nicer path once bevy_reflect exposes it.
                            bevy_reflect::__macro_exports::alloc_utils::Cow::Borrowed("T"),
                        )),
                    ])),
                )
            })
        }
    }

    extern crate alloc;
    impl<T> bevy_reflect::TypePath for Notify<T>
    where
        Notify<T>: ::core::any::Any + ::core::marker::Send + ::core::marker::Sync,
        T: bevy_reflect::TypePath,
    {
        fn type_path() -> &'static str {
            static CELL: bevy_reflect::utility::GenericTypePathCell =
                bevy_reflect::utility::GenericTypePathCell::new();
            CELL.get_or_insert::<Self, _>(|| {
                ::core::ops::Add::<&str>::add(
                    ::core::ops::Add::<&str>::add(
                        ToString::to_string(::core::concat!(
                            ::core::concat!(
                                ::core::concat!(::core::module_path!(), "::"),
                                "Notify"
                            ),
                            "<"
                        )),
                        <T as bevy_reflect::TypePath>::type_path(),
                    ),
                    ">",
                )
            })
        }
        fn short_type_path() -> &'static str {
            static CELL: bevy_reflect::utility::GenericTypePathCell =
                bevy_reflect::utility::GenericTypePathCell::new();
            CELL.get_or_insert::<Self, _>(|| {
                ::core::ops::Add::<&str>::add(
                    ::core::ops::Add::<&str>::add(
                        ToString::to_string(::core::concat!("Notify", "<")),
                        <T as bevy_reflect::TypePath>::short_type_path(),
                    ),
                    ">",
                )
            })
        }
        fn type_ident() -> Option<&'static str> {
            Some("Notify")
        }
        fn crate_name() -> Option<&'static str> {
            Some(::core::module_path!().split(':').next().unwrap())
        }
        fn module_path() -> Option<&'static str> {
            Some(::core::module_path!())
        }
    }

    impl<T> bevy_reflect::Reflect for Notify<T>
    where
        Notify<T>: ::core::any::Any + ::core::marker::Send + ::core::marker::Sync,
        T: Clone
            + bevy_reflect::FromReflect
            + bevy_reflect::TypePath
            + bevy_reflect::MaybeTyped
            + bevy_reflect::__macro_exports::RegisterForReflection,
    {
        #[inline]
        fn into_any(self: Box<Self>) -> Box<dyn ::core::any::Any> {
            self
        }
        #[inline]
        fn as_any(&self) -> &dyn ::core::any::Any {
            self
        }
        #[inline]
        fn as_any_mut(&mut self) -> &mut dyn ::core::any::Any {
            self
        }
        #[inline]
        fn into_reflect(self: Box<Self>) -> Box<dyn bevy_reflect::Reflect> {
            self
        }
        #[inline]
        fn as_reflect(&self) -> &dyn bevy_reflect::Reflect {
            self
        }
        #[inline]
        fn as_reflect_mut(&mut self) -> &mut dyn bevy_reflect::Reflect {
            self
        }
        #[inline]
        fn set(
            &mut self,
            value: Box<dyn bevy_reflect::Reflect>,
        ) -> Result<(), Box<dyn bevy_reflect::Reflect>> {
            *self = <dyn bevy_reflect::Reflect>::take(value)?;
            Ok(())
        }
    }

    impl<T> bevy_reflect::prelude::Struct for Notify<T>
    where
        Notify<T>: ::core::any::Any + ::core::marker::Send + ::core::marker::Sync,
        T: Clone
            + bevy_reflect::FromReflect
            + bevy_reflect::TypePath
            + bevy_reflect::MaybeTyped
            + bevy_reflect::__macro_exports::RegisterForReflection,
    {
        fn field(&self, name: &str) -> Option<&dyn bevy_reflect::PartialReflect> {
            match name {
                "value" => Some(&self.value),
                _ => None,
            }
        }

        fn field_mut(&mut self, name: &str) -> Option<&mut dyn bevy_reflect::PartialReflect> {
            match name {
                "value" => Some(self.as_mut()),
                _ => None,
            }
        }

        fn field_at(&self, index: usize) -> Option<&dyn bevy_reflect::PartialReflect> {
            match index {
                0usize => Some(&self.value),
                _ => None,
            }
        }

        fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn bevy_reflect::PartialReflect> {
            match index {
                0usize => Some(self.as_mut()),
                _ => None,
            }
        }

        fn name_at(&self, index: usize) -> Option<&str> {
            match index {
                0usize => Some("value"),
                _ => None,
            }
        }

        fn field_len(&self) -> usize {
            1usize
        }

        fn iter_fields<'a>(&'a self) -> bevy_reflect::structs::FieldIter<'a> {
            bevy_reflect::structs::FieldIter::new(self)
        }

        fn to_dynamic_struct(&self) -> bevy_reflect::structs::DynamicStruct {
            let mut dynamic: bevy_reflect::structs::DynamicStruct = Default::default();
            dynamic.set_represented_type(bevy_reflect::PartialReflect::get_represented_type_info(
                self,
            ));
            dynamic.insert_boxed(
                "value",
                bevy_reflect::PartialReflect::to_dynamic(&self.value),
            );
            dynamic
        }

        fn index_of_name(&self, name: &str) -> Option<usize> {
            (name == "value").then_some(0)
        }
    }

    impl<T> bevy_reflect::PartialReflect for Notify<T>
    where
        Notify<T>: ::core::any::Any + ::core::marker::Send + ::core::marker::Sync,
        T: Clone
            + bevy_reflect::FromReflect
            + bevy_reflect::TypePath
            + bevy_reflect::MaybeTyped
            + bevy_reflect::__macro_exports::RegisterForReflection,
    {
        #[inline]
        fn get_represented_type_info(&self) -> Option<&'static bevy_reflect::TypeInfo> {
            Some(<Self as bevy_reflect::Typed>::type_info())
        }

        #[inline]
        fn try_apply(
            &mut self,
            value: &dyn bevy_reflect::PartialReflect,
        ) -> Result<(), bevy_reflect::ApplyError> {
            if let bevy_reflect::ReflectRef::Struct(struct_value) =
                bevy_reflect::PartialReflect::reflect_ref(value)
            {
                for (name, value) in struct_value {
                    if let Some(v) = bevy_reflect::prelude::Struct::field_mut(self, name) {
                        bevy_reflect::PartialReflect::try_apply(v, value)?;
                    }
                }
            } else {
                return Result::Err(bevy_reflect::ApplyError::MismatchedKinds {
                    from_kind: bevy_reflect::PartialReflect::reflect_kind(value),
                    to_kind: bevy_reflect::ReflectKind::Struct,
                });
            }
            Ok(())
        }

        #[inline]
        fn reflect_kind(&self) -> bevy_reflect::ReflectKind {
            bevy_reflect::ReflectKind::Struct
        }

        #[inline]
        fn reflect_ref<'a>(&'a self) -> bevy_reflect::ReflectRef<'a> {
            bevy_reflect::ReflectRef::Struct(self)
        }

        #[inline]
        fn reflect_mut<'a>(&'a mut self) -> bevy_reflect::ReflectMut<'a> {
            bevy_reflect::ReflectMut::Struct(self)
        }

        #[inline]
        fn reflect_owned(self: Box<Self>) -> bevy_reflect::ReflectOwned {
            bevy_reflect::ReflectOwned::Struct(self)
        }

        #[inline]
        fn try_into_reflect(
            self: Box<Self>,
        ) -> Result<Box<dyn bevy_reflect::Reflect>, Box<dyn bevy_reflect::PartialReflect>> {
            Ok(self)
        }

        #[inline]
        fn try_as_reflect(&self) -> Option<&dyn bevy_reflect::Reflect> {
            Some(self)
        }

        #[inline]
        fn try_as_reflect_mut(&mut self) -> Option<&mut dyn bevy_reflect::Reflect> {
            Some(self)
        }

        #[inline]
        fn into_partial_reflect(self: Box<Self>) -> Box<dyn bevy_reflect::PartialReflect> {
            self
        }

        #[inline]
        fn as_partial_reflect(&self) -> &dyn bevy_reflect::PartialReflect {
            self
        }

        #[inline]
        fn as_partial_reflect_mut(&mut self) -> &mut dyn bevy_reflect::PartialReflect {
            self
        }

        fn reflect_partial_eq(&self, value: &dyn bevy_reflect::PartialReflect) -> Option<bool> {
            (bevy_reflect::structs::struct_partial_eq)(self, value)
        }

        #[inline]
        fn reflect_clone(
            &self,
        ) -> Result<Box<dyn bevy_reflect::Reflect>, bevy_reflect::ReflectCloneError> {
            Ok(Box::new(Clone::clone(self)))
        }
    }

    impl<T> bevy_reflect::FromReflect for Notify<T>
    where
        Notify<T>: ::core::any::Any + ::core::marker::Send + ::core::marker::Sync,
        T: Default
            + Clone
            + bevy_reflect::FromReflect
            + bevy_reflect::TypePath
            + bevy_reflect::MaybeTyped
            + bevy_reflect::__macro_exports::RegisterForReflection,
    {
        fn from_reflect(reflect: &dyn bevy_reflect::PartialReflect) -> Option<Self> {
            if let bevy_reflect::ReflectRef::Struct(ref_struct) =
                bevy_reflect::PartialReflect::reflect_ref(reflect)
            {
                let mut this = <Self as ::core::default::Default>::default();
                if let Some(field) = (|| {
                    <T as bevy_reflect::FromReflect>::from_reflect(
                        bevy_reflect::prelude::Struct::field(ref_struct, "value")?,
                    )
                })() {
                    this.value = field;
                }
                Some(this)
            } else {
                None
            }
        }
    }
}