[Rust] Implement support for persistent data notifications

Using `DataNotificationClosure::register_persisted` you can keep the notifications active until the associated `BinaryView` is destroyed.

Author: emesare

rust/src/data_notification.rs

@@ -83,16 +83,17 @@ macro_rules! trait_handler {
     ) -> DataNotificationHandle<'a, H> {
         // SAFETY: this leak is undone on drop
         let leak_notify = Box::leak(Box::new(notify));
-        let handle = BNBinaryDataNotification {
+        let notifications = BNBinaryDataNotification {
             context: leak_notify as *mut _ as *mut c_void,
+            unregistered: None,
             $($ffi_param_name: triggers.$fun_name.then_some($fun_name::<H>)),*,
             // TODO: Require all BNBinaryDataNotification's to be implemented?
             // Since core developers are not required to write Rust bindings (yet) we do not
-            // force new binary data notifications callbacks to be written here.of core developers who do not wish to write
+            // force new binary data notifications callbacks to be written here.
             ..Default::default()
         };
         // Box it to prevent a copy being returned in `DataNotificationHandle`.
-        let mut boxed_handle = Box::new(handle);
+        let mut boxed_handle = Box::new(notifications);
         unsafe { BNRegisterDataNotification(view.handle, boxed_handle.as_mut()) };
         DataNotificationHandle {
             bv: view.to_owned(),
@@ -101,12 +102,38 @@ macro_rules! trait_handler {
         }
     }
 
-    /// Implement closures that will be called by on the event of data modification.
+    fn register_persisted_data_notification<'a, H: CustomDataNotification + 'a>(
+        view: &BinaryView,
+        notify: H,
+        triggers: DataNotificationTriggers,
+    ) -> PersistedDataNotificationHandle<'a, H> {
+        // SAFETY: this leak is undone on drop
+        let leak_notify = Box::leak(Box::new(notify));
+        // NOTE: The notification structure here is passed as ptr but eventually gets copied, so
+        // the lifetime of this object just needs to live to after `BNRegisterDataNotification`.
+        let notifications = BNBinaryDataNotification {
+            context: leak_notify as *mut _ as *mut c_void,
+            unregistered: Some(cb_unregistered::<H>),
+            $($ffi_param_name: triggers.$fun_name.then_some($fun_name::<H>)),*,
+            // TODO: Require all BNBinaryDataNotification's to be implemented?
+            // Since core developers are not required to write Rust bindings (yet) we do not
+            // force new binary data notifications callbacks to be written here.
+            ..Default::default()
+        };
+        let mut boxed_handle = Box::new(notifications);
+        unsafe { BNRegisterDataNotification(view.handle, boxed_handle.as_mut()) };
+        PersistedDataNotificationHandle {
+            handle: boxed_handle,
+            _life: std::marker::PhantomData,
+        }
+    }
+
+    /// Implement closures that will be called in the event of data modification.
     ///
-    /// Once dropped the closures will stop being called.
+    /// Once dropped, the closures will stop being called.
     ///
     /// NOTE: Closures are not executed on the same thread as the event that occurred, you must not depend
-    /// on any serial behavior
+    /// on any serial behavior.
     ///
     /// # Example
     ///
@@ -148,6 +175,8 @@ macro_rules! trait_handler {
     )*
 
         /// Register the closures to be notified up until the [`DataNotificationHandle`] is dropped.
+        ///
+        /// If you need to have the closures notified indefinitely, use [`DataNotificationClosure::register_persisted`].
         pub fn register(
             self,
             view: &BinaryView,
@@ -160,6 +189,20 @@ macro_rules! trait_handler {
             )*
             register_data_notification(view, self, triggers)
         }
+
+        /// Register the closures to be notified up until the [`BinaryView`] is dropped.
+        pub fn register_persisted(
+            self,
+            view: &BinaryView,
+        ) -> PersistedDataNotificationHandle<'a, Self> {
+            let mut triggers = DataNotificationTriggers::default();
+            $(
+            if self.$fun_name.is_some() {
+                triggers = triggers.$fun_name();
+            }
+            )*
+            register_persisted_data_notification(view, self, triggers)
+        }
     }
 
     impl CustomDataNotification for DataNotificationClosure<'_> {
@@ -352,27 +395,27 @@ trait_handler! {
         var: *mut BNDataVariable: &DataVariable = &DataVariable::from_raw(&*var),
     ),
     externalLibraryAdded => external_library_added(
-        data: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(data),
+        view: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(view),
         library: *mut BNExternalLibrary: &ExternalLibrary = &ExternalLibrary::from_raw(NonNull::new(library).unwrap()),
     ),
     externalLibraryUpdated => external_library_updated(
-        data: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(data),
+        view: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(view),
         library: *mut BNExternalLibrary: &ExternalLibrary = &ExternalLibrary::from_raw(NonNull::new(library).unwrap()),
     ),
     externalLibraryRemoved => external_library_removed(
-        data: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(data),
+        view: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(view),
         library: *mut BNExternalLibrary: &ExternalLibrary = &ExternalLibrary::from_raw(NonNull::new(library).unwrap()),
     ),
     externalLocationAdded => external_location_added(
-        data: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(data),
+        view: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(view),
         location: *mut BNExternalLocation: &ExternalLocation = &ExternalLocation::from_raw(NonNull::new(location).unwrap()),
     ),
     externalLocationUpdated => external_location_updated(
-        data: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(data),
+        view: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(view),
         location: *mut BNExternalLocation: &ExternalLocation = &ExternalLocation::from_raw(NonNull::new(location).unwrap()),
     ),
     externalLocationRemoved => external_location_removed(
-        data: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(data),
+        view: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(view),
         location: *mut BNExternalLocation: &ExternalLocation = &ExternalLocation::from_raw(NonNull::new(location).unwrap()),
     ),
     typeArchiveAttached => type_archive_attached(
@@ -406,8 +449,8 @@ trait_handler! {
         entry: *mut BNUndoEntry: &UndoEntry = &UndoEntry::from_raw(NonNull::new(entry).unwrap()),
     ),
     rebased => rebased(
-        oldview: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(oldview),
-        newview: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(newview),
+        old_view: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(old_view),
+        new_view: *mut BNBinaryView: &BinaryView = &BinaryView::from_raw(new_view),
     ),
 }
 
@@ -430,7 +473,7 @@ impl<T: CustomDataNotification> DataNotificationHandle<'_, T> {
     }
 
     pub fn unregister(self) -> T {
-        // NOTE don't drop the ctxt, return it
+        // NOTE: Don't drop the ctxt, return it
         let mut slf = core::mem::ManuallyDrop::new(self);
         unsafe { slf.unregister_bv() };
         unsafe { *slf.extract_context() }
@@ -444,3 +487,38 @@ impl<T: CustomDataNotification> Drop for DataNotificationHandle<'_, T> {
         let _ctxt = unsafe { self.extract_context() };
     }
 }
+
+unsafe impl<T: CustomDataNotification> Send for DataNotificationHandle<'_, T> {}
+unsafe impl<T: CustomDataNotification> Sync for DataNotificationHandle<'_, T> {}
+
+pub struct PersistedDataNotificationHandle<'a, T: CustomDataNotification>
+where
+    T: 'a,
+{
+    handle: Box<BNBinaryDataNotification>,
+    _life: std::marker::PhantomData<&'a T>,
+}
+
+impl<T: CustomDataNotification> PersistedDataNotificationHandle<'_, T> {
+    unsafe fn unregister_bv(&mut self, view: &BinaryView) {
+        BNUnregisterDataNotification(view.handle, self.handle.as_mut())
+    }
+
+    unsafe fn extract_context(&mut self) -> Box<T> {
+        Box::from_raw(self.handle.context as *mut T)
+    }
+
+    pub fn unregister(self, view: &BinaryView) -> T {
+        // NOTE: Don't drop the ctxt, return it
+        let mut slf = core::mem::ManuallyDrop::new(self);
+        unsafe { slf.unregister_bv(view) };
+        unsafe { *slf.extract_context() }
+    }
+}
+
+unsafe impl<T: CustomDataNotification> Send for PersistedDataNotificationHandle<'_, T> {}
+unsafe impl<T: CustomDataNotification> Sync for PersistedDataNotificationHandle<'_, T> {}
+
+unsafe extern "C" fn cb_unregistered<T: CustomDataNotification>(ctxt: *mut c_void) {
+    let _ = Box::from_raw(ctxt as *mut T);
+}