Port the Memoize view into xilem_core

crates/xilem_core/src/lib.rs

@@ -17,6 +17,7 @@
 
 mod any_view;
 mod id;
+mod memoize;
 mod message;
 mod sequence;
 mod vec_splice;

crates/xilem_core/src/memoize.rs

@@ -0,0 +1,104 @@
+// Copyright 2023 the Xilem Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+#[macro_export]
+macro_rules! generate_memoize_view {
+    ($memoizeview:ident,
+     $memoizestate:ident,
+     $viewtrait:ident,
+     $viewmarker:ty,
+     $cx:ty,
+     $changeflags:ty,
+     $staticviewfunction:ident,
+     $memoizeviewfunction:ident
+    ) => {
+        pub struct $memoizeview<D, F> {
+            data: D,
+            child_cb: F,
+        }
+
+        pub struct $memoizestate<T, A, V: $viewtrait<T, A>> {
+            view: V,
+            view_state: V::State,
+            dirty: bool,
+        }
+
+        impl<D, V, F: Fn(&D) -> V> $memoizeview<D, F> {
+            pub fn new(data: D, child_cb: F) -> Self {
+                $memoizeview { data, child_cb }
+            }
+        }
+
+        impl<D, F> $viewmarker for $memoizeview<D, F> {}
+
+        impl<
+                T,
+                A,
+                D: PartialEq + Clone + Send + 'static,
+                V: $viewtrait<T, A>,
+                F: Fn(&D) -> V + Send,
+            > $viewtrait<T, A> for $memoizeview<D, F>
+        {
+            type State = $memoizestate<T, A, V>;
+
+            type Element = V::Element;
+
+            fn build(&self, cx: &mut $cx) -> ($crate::Id, Self::State, Self::Element) {
+                let view = (self.child_cb)(&self.data);
+                let (id, view_state, element) = view.build(cx);
+                let memoize_state = $memoizestate {
+                    view,
+                    view_state,
+                    dirty: false,
+                };
+                (id, memoize_state, element)
+            }
+
+            fn rebuild(
+                &self,
+                cx: &mut $cx,
+                prev: &Self,
+                id: &mut $crate::Id,
+                state: &mut Self::State,
+                element: &mut Self::Element,
+            ) -> $changeflags {
+                if std::mem::take(&mut state.dirty) || prev.data != self.data {
+                    let view = (self.child_cb)(&self.data);
+                    let changed = view.rebuild(cx, &state.view, id, &mut state.view_state, element);
+                    state.view = view;
+                    changed
+                } else {
+                    <$changeflags>::empty()
+                }
+            }
+
+            fn message(
+                &self,
+                id_path: &[$crate::Id],
+                state: &mut Self::State,
+                event: Box<dyn std::any::Any>,
+                app_state: &mut T,
+            ) -> $crate::MessageResult<A> {
+                let r = state
+                    .view
+                    .message(id_path, &mut state.view_state, event, app_state);
+                if matches!(r, $crate::MessageResult::RequestRebuild) {
+                    state.dirty = true;
+                }
+                r
+            }
+        }
+
+        /// A static view, all of the content of the `view` should be constant, as this function is only run once
+        pub fn $staticviewfunction<V, F: Fn() -> V + 'static>(
+            view: F,
+        ) -> $memoizeview<(), impl Fn(&()) -> V> {
+            $memoizeview::new((), move |_: &()| view())
+        }
+
+        /// Memoize the view, until the `data` changes (in which case `view` is called again)
+        pub fn $memoizeviewfunction<D, V, F: Fn(&D) -> V>(data: D, view: F) -> $memoizeview<D, F> {
+            $memoizeview::new(data, view)
+        }
+    };
+}

src/view/mod.rs

@@ -17,7 +17,6 @@
 mod button;
 // mod layout_observer;
 // mod list;
-// mod memoize;
 // mod scroll_view;
 // mod text;
 // mod use_state;

src/view/view.rs

@@ -26,6 +26,7 @@ use crate::widget::{AnyWidget, ChangeFlags, Pod, Widget};
 xilem_core::generate_view_trait! {View, Widget, Cx, ChangeFlags; : Send}
 xilem_core::generate_viewsequence_trait! {ViewSequence, View, ViewMarker, Widget, Cx, ChangeFlags, Pod; : Send}
 xilem_core::generate_anyview_trait! {AnyView, View, ViewMarker, Cx, ChangeFlags, AnyWidget, BoxedView; + Send}
+xilem_core::generate_memoize_view! {Memoize, MemoizeState, View, ViewMarker, Cx, ChangeFlags, s, memoize}
 
 #[derive(Clone)]
 pub struct Cx {