nex5file 1.2.0

Read and write NeuroExplorer .nex and .nex5 files
Documentation
#[cfg(not(feature = "std"))]
use crate::compat::prelude::*;

use super::{default_metadata, max_of_slice_or_zero, Timestamps};
use crate::error::{NexError, Result};
use crate::format::VariableHeader;
use serde_json::Value as JsonValue;

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum MarkerFieldValue {
    Number(u32),
    String(String),
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct MarkerVariable {
    pub header: VariableHeader,
    pub metadata: JsonValue,
    pub timestamps: Timestamps,
    pub marker_field_names: Vec<String>,
    pub marker_fields: Vec<Vec<MarkerFieldValue>>,
}

impl MarkerVariable {
    pub fn new(header: VariableHeader) -> Self {
        let name = header.name.clone();
        Self {
            header,
            metadata: default_metadata(&name),
            timestamps: Timestamps::new(),
            marker_field_names: Vec::new(),
            marker_fields: Vec::new(),
        }
    }

    pub fn timestamps_copy(&self) -> Vec<f64> {
        self.timestamps.as_f64_vec()
    }

    pub fn marker_field_names_copy(&self) -> Vec<String> {
        self.marker_field_names.clone()
    }

    pub fn markers_copy(&self) -> Vec<Vec<MarkerFieldValue>> {
        self.marker_fields.clone()
    }

    pub fn maximum_timestamp(&self) -> f64 {
        max_of_slice_or_zero(&self.timestamps.as_f64_vec())
    }

    pub fn count_for_header(&self) -> u64 {
        self.timestamps.len() as u64
    }

    pub fn bytes_in_data_with_header(&self, hw: &VariableHeader) -> u64 {
        let num_markers = self.timestamps.len();
        let mut total = super::timestamp_payload_bytes(num_markers, hw);
        total += (self.marker_field_names.len() as u64)
            * (64 + hw.marker_length as u64 * num_markers as u64);
        total
    }

    pub fn all_marker_values_are_numeric(&self) -> bool {
        self.marker_fields
            .iter()
            .flatten()
            .all(|v| matches!(v, MarkerFieldValue::Number(_)))
    }

    pub fn if_number_strings_store_as_numbers(&mut self) {
        if !self.all_marker_values_are_numeric() {
            for field in &mut self.marker_fields {
                for value in field.iter_mut() {
                    if let MarkerFieldValue::String(s) = value {
                        if let Ok(n) = s.parse::<u32>() {
                            *value = MarkerFieldValue::Number(n);
                        }
                    }
                }
            }
        }
    }

    pub fn calc_marker_length(&mut self) -> crate::error::Result<()> {
        self.calc_marker_length_checked()
    }

    pub fn calc_marker_length_checked(&mut self) -> Result<()> {
        self.header.n_markers = self.marker_field_names.len() as i32;
        if self.all_marker_values_are_numeric() {
            self.header.marker_length = 6;
            self.header.marker_data_type = 1;
            Ok(())
        } else {
            self.header.marker_data_type = 0;
            let mut max_string_length = 0usize;
            for field in &self.marker_fields {
                for value in field {
                    match value {
                        MarkerFieldValue::String(s) => {
                            max_string_length = max_string_length.max(s.len());
                        }
                        MarkerFieldValue::Number(_) => return Err(NexError::InvalidMarkerValues),
                    }
                }
            }
            self.header.marker_length = (max_string_length + 1).max(6) as i32;
            Ok(())
        }
    }
}