use super::parser::parse_procpar;
use crate::raw::{InputSource, ParameterError};
use std::collections::BTreeMap;
#[derive(Clone, Debug, PartialEq)]
pub struct Parameters {
pub(super) records: BTreeMap<String, ParameterRecord>,
pub(super) raw_text: String,
pub(super) file_header: Option<FileHeader>,
pub(super) block_headers: Vec<BlockHeader>,
pub(super) input_source: InputSource,
}
impl Parameters {
pub fn parse(text: &str) -> Result<Self, ParameterError> {
parse_procpar(text, InputSource::memory("procpar"))
}
pub fn get(&self, name: &str) -> Option<&ParameterRecord> {
self.records.get(name)
}
pub fn iter(&self) -> impl Iterator<Item = (&str, &ParameterRecord)> {
self.records
.iter()
.map(|(name, record)| (name.as_str(), record))
}
pub fn raw_text(&self) -> &str {
&self.raw_text
}
pub fn file_header(&self) -> Option<&FileHeader> {
self.file_header.as_ref()
}
pub fn block_headers(&self) -> &[BlockHeader] {
&self.block_headers
}
}
#[non_exhaustive]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ParameterType {
Real,
String,
}
#[non_exhaustive]
#[derive(Clone, Debug, PartialEq)]
pub enum ParameterValue {
Real(f64),
String(String),
}
impl ParameterValue {
pub fn as_f64(&self) -> Option<f64> {
match self {
Self::Real(value) => Some(*value),
Self::String(_) => None,
}
}
pub fn as_str(&self) -> Option<&str> {
match self {
Self::String(value) => Some(value),
Self::Real(_) => None,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct ParameterRecord {
pub(super) subtype: i16,
pub(super) parameter_type: ParameterType,
pub(super) maximum: f64,
pub(super) minimum: f64,
pub(super) step: f64,
pub(super) group: i16,
pub(super) display_group: i16,
pub(super) protection: i32,
pub(super) active: bool,
pub(super) values: Vec<ParameterValue>,
pub(super) enumerated_values: Vec<ParameterValue>,
}
impl ParameterRecord {
pub fn subtype(&self) -> i16 {
self.subtype
}
pub fn parameter_type(&self) -> ParameterType {
self.parameter_type
}
pub fn maximum(&self) -> f64 {
self.maximum
}
pub fn minimum(&self) -> f64 {
self.minimum
}
pub fn step(&self) -> f64 {
self.step
}
pub fn group(&self) -> i16 {
self.group
}
pub fn display_group(&self) -> i16 {
self.display_group
}
pub fn protection(&self) -> i32 {
self.protection
}
pub fn active(&self) -> bool {
self.active
}
pub fn values(&self) -> &[ParameterValue] {
&self.values
}
pub fn enumerated_values(&self) -> &[ParameterValue] {
&self.enumerated_values
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FileHeader {
pub(super) raw_bytes: [u8; 32],
pub(super) nblocks: usize,
pub(super) ntraces: usize,
pub(super) stored_values_per_trace: usize,
pub(super) bytes_per_value: usize,
pub(super) trace_bytes: usize,
pub(super) block_bytes: usize,
pub(super) version_id: u16,
pub(super) status: u16,
pub(super) block_headers: usize,
pub(super) raw_block_header_word: u32,
}
impl FileHeader {
pub fn raw_bytes(&self) -> &[u8; 32] {
&self.raw_bytes
}
pub fn nblocks(&self) -> usize {
self.nblocks
}
pub fn ntraces(&self) -> usize {
self.ntraces
}
pub fn stored_values_per_trace(&self) -> usize {
self.stored_values_per_trace
}
pub fn bytes_per_value(&self) -> usize {
self.bytes_per_value
}
pub fn trace_bytes(&self) -> usize {
self.trace_bytes
}
pub fn block_bytes(&self) -> usize {
self.block_bytes
}
pub fn version_id(&self) -> u16 {
self.version_id
}
pub fn version(&self) -> u16 {
self.version_id & 0x003f
}
pub fn status(&self) -> u16 {
self.status
}
pub fn block_headers(&self) -> usize {
self.block_headers
}
pub fn raw_block_header_word(&self) -> u32 {
self.raw_block_header_word
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct BlockHeader {
pub(super) raw_bytes: [u8; 28],
pub(super) scale: i16,
pub(super) status: u16,
pub(super) index: i16,
pub(super) mode: u16,
pub(super) ctcount: i32,
pub(super) left_phase: f32,
pub(super) right_phase: f32,
pub(super) level: f32,
pub(super) tilt: f32,
}
impl BlockHeader {
pub fn raw_bytes(&self) -> &[u8; 28] {
&self.raw_bytes
}
pub fn scale(&self) -> i16 {
self.scale
}
pub fn status(&self) -> u16 {
self.status
}
pub fn index(&self) -> i16 {
self.index
}
pub fn mode(&self) -> u16 {
self.mode
}
pub fn ctcount(&self) -> i32 {
self.ctcount
}
pub fn left_phase(&self) -> f32 {
self.left_phase
}
pub fn right_phase(&self) -> f32 {
self.right_phase
}
pub fn level(&self) -> f32 {
self.level
}
pub fn tilt(&self) -> f32 {
self.tilt
}
}
impl BlockHeader {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&[u8; 28],
&i16,
&u16,
&i16,
&u16,
&i32,
&f32,
&f32,
&f32,
&f32,
) {
(
&self.raw_bytes,
&self.scale,
&self.status,
&self.index,
&self.mode,
&self.ctcount,
&self.left_phase,
&self.right_phase,
&self.level,
&self.tilt,
)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: ([u8; 28], i16, u16, i16, u16, i32, f32, f32, f32, f32),
) -> Result<Self, crate::internal::ModelError> {
let (raw_bytes, scale, status, index, mode, ctcount, left_phase, right_phase, level, tilt) =
parts;
let value = Self {
raw_bytes,
scale,
status,
index,
mode,
ctcount,
left_phase,
right_phase,
level,
tilt,
};
Ok(value)
}
}
impl FileHeader {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&[u8; 32],
&usize,
&usize,
&usize,
&usize,
&usize,
&usize,
&u16,
&u16,
&usize,
&u32,
) {
(
&self.raw_bytes,
&self.nblocks,
&self.ntraces,
&self.stored_values_per_trace,
&self.bytes_per_value,
&self.trace_bytes,
&self.block_bytes,
&self.version_id,
&self.status,
&self.block_headers,
&self.raw_block_header_word,
)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (
[u8; 32],
usize,
usize,
usize,
usize,
usize,
usize,
u16,
u16,
usize,
u32,
),
) -> Result<Self, crate::internal::ModelError> {
let (
raw_bytes,
nblocks,
ntraces,
stored_values_per_trace,
bytes_per_value,
trace_bytes,
block_bytes,
version_id,
status,
block_headers,
raw_block_header_word,
) = parts;
let value = Self {
raw_bytes,
nblocks,
ntraces,
stored_values_per_trace,
bytes_per_value,
trace_bytes,
block_bytes,
version_id,
status,
block_headers,
raw_block_header_word,
};
Ok(value)
}
}
impl ParameterRecord {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&i16,
&ParameterType,
&f64,
&f64,
&f64,
&i16,
&i16,
&i32,
&bool,
&Vec<ParameterValue>,
&Vec<ParameterValue>,
) {
(
&self.subtype,
&self.parameter_type,
&self.maximum,
&self.minimum,
&self.step,
&self.group,
&self.display_group,
&self.protection,
&self.active,
&self.values,
&self.enumerated_values,
)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (
i16,
ParameterType,
f64,
f64,
f64,
i16,
i16,
i32,
bool,
Vec<ParameterValue>,
Vec<ParameterValue>,
),
) -> Result<Self, crate::internal::ModelError> {
let (
subtype,
parameter_type,
maximum,
minimum,
step,
group,
display_group,
protection,
active,
values,
enumerated_values,
) = parts;
let value = Self {
subtype,
parameter_type,
maximum,
minimum,
step,
group,
display_group,
protection,
active,
values,
enumerated_values,
};
Ok(value)
}
}
impl Parameters {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&BTreeMap<String, ParameterRecord>,
&String,
&Option<FileHeader>,
&Vec<BlockHeader>,
&InputSource,
) {
(
&self.records,
&self.raw_text,
&self.file_header,
&self.block_headers,
&self.input_source,
)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (
BTreeMap<String, ParameterRecord>,
String,
Option<FileHeader>,
Vec<BlockHeader>,
InputSource,
),
) -> Result<Self, crate::internal::ModelError> {
let (records, raw_text, file_header, block_headers, input_source) = parts;
let value = Self {
records,
raw_text,
file_header,
block_headers,
input_source,
};
Ok(value)
}
}