use std::fs::File;
use std::io::{BufWriter, Write};
use std::path::PathBuf;
use crate::block::Med64DataBlock;
use crate::error::{Med64Error, Result};
use crate::header::Med64Header;
pub struct JsonWriter {
path: PathBuf,
writer: BufWriter<File>,
include_samples: bool,
first_block: bool,
}
impl JsonWriter {
pub fn create(
path: impl AsRef<std::path::Path>,
header: &Med64Header,
include_samples: bool,
) -> 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);
write!(writer, "{{\"header\":{{").map_err(io_err(&path))?;
write_header_json(&mut writer, header)?;
if include_samples {
write!(writer, "}},\"blocks\":[").map_err(io_err(&path))?;
} else {
write!(writer, "}}}}").map_err(io_err(&path))?;
}
Ok(Self { path, writer, include_samples, first_block: true })
}
pub fn write_block(&mut self, header: &Med64Header, block: &Med64DataBlock) -> Result<()> {
if !self.include_samples {
return Ok(());
}
if !self.first_block {
write!(self.writer, ",").map_err(io_err(&self.path))?;
}
self.first_block = false;
let interval = header.interval_ms();
write!(
self.writer,
"{{\"trace\":{},\"block\":{},\"offset_ms\":{},\"points\":[",
block.trace_number, block.block_number, block.block_offset_ms
)
.map_err(io_err(&self.path))?;
for (point_idx, row) in block.samples.iter().enumerate() {
if point_idx > 0 {
write!(self.writer, ",").map_err(io_err(&self.path))?;
}
let time_ms =
block.block_offset_ms + block.trace_offset_ms + point_idx as f64 * interval;
write!(self.writer, "{{\"t\":{time_ms},\"ch\":[").map_err(io_err(&self.path))?;
for (col, &counts) in row.iter().enumerate() {
if col > 0 {
write!(self.writer, ",").map_err(io_err(&self.path))?;
}
write!(
self.writer,
"{{\"i\":{},\"c\":{},\"mv\":{}}}",
block.channel_indices[col],
counts,
header.counts_to_millivolts(counts)
)
.map_err(io_err(&self.path))?;
}
write!(self.writer, "]}}").map_err(io_err(&self.path))?;
}
write!(self.writer, "]}}").map_err(io_err(&self.path))?;
Ok(())
}
pub fn finish(mut self) -> Result<()> {
if self.include_samples {
writeln!(self.writer, "]}}").map_err(io_err(&self.path))?;
}
self.writer.flush().map_err(|source| Med64Error::WriteIo { path: self.path, source })
}
}
fn write_header_json(writer: &mut impl Write, header: &Med64Header) -> Result<()> {
write!(
writer,
"\"sampling_frequency_hz\":{},\"trace_duration_ms\":{},\"conversion_factor\":{},\"channels\":{},\"blocks\":{}",
header.sampling_frequency_hz,
header.trace_duration_ms,
header.conversion_factor,
header.num_active_channels(),
header.number_of_real_data_blocks,
)
.map_err(io_err(&header.path))?;
Ok(())
}
fn io_err(path: &PathBuf) -> impl Fn(std::io::Error) -> Med64Error + '_ {
move |source| Med64Error::WriteIo { path: path.clone(), source }
}