fn deserialize()

in core/bench/report/src/types/group_metrics.rs [35:116]
70 lines of code
13 McCabe index (conditional complexity)

    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct BenchmarkGroupMetricsVisitor;

        impl<'de> Visitor<'de> for BenchmarkGroupMetricsVisitor {
            type Value = BenchmarkGroupMetrics;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct BenchmarkGroupMetrics")
            }

            fn visit_map<V>(self, mut map: V) -> Result<BenchmarkGroupMetrics, V::Error>
            where
                V: MapAccess<'de>,
            {
                let mut summary: Option<BenchmarkGroupMetricsSummary> = None;
                let mut avg_throughput_mb_ts: Option<TimeSeries> = None;
                let mut avg_throughput_msg_ts: Option<TimeSeries> = None;
                let mut avg_latency_ts: Option<TimeSeries> = None;

                while let Some(key) = map.next_key::<String>()? {
                    match key.as_str() {
                        "summary" => {
                            summary = Some(map.next_value()?);
                        }
                        "avg_throughput_mb_ts" => {
                            avg_throughput_mb_ts = Some(map.next_value()?);
                        }
                        "avg_throughput_msg_ts" => {
                            avg_throughput_msg_ts = Some(map.next_value()?);
                        }
                        "avg_latency_ts" => {
                            avg_latency_ts = Some(map.next_value()?);
                        }
                        _ => {
                            let _ = map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }

                let summary = summary.ok_or_else(|| de::Error::missing_field("summary"))?;
                let avg_throughput_mb_ts = avg_throughput_mb_ts
                    .ok_or_else(|| de::Error::missing_field("avg_throughput_mb_ts"))?;
                let avg_throughput_msg_ts = avg_throughput_msg_ts
                    .ok_or_else(|| de::Error::missing_field("avg_throughput_msg_ts"))?;
                let avg_latency_ts =
                    avg_latency_ts.ok_or_else(|| de::Error::missing_field("avg_latency_ts"))?;

                let mut updated_summary = summary.clone();

                // Calculate and populate missing statistics from the time series data
                if updated_summary.min_latency_ms == 0.0 {
                    if let Some(min_val) = min(&avg_latency_ts) {
                        updated_summary.min_latency_ms = min_val;
                    }
                }

                if updated_summary.max_latency_ms == 0.0 {
                    if let Some(max_val) = max(&avg_latency_ts) {
                        updated_summary.max_latency_ms = max_val;
                    }
                }

                if updated_summary.std_dev_latency_ms == 0.0 {
                    if let Some(std_dev_val) = std_dev(&avg_latency_ts) {
                        updated_summary.std_dev_latency_ms = std_dev_val;
                    }
                }

                Ok(BenchmarkGroupMetrics {
                    summary: updated_summary,
                    avg_throughput_mb_ts,
                    avg_throughput_msg_ts,
                    avg_latency_ts,
                })
            }
        }

        deserializer.deserialize_map(BenchmarkGroupMetricsVisitor)
    }