Clonable ResamplingFunctions (#69)

Author: shsms

RELEASE_NOTES.md

@@ -1,5 +1,5 @@
 # Frequenz Resampling Release Notes
 
-## Summary
+## New Features
 
-This is the first release of Frequenz Resampling.
+- `ResamplingFunction` now implements `Clone`.

src/lib.rs

@@ -81,4 +81,7 @@ mod tests;
 #[cfg(feature = "python")]
 mod python;
 
-pub use resampler::{Resampler, ResamplingFunction, Sample};
+mod resampling_function;
+pub use resampling_function::ResamplingFunction;
+
+pub use resampler::{Resampler, Sample};

src/resampler.rs

@@ -4,16 +4,14 @@
 //! The resampler module provides the Resampler struct that is used to resample
 //! a time series of samples.
 
+use crate::ResamplingFunction;
 use chrono::{DateTime, TimeDelta, Utc};
+use itertools::Itertools;
 use log::warn;
 use num_traits::FromPrimitive;
 use std::fmt::Debug;
 use std::ops::Div;
 
-use itertools::Itertools;
-
-pub type CustomResamplingFunction<S, T> = Box<dyn FnMut(&[&S]) -> Option<T> + Send + Sync>;
-
 /// The Sample trait represents a single sample in a time series.
 pub trait Sample: Clone + Debug + Default {
     type Value;
@@ -22,42 +20,6 @@ pub trait Sample: Clone + Debug + Default {
     fn value(&self) -> Option<Self::Value>;
 }
 
-/// The ResamplingFunction enum represents the different resampling functions
-/// that can be used to resample a channel.
-#[derive(Default)]
-pub enum ResamplingFunction<
-    T: Div<Output = T> + std::iter::Sum + Default + Debug,
-    S: Sample<Value = T>,
-> {
-    /// Calculates the average of all samples in the time step (ignoring None
-    /// values)
-    #[default]
-    Average,
-    /// Calculates the sum of all samples in the time step (ignoring None
-    /// values)
-    Sum,
-    /// Calculates the maximum value of all samples in the time step (ignoring
-    /// None values)
-    Max,
-    /// Calculates the minimum value of all samples in the time step (ignoring
-    /// None values)
-    Min,
-    /// Uses the first sample in the time step. If the first sample is None, the
-    /// resampling function will return None.
-    First,
-    /// Uses the last sample in the time step. If the last sample is None, the
-    /// resampling function will return None.
-    Last,
-    /// Returns the first non-None sample in the time step. If all samples are
-    /// None, the resampling function will return None.
-    Coalesce,
-    /// Counts the number of samples in the time step (ignoring None values)
-    Count,
-    /// A custom resampling function that takes a closure that takes a slice of
-    /// samples and returns an optional value.
-    Custom(CustomResamplingFunction<S, T>),
-}
-
 impl<
         T: Div<Output = T> + std::iter::Sum + PartialOrd + FromPrimitive + Default + Debug,
         S: Sample<Value = T>,

src/resampling_function.rs

@@ -0,0 +1,81 @@
+// License: MIT
+// Copyright © 2024 Frequenz Energy-as-a-Service GmbH
+
+//! Resampling functions for time series data.
+
+use crate::Sample;
+use std::{fmt::Debug, ops::Div};
+
+// This trait can't directly have `Clone` as a supertrait because
+// then it wouldn't be dyn-compatible.
+//
+// Instead, we make a blanket implementation for all FnMut that implement
+// `Clone`, which will be dispatched statically.
+pub trait ClonableFnMut<S, T>: FnMut(&[&S]) -> Option<T> + Send + Sync {
+    fn clone_box(&self) -> Box<dyn ClonableFnMut<S, T>>;
+}
+
+impl<S, T, F> ClonableFnMut<S, T> for F
+where
+    F: FnMut(&[&S]) -> Option<T> + Send + Sync + Clone + 'static,
+{
+    fn clone_box(&self) -> Box<dyn ClonableFnMut<S, T>> {
+        Box::new(self.clone())
+    }
+}
+
+/// The ResamplingFunction enum represents the different resampling functions
+/// that can be used to resample a channel.
+#[derive(Default)]
+pub enum ResamplingFunction<
+    T: Div<Output = T> + std::iter::Sum + Default + Debug,
+    S: Sample<Value = T>,
+> {
+    /// Calculates the average of all samples in the time step (ignoring None
+    /// values)
+    #[default]
+    Average,
+    /// Calculates the sum of all samples in the time step (ignoring None
+    /// values)
+    Sum,
+    /// Calculates the maximum value of all samples in the time step (ignoring
+    /// None values)
+    Max,
+    /// Calculates the minimum value of all samples in the time step (ignoring
+    /// None values)
+    Min,
+    /// Uses the first sample in the time step. If the first sample is None, the
+    /// resampling function will return None.
+    First,
+    /// Uses the last sample in the time step. If the last sample is None, the
+    /// resampling function will return None.
+    Last,
+    /// Returns the first non-None sample in the time step. If all samples are
+    /// None, the resampling function will return None.
+    Coalesce,
+    /// Counts the number of samples in the time step (ignoring None values)
+    Count,
+    /// A custom resampling function that takes a closure that takes a slice of
+    /// samples and returns an optional value.
+    Custom(Box<dyn ClonableFnMut<S, T>>),
+}
+
+impl<T, S> Clone for ResamplingFunction<T, S>
+where
+    T: Div<Output = T> + std::iter::Sum + Default + Debug,
+    S: Sample<Value = T>,
+{
+    fn clone(&self) -> Self {
+        match self {
+            Self::Average => Self::Average,
+            Self::Sum => Self::Sum,
+            Self::Max => Self::Max,
+            Self::Min => Self::Min,
+            Self::First => Self::First,
+            Self::Last => Self::Last,
+            Self::Coalesce => Self::Coalesce,
+            Self::Count => Self::Count,
+            Self::Custom(f) => Self::Custom(f.clone_box()),
+        }
+    }
+}

src/tests.rs

@@ -9,7 +9,8 @@ use std::{
     ops::{Add, Div},
 };
 
-use crate::resampler::{epoch_align, Resampler, ResamplingFunction, Sample};
+use crate::resampler::{epoch_align, Resampler, Sample};
+use crate::ResamplingFunction;
 use chrono::{DateTime, TimeDelta, Utc};
 use num_traits::FromPrimitive;
 
@@ -334,13 +335,33 @@ fn test_resampling_coalesce() {
 
 #[test]
 fn test_resampling_custom() {
+    // Create a custom FnMut with internal state (an increment).
+    let mut increment = 0.0;
+    let resampling_fn = ResamplingFunction::Custom(Box::new(move |x: &[&TestSample]| {
+        increment += 1.0;
+        Some(x.iter().map(|s| s.value().unwrap()).sum::<f64>() + increment)
+    }));
+
     test_resampling(
-        ResamplingFunction::Custom(Box::new(|x: &[&TestSample]| {
-            Some(x.iter().map(|s| s.value().unwrap()).sum::<f64>())
-        })),
+        resampling_fn.clone(),
         vec![
-            TestSample::new(DateTime::from_timestamp(5, 0).unwrap(), Some(15.0)),
-            TestSample::new(DateTime::from_timestamp(10, 0).unwrap(), Some(40.0)),
+            TestSample::new(DateTime::from_timestamp(5, 0).unwrap(), Some(16.0)),
+            TestSample::new(DateTime::from_timestamp(10, 0).unwrap(), Some(42.0)),
+        ],
+    );
+    // Ensure that clones don't share mutable state with the original.
+    test_resampling(
+        resampling_fn.clone(),
+        vec![
+            TestSample::new(DateTime::from_timestamp(5, 0).unwrap(), Some(16.0)),
+            TestSample::new(DateTime::from_timestamp(10, 0).unwrap(), Some(42.0)),
+        ],
+    );
+    test_resampling(
+        resampling_fn,
+        vec![
+            TestSample::new(DateTime::from_timestamp(5, 0).unwrap(), Some(16.0)),
+            TestSample::new(DateTime::from_timestamp(10, 0).unwrap(), Some(42.0)),
         ],
     );
 }