Expect metric only as a generic argument in logical meter formulas (#31)

Author: shsms

RELEASE_NOTES.md

@@ -8,6 +8,20 @@
 
 - `LogicalMeterConfig` instances can't be created directly anymore, and need to be created using the `LogicalMeterConfig::new` method.  This helps avoid future breaking changes, as we add more config parameters.
 
+- Formula streaming methods in the `LogicalMeterHandle` no longer take metric as a function parameter, but expect a generic argument.  For example:
+
+  *Old syntax:*
+   ```rust
+   let formula_grid = logical_meter.grid(metric::AcPowerActive)?;
+   let formula_pv = logical_meter.pv(None, metric::AcVoltage)?;
+   ```
+
+  *New syntax:*
+   ```rust
+   let formula_grid = logical_meter.grid::<metric::AcPowerActive>()?;
+   let formula_pv = logical_meter.pv::<metric::AcVoltage>(None)?;
+   ```
+
 ## New Features
 
 - It is now possible to change the default resampling function, and to override the resampling function for specific metrics.

examples/logical_meter.rs

@@ -19,20 +19,20 @@ async fn main() -> Result<(), Error> {
         .init();
 
     let client = MicrogridClientHandle::try_new("http://[::1]:8800").await?;
-    let mut logical_meter = LogicalMeterHandle::try_new(
+    let logical_meter = LogicalMeterHandle::try_new(
         client,
         LogicalMeterConfig::new(TimeDelta::try_seconds(1).unwrap()),
     )
     .await?;
 
-    let formula_grid = logical_meter.grid(metric::AcPowerActive)?;
-    let formula_pv = logical_meter.pv(None, metric::AcPowerActive)?;
-    let formula_consumer = logical_meter.consumer(metric::AcPowerActive)?;
+    let formula_grid = logical_meter.grid::<metric::AcPowerActive>()?;
+    let formula_pv = logical_meter.pv::<metric::AcPowerActive>(None)?;
+    let formula_consumer = logical_meter.consumer::<metric::AcPowerActive>()?;
 
     // Create a formula that calculates `grid_power - pv_power + consumer_power + 100kW`.
-    let formula = logical_meter.grid(metric::AcPowerActive)?
-        - logical_meter.pv(None, metric::AcPowerActive)?
-        + logical_meter.consumer(metric::AcPowerActive)?
+    let formula = logical_meter.grid::<metric::AcPowerActive>()?
+        - logical_meter.pv::<metric::AcPowerActive>(None)?
+        + logical_meter.consumer::<metric::AcPowerActive>()?
         + Power::from_kilowatts(100.0);
 
     let mut rx = formula.subscribe().await?;
@@ -68,10 +68,10 @@ async fn main() -> Result<(), Error> {
 
     // Create a formula that calculates the grid voltage as:
     // COALESCE(grid_voltage, AVG(grid_voltage_p1, grid_voltage_p2, grid_voltage_p3) * SQRT(3))
-    let formula_grid_voltage = logical_meter.grid(metric::AcVoltage)?.coalesce(
-        logical_meter.grid(metric::AcVoltagePhase1N)?.avg(vec![
-            logical_meter.grid(metric::AcVoltagePhase2N)?,
-            logical_meter.grid(metric::AcVoltagePhase3N)?,
+    let formula_grid_voltage = logical_meter.grid::<metric::AcVoltage>()?.coalesce(
+        logical_meter.grid::<metric::AcVoltagePhase1N>()?.avg(vec![
+            logical_meter.grid::<metric::AcVoltagePhase2N>()?,
+            logical_meter.grid::<metric::AcVoltagePhase3N>()?,
         ])? * 3.0_f32.sqrt(),
     )?;
 
@@ -95,18 +95,21 @@ async fn main() -> Result<(), Error> {
     drop(consumer_rx);
 
     let mut p1 = logical_meter
-        .grid(metric::AcVoltagePhase1N)?
+        .grid::<metric::AcVoltagePhase1N>()?
         .subscribe()
         .await?;
     let mut p2 = logical_meter
-        .grid(metric::AcVoltagePhase2N)?
+        .grid::<metric::AcVoltagePhase2N>()?
         .subscribe()
         .await?;
     let mut p3 = logical_meter
-        .grid(metric::AcVoltagePhase3N)?
+        .grid::<metric::AcVoltagePhase3N>()?
+        .subscribe()
+        .await?;
+    let mut three_phase = logical_meter
+        .grid::<metric::AcVoltage>()?
         .subscribe()
         .await?;
-    let mut three_phase = logical_meter.grid(metric::AcVoltage)?.subscribe().await?;
 
     loop {
         let sample = grid_voltage_rx.recv().await.unwrap();

src/logical_meter/formula.rs

@@ -3,6 +3,8 @@
 
 //! Formula module for the logical meter.
 
+use std::marker::PhantomData;
+
 use async_trait::async_trait;
 pub(crate) mod aggregation_formula;
 mod async_formula;
@@ -37,20 +39,19 @@ pub trait FormulaSubscriber: std::fmt::Display + Sync + Send {
 /// Parameters for creating a logical meter formula.
 pub(super) struct FormulaParams<F: GraphFormulaConnector, M: Metric> {
     pub(super) formula: F::GraphFormulaType,
-    pub(super) metric: M,
     pub(super) instructions_tx: mpsc::Sender<logical_meter_actor::Instruction>,
+    phantom: PhantomData<M>,
 }
 
 impl<F: GraphFormulaConnector, M: Metric> FormulaParams<F, M> {
     pub(super) fn new(
         formula: F::GraphFormulaType,
-        metric: M,
         instructions_tx: mpsc::Sender<logical_meter_actor::Instruction>,
     ) -> Self {
         Self {
             formula,
-            metric,
             instructions_tx,
+            phantom: PhantomData,
         }
     }
 }

src/logical_meter/formula/aggregation_formula.rs

@@ -3,6 +3,8 @@
 
 //! An formula that supports aggregation operations.
 
+use std::marker::PhantomData;
+
 use super::{FormulaParams, FormulaSubscriber, GraphFormulaConnector};
 use crate::{
     Error, Sample, logical_meter::logical_meter_actor, metric::Metric, quantity::Quantity,
@@ -13,8 +15,8 @@ use tokio::sync::{broadcast, mpsc, oneshot};
 #[derive(Clone)]
 pub struct AggregationFormula<M: Metric> {
     formula: frequenz_microgrid_component_graph::AggregationFormula,
-    metric: M,
     instructions_tx: mpsc::Sender<logical_meter_actor::Instruction>,
+    phantom: PhantomData<M>,
 }
 
 impl<M: Metric> std::fmt::Display for AggregationFormula<M> {
@@ -56,8 +58,8 @@ impl<M: Metric> From<FormulaParams<AggregationFormula<M>, M>> for AggregationFor
     fn from(params: FormulaParams<AggregationFormula<M>, M>) -> Self {
         Self {
             formula: params.formula,
-            metric: params.metric,
             instructions_tx: params.instructions_tx,
+            phantom: PhantomData,
         }
     }
 }
@@ -66,8 +68,8 @@ impl<M: Metric> From<AggregationFormula<M>> for FormulaParams<AggregationFormula
     fn from(formula: AggregationFormula<M>) -> Self {
         FormulaParams {
             formula: formula.formula,
-            metric: formula.metric,
             instructions_tx: formula.instructions_tx,
+            phantom: PhantomData,
         }
     }
 }

src/logical_meter/formula/coalesce_formula.rs

@@ -3,6 +3,8 @@
 
 //! An coalesce formula.
 
+use std::marker::PhantomData;
+
 use super::{FormulaParams, FormulaSubscriber, GraphFormulaConnector};
 use crate::{
     Error, Sample, logical_meter::logical_meter_actor, metric::Metric, quantity::Quantity,
@@ -13,8 +15,8 @@ use tokio::sync::{broadcast, mpsc, oneshot};
 #[derive(Clone)]
 pub struct CoalesceFormula<M: Metric> {
     formula: frequenz_microgrid_component_graph::CoalesceFormula,
-    metric: M,
     instructions_tx: mpsc::Sender<logical_meter_actor::Instruction>,
+    phantom: PhantomData<M>,
 }
 
 impl<M: Metric> std::fmt::Display for CoalesceFormula<M> {
@@ -56,8 +58,8 @@ impl<M: Metric> From<FormulaParams<CoalesceFormula<M>, M>> for CoalesceFormula<M
     fn from(params: FormulaParams<CoalesceFormula<M>, M>) -> Self {
         Self {
             formula: params.formula,
-            metric: params.metric,
             instructions_tx: params.instructions_tx,
+            phantom: PhantomData,
         }
     }
 }
@@ -66,7 +68,7 @@ impl<M: Metric> From<CoalesceFormula<M>> for FormulaParams<CoalesceFormula<M>, M
     fn from(formula: CoalesceFormula<M>) -> Self {
         FormulaParams {
             formula: formula.formula,
-            metric: formula.metric,
+            phantom: formula.phantom,
             instructions_tx: formula.instructions_tx,
         }
     }

src/logical_meter/formula/graph_formula_provider.rs

@@ -22,7 +22,6 @@ macro_rules! graph_formula_provider {
 
         fn $fnname(
             _graph: &ComponentGraph<ElectricalComponent, ElectricalComponentConnection>,
-            metric: Self::MetricType,
             _instructions_tx: mpsc::Sender<logical_meter_actor::Instruction>,
             $($idsparam: Option<BTreeSet<u64>>,)?
             $($idparam: u64,)?
@@ -31,7 +30,7 @@ macro_rules! graph_formula_provider {
                 format!(
                     "The component graph does not support {} formula generation for {}.",
                     stringify!($fnname),
-                    metric.to_string()
+                    Self::MetricType::str_name()
                 )
             ));
         }
@@ -70,7 +69,6 @@ macro_rules! impl_graph_formula_provider {
 
         fn $fnname(
             graph: &ComponentGraph<ElectricalComponent, ElectricalComponentConnection>,
-            metric: Self::MetricType,
             instructions_tx: mpsc::Sender<logical_meter_actor::Instruction>,
             $($idsparam: Option<BTreeSet<u64>>,)?
             $($idparam: u64,)?
@@ -80,7 +78,7 @@ macro_rules! impl_graph_formula_provider {
                     format!("Could not get {} formula: {e}", stringify!($fnname))
                 )
             })?;
-            Ok(FormulaParams::new(formula, metric, instructions_tx).into())
+            Ok(FormulaParams::new(formula, instructions_tx).into())
         }
 
     )+};