med64 0.0.2

Headless MED64 electrophysiology toolkit: .modat I/O, spike/burst analysis, assays, spike-rate maps, and CSV/HTML/SVG/HDF5 export
Documentation
use std::fs::File;
use std::io::{BufWriter, Write};
use std::path::{Path, PathBuf};

use crate::block::Med64DataBlock;
use crate::error::{Med64Error, Result};
use crate::header::Med64Header;

pub mod csv;
pub mod json;

pub use csv::CsvWriter;
pub use json::JsonWriter;

/// Write MED64 `.modat` binary recordings.
pub struct ModatWriter {
    path: PathBuf,
    header: Med64Header,
    writer: BufWriter<File>,
    blocks_written: u32,
}

impl ModatWriter {
    pub fn create(path: impl AsRef<Path>, header: Med64Header) -> Result<Self> {
        let path = path.as_ref().to_path_buf();
        let file = File::create(&path)
            .map_err(|source| Med64Error::WriteIo { path: path.clone(), source })?;
        let mut writer = BufWriter::new(file);
        let mut header = header;
        header.path = path.clone();
        header.write_to(&mut writer)?;
        Ok(Self { path, header, writer, blocks_written: 0 })
    }

    pub fn write_block(&mut self, block: &Med64DataBlock) -> Result<()> {
        block.write_to(&mut self.writer, &self.header)?;
        self.blocks_written += 1;
        Ok(())
    }

    pub fn finish(mut self) -> Result<()> {
        self.writer
            .flush()
            .map_err(|source| Med64Error::WriteIo { path: self.path.clone(), source })
    }

    pub fn blocks_written(&self) -> u32 {
        self.blocks_written
    }
}

/// Unified writer enum for conversion targets.
pub enum Writer {
    Modat(ModatWriter),
    Csv(CsvWriter),
    Json(JsonWriter),
}

impl Writer {
    pub fn modat(path: impl AsRef<Path>, header: Med64Header) -> Result<Self> {
        Ok(Self::Modat(ModatWriter::create(path, header)?))
    }

    pub fn csv(path: impl AsRef<Path>) -> Result<Self> {
        Ok(Self::Csv(CsvWriter::create(path)?))
    }

    pub fn json(
        path: impl AsRef<Path>,
        header: &Med64Header,
        include_samples: bool,
    ) -> Result<Self> {
        Ok(Self::Json(JsonWriter::create(path, header, include_samples)?))
    }

    pub fn write_block(&mut self, header: &Med64Header, block: &Med64DataBlock) -> Result<()> {
        match self {
            Self::Modat(w) => w.write_block(block),
            Self::Csv(w) => w.write_block(header, block),
            Self::Json(w) => w.write_block(header, block),
        }
    }

    pub fn finish(self) -> Result<()> {
        match self {
            Self::Modat(w) => w.finish(),
            Self::Csv(w) => w.finish(),
            Self::Json(w) => w.finish(),
        }
    }
}