pub use crate::ReadLimits;
pub use crate::acquisition::{
AssertionId, AxisIndex, ChemicalShiftReference, ComponentEvidence, DirectSamples,
EvidenceValidationError, GroupDelayState, IndirectComponents, LinearComponentTransform,
ModulationIndexDomain, NormalizationEvidence, NormalizationFact, PendingGroupDelay,
PeriodicLaneModulation, RawAxisKind, ResolutionAuthority, ResolvedComponentTransform, RuleId,
TransformValidationError, TrustClass,
};
pub use crate::io::Reader;
pub use crate::provenance::{
SampleNormalization, SourceDigest, SourceFile, SourceId, SourceIdentity, SourceKind,
};
pub use crate::raw::model::{
AccessError, DiffusionAcquisition, ObservationOrdinal, RawAxis, RawData, RawDataset,
RawDatasetBuilder, RawDescriptor, RawFormat, RawLayout, RawMetadata, RawProvenance,
SamplingCoordinate, SamplingSchedule, SparseTrace, StorageOrder, ValidationError,
VendorMetadata,
};
pub use crate::read_error::{
InputSource, ParameterError, ParameterErrorKind, ReadError, ReadErrorKind, ReadErrorReason,
ReadResource, UnsupportedFeatureCode,
};
use crate::Complex64;
use std::path::Path;
#[derive(Clone, Debug, Default)]
pub struct OpenOptions {
limits: ReadLimits,
varian: Option<crate::formats::varian::ReadAssertions>,
experimental_vendor_semantics: bool,
}
impl OpenOptions {
pub fn new() -> Self {
Self::default()
}
pub fn allow_experimental_vendor_semantics(mut self, value: bool) -> Self {
self.experimental_vendor_semantics = value;
self
}
pub fn limits(mut self, value: ReadLimits) -> Self {
self.limits = value;
self
}
pub fn varian_assertions(mut self, value: crate::formats::varian::ReadAssertions) -> Self {
self.varian = Some(value);
self
}
pub fn read_limits(&self) -> ReadLimits {
self.limits
}
pub fn open(&self, path: impl AsRef<Path>) -> Result<Reader, ReadError> {
self.open_with_context(path, &mut crate::ExecutionContext::default())
}
pub fn open_with_context(
&self,
path: impl AsRef<Path>,
control: &mut crate::ExecutionContext<'_>,
) -> Result<Reader, ReadError> {
control.begin(crate::execution::ExecutionStage::Reading, None, None)?;
let path = path.as_ref();
let candidate = crate::reading::resolver::resolve_raw_and_select(path)?;
candidate.validate_required()?;
let reader = candidate.open_raw(
&self.limits,
self.varian.as_ref(),
self.experimental_vendor_semantics,
None,
control.cancellation(),
)?;
control.check_cancelled()?;
Ok(reader)
}
}
pub fn detect(path: impl AsRef<Path>) -> Result<RawFormat, ReadError> {
let path = path.as_ref();
let candidate = crate::reading::resolver::resolve_raw_and_select(path)?;
match candidate.format {
crate::Format::Raw(format) => Ok(format),
crate::Format::Processed(_) => unreachable!(),
}
}
pub fn open(path: impl AsRef<Path>) -> Result<Reader, ReadError> {
OpenOptions::new().open(path)
}
pub fn read(path: impl AsRef<Path>) -> Result<RawDataset, ReadError> {
read_with_context(path, &mut crate::ExecutionContext::default())
}
#[derive(Clone, Debug, PartialEq)]
pub struct Trace {
coordinate: Box<[usize]>,
observation_ordinal: Option<ObservationOrdinal>,
direct_points: usize,
component_lanes: Box<[usize]>,
samples: Box<[Complex64]>,
}
impl Trace {
pub(crate) fn new(
coordinate: &[usize],
observation_ordinal: Option<ObservationOrdinal>,
direct_points: usize,
component_lanes: &[usize],
samples: Vec<Complex64>,
) -> Result<Self, ReadError> {
let component_count = component_lanes
.iter()
.try_fold(1usize, |count, &lanes| count.checked_mul(lanes))
.ok_or(ReadError::SizeOverflow)?;
let expected = direct_points
.checked_mul(component_count)
.ok_or(ReadError::SizeOverflow)?;
if samples.len() != expected {
return Err(ReadError::corrupt(
InputSource::memory("decoded trace"),
"decoded trace length does not match its component layout",
));
}
Ok(Self {
coordinate: coordinate.into(),
observation_ordinal,
direct_points,
component_lanes: component_lanes.into(),
samples: samples.into(),
})
}
pub fn coordinate(&self) -> &[usize] {
&self.coordinate
}
pub fn observation_ordinal(&self) -> Option<ObservationOrdinal> {
self.observation_ordinal
}
pub fn direct_points(&self) -> usize {
self.direct_points
}
pub fn component_lanes(&self) -> &[usize] {
&self.component_lanes
}
pub fn samples(&self) -> &[Complex64] {
&self.samples
}
}
impl std::ops::Deref for Trace {
type Target = [Complex64];
fn deref(&self) -> &Self::Target {
self.samples()
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Region {
start: Box<[usize]>,
shape: Box<[usize]>,
}
impl Region {
pub fn new(
start: impl Into<Box<[usize]>>,
shape: impl Into<Box<[usize]>>,
) -> Result<Self, ValidationError> {
let start = start.into();
let shape = shape.into();
if start.len() != shape.len() || shape.is_empty() || shape.contains(&0) {
return Err(ValidationError::InvalidRegion);
}
Ok(Self { start, shape })
}
pub fn start(&self) -> &[usize] {
&self.start
}
pub fn shape(&self) -> &[usize] {
&self.shape
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct RegionData {
region: Region,
data: RawData,
}
impl RegionData {
pub(crate) fn new(region: Region, data: RawData) -> Self {
Self { region, data }
}
pub fn region(&self) -> &Region {
&self.region
}
pub fn data(&self) -> &RawData {
&self.data
}
pub fn into_data(self) -> RawData {
self.data
}
}
pub fn read_with_context(
path: impl AsRef<Path>,
control: &mut crate::ExecutionContext<'_>,
) -> Result<RawDataset, ReadError> {
OpenOptions::new()
.open_with_context(path, control)?
.into_dataset_with_context(control)
}
pub(crate) mod model;