Remove Send+Sync bound from Measurable and create separate SyncMeasureFunc type

Author: nicoburns

src/lib.rs

@@ -3,7 +3,6 @@
 #![deny(unsafe_code)]
 #![warn(missing_docs)]
 #![warn(clippy::missing_docs_in_private_items)]
-#![forbid(unsafe_code)]
 
 // We always need std for the tests
 // See <https://github.com/la10736/rstest/issues/149#issuecomment-1156402989>

src/tree/measure_func.rs

@@ -8,7 +8,7 @@ use crate::util::sys::Box;
 /// A function type that can be used in a [`MeasureFunc`]
 ///
 /// This trait is automatically implemented for all types (including closures) that define a function with the appropriate type signature.
-pub trait Measurable: Send + Sync {
+pub trait Measurable {
     /// A user-defined context which is passed to taffy when the `compute_layout` function is called, and which Taffy then passes
     /// into measure functions when it calls them
     type Context;
@@ -55,13 +55,53 @@ impl<Context> Measurable for MeasureFunc<Context> {
     }
 }
 
+/// A function that can be used to compute the intrinsic size of a node
+pub enum SyncMeasureFunc<Context = ()> {
+    /// Stores an unboxed function with no context parameter
+    Raw(fn(Size<Option<f32>>, Size<AvailableSpace>) -> Size<f32>),
+
+    /// Stores an unboxed function with a context parameter
+    RawWithContext(fn(Size<Option<f32>>, Size<AvailableSpace>, context: &mut Context) -> Size<f32>),
+
+    /// Stores a boxed function
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    Boxed(Box<dyn Measurable<Context = Context> + Send + Sync>),
+}
+
+impl<Context> Measurable for SyncMeasureFunc<Context> {
+    type Context = Context;
+
+    /// Call the measure function to measure to the node
+    #[inline(always)]
+    fn measure(
+        &self,
+        known_dimensions: Size<Option<f32>>,
+        available_space: Size<AvailableSpace>,
+        context: &mut Context,
+    ) -> Size<f32> {
+        match self {
+            Self::Raw(measure) => measure(known_dimensions, available_space),
+            Self::RawWithContext(measure) => measure(known_dimensions, available_space, context),
+            #[cfg(any(feature = "std", feature = "alloc"))]
+            Self::Boxed(measurable) => measurable.measure(known_dimensions, available_space, context),
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
-    use super::MeasureFunc;
+    use super::SyncMeasureFunc;
+    use crate::tree::Taffy;
+
+    #[test]
+    fn sync_measure_func_is_send_and_sync() {
+        fn is_send_and_sync<T: Send + Sync>() {}
+        is_send_and_sync::<SyncMeasureFunc>();
+    }
 
     #[test]
-    fn measure_func_is_send_and_sync() {
+    fn taffy_with_sync_measure_func_is_send_and_sync() {
         fn is_send_and_sync<T: Send + Sync>() {}
-        is_send_and_sync::<MeasureFunc>();
+        is_send_and_sync::<Taffy<SyncMeasureFunc>>();
     }
 }

src/tree/mod.rs

@@ -7,7 +7,7 @@ use crate::style::{AvailableSpace, Style};
 mod cache;
 pub use cache::{Cache, CacheEntry};
 mod measure_func;
-pub use measure_func::{Measurable, MeasureFunc};
+pub use measure_func::{Measurable, MeasureFunc, SyncMeasureFunc};
 mod node;
 #[cfg(feature = "taffy_tree")]
 pub(self) use node::NodeData;

src/tree/taffy_tree/tree.rs

@@ -33,7 +33,7 @@ where
     pub(crate) nodes: SlotMap<DefaultKey, NodeData>,
 
     /// Functions/closures that compute the intrinsic size of leaf nodes
-    pub(crate) measure_funcs: SparseSecondaryMap<DefaultKey, MeasureFunc<Measure::Context>>,
+    pub(crate) measure_funcs: SparseSecondaryMap<DefaultKey, Measure>,
 
     /// The children of each node
     ///
@@ -168,11 +168,7 @@ impl<Measure: Measurable> Taffy<Measure> {
     /// Creates and adds a new unattached leaf node to the tree, and returns the node of the new node
     ///
     /// Creates and adds a new leaf node with a supplied [`MeasureFunc`]
-    pub fn new_leaf_with_measure(
-        &mut self,
-        layout: Style,
-        measure: MeasureFunc<Measure::Context>,
-    ) -> TaffyResult<NodeId> {
+    pub fn new_leaf_with_measure(&mut self, layout: Style, measure: Measure) -> TaffyResult<NodeId> {
         let mut data = NodeData::new(layout);
         data.needs_measure = true;
 
@@ -225,7 +221,7 @@ impl<Measure: Measurable> Taffy<Measure> {
     }
 
     /// Sets the [`MeasureFunc`] of the associated node
-    pub fn set_measure(&mut self, node: NodeId, measure: Option<MeasureFunc<Measure::Context>>) -> TaffyResult<()> {
+    pub fn set_measure(&mut self, node: NodeId, measure: Option<Measure>) -> TaffyResult<()> {
         let key = node.into();
         if let Some(measure) = measure {
             self.nodes[key].needs_measure = true;