nex5file 1.2.1

Read and write NeuroExplorer .nex and .nex5 files
Documentation
use super::io_helpers::{
    read_bytes, read_f64_le, read_i32_le, read_i64_le, to_string, write_f64_le, write_i32_le,
    write_i64_le, write_padded_string, write_padding,
};
use crate::compat::String;
use crate::error::{NexError, Result};
use crate::format::{NEX5_MAGIC, NEX_MAGIC};
use crate::io_ext::{IoResult, Read, Write};

#[derive(Debug, Clone, PartialEq)]
pub struct FileHeader {
    pub magic_number: i32,
    pub nex_file_version: i32,
    pub comment: String,
    pub frequency: f64,
    pub beg_ticks: i64,
    pub end_ticks: i64,
    pub num_vars: i32,
    pub meta_offset: u64,
    pub beg_seconds: f64,
    pub end_seconds: f64,
}

impl Default for FileHeader {
    fn default() -> Self {
        Self {
            magic_number: 0,
            nex_file_version: 0,
            comment: String::new(),
            frequency: 0.0,
            beg_ticks: 0,
            end_ticks: 0,
            num_vars: 0,
            meta_offset: 0,
            beg_seconds: 0.0,
            end_seconds: 0.0,
        }
    }
}

impl FileHeader {
    pub fn read_from_nex(reader: &mut impl Read) -> Result<Self> {
        let magic_number = read_i32_le(reader).map_err(|_| NexError::InvalidNexHeader)?;
        if magic_number != NEX_MAGIC {
            return Err(NexError::InvalidNexHeader);
        }
        let nex_file_version = read_i32_le(reader).map_err(|_| NexError::InvalidNexHeader)?;
        let comment = to_string(
            &read_bytes(reader, 256).map_err(|_| NexError::InvalidNexHeader)?,
            false,
        );
        let frequency = read_f64_le(reader).map_err(|_| NexError::InvalidNexHeader)?;
        let beg_ticks = read_i32_le(reader).map_err(|_| NexError::InvalidNexHeader)? as i64;
        let end_ticks = read_i32_le(reader).map_err(|_| NexError::InvalidNexHeader)? as i64;
        let num_vars = read_i32_le(reader).map_err(|_| NexError::InvalidNexHeader)?;
        let _padding = read_bytes(reader, 260).map_err(|_| NexError::InvalidNexHeader)?;

        Ok(Self {
            magic_number,
            nex_file_version,
            comment,
            frequency,
            beg_ticks,
            end_ticks,
            num_vars,
            meta_offset: 0,
            beg_seconds: beg_ticks as f64 / frequency,
            end_seconds: end_ticks as f64 / frequency,
        })
    }

    pub fn read_from_nex5(reader: &mut impl Read) -> Result<Self> {
        let magic_number = read_i32_le(reader).map_err(|_| NexError::InvalidNex5Header)?;
        if magic_number != NEX5_MAGIC {
            return Err(NexError::InvalidNex5Header);
        }
        let nex_file_version = read_i32_le(reader).map_err(|_| NexError::InvalidNex5Header)?;
        let comment = to_string(
            &read_bytes(reader, 256).map_err(|_| NexError::InvalidNex5Header)?,
            false,
        );
        let frequency = read_f64_le(reader).map_err(|_| NexError::InvalidNex5Header)?;
        let beg_ticks = read_i64_le(reader).map_err(|_| NexError::InvalidNex5Header)?;
        let num_vars = read_i32_le(reader).map_err(|_| NexError::InvalidNex5Header)?;
        let meta_offset =
            super::io_helpers::read_u64_le(reader).map_err(|_| NexError::InvalidNex5Header)?;
        let end_ticks = read_i64_le(reader).map_err(|_| NexError::InvalidNex5Header)?;
        let _padding = read_bytes(reader, 56).map_err(|_| NexError::InvalidNex5Header)?;

        Ok(Self {
            magic_number,
            nex_file_version,
            comment,
            frequency,
            beg_ticks,
            end_ticks,
            num_vars,
            meta_offset,
            beg_seconds: beg_ticks as f64 / frequency,
            end_seconds: end_ticks as f64 / frequency,
        })
    }

    pub fn write_to_nex(&self, writer: &mut impl Write) -> IoResult<()> {
        write_i32_le(writer, self.magic_number)?;
        write_i32_le(writer, self.nex_file_version)?;
        write_padded_string(writer, &self.comment, 256)?;
        write_f64_le(writer, self.frequency)?;
        write_i32_le(writer, self.beg_ticks as i32)?;
        write_i32_le(writer, self.end_ticks as i32)?;
        write_i32_le(writer, self.num_vars)?;
        write_padding(writer, 260)
    }

    pub fn write_to_nex5(&self, writer: &mut impl Write) -> IoResult<()> {
        write_i32_le(writer, self.magic_number)?;
        write_i32_le(writer, self.nex_file_version)?;
        write_padded_string(writer, &self.comment, 256)?;
        write_f64_le(writer, self.frequency)?;
        write_i64_le(writer, self.beg_ticks)?;
        write_i32_le(writer, self.num_vars)?;
        super::io_helpers::write_u64_le(writer, self.meta_offset)?;
        write_i64_le(writer, self.end_ticks)?;
        write_padding(writer, 56)
    }
}