use crate::provenance::CanonicalDatasetDigests;
#[derive(Clone, Debug, PartialEq)]
pub struct ExecutionSegment {
end_record: usize,
output: CanonicalDatasetDigests,
environment: ExecutionEnvironment,
accepted_archive: bool,
}
#[derive(Clone, Debug, PartialEq)]
pub struct ExecutionEnvironment {
crate_version: String,
architecture: String,
operating_system: String,
numerical_dependencies: Option<String>,
explicit_fft_backend: String,
build_identifier: Option<String>,
floating_point_configuration: Option<String>,
}
impl ExecutionEnvironment {
pub(crate) fn current() -> Self {
Self {
crate_version: env!("CARGO_PKG_VERSION").into(),
architecture: std::env::consts::ARCH.into(),
operating_system: std::env::consts::OS.into(),
numerical_dependencies: Some("rustfft=6.4.1".into()),
explicit_fft_backend: crate::processing::kernels::fft::BACKEND.into(),
build_identifier: Some(env!("NMR_BUILD_SHA256").into()),
floating_point_configuration: None,
}
}
pub fn crate_version(&self) -> &str {
&self.crate_version
}
pub fn architecture(&self) -> &str {
&self.architecture
}
pub fn operating_system(&self) -> &str {
&self.operating_system
}
pub fn build_identifier(&self) -> Option<&str> {
self.build_identifier.as_deref()
}
pub fn numerical_dependency_versions(&self) -> Option<&str> {
self.numerical_dependencies.as_deref()
}
pub fn explicit_fft_backend(&self) -> &str {
&self.explicit_fft_backend
}
pub fn floating_point_configuration(&self) -> Option<&str> {
self.floating_point_configuration.as_deref()
}
}
impl ExecutionSegment {
pub fn accepted_archive(&self) -> bool {
self.accepted_archive
}
pub fn end_record(&self) -> usize {
self.end_record
}
pub fn output_digests(&self) -> CanonicalDatasetDigests {
self.output
}
pub fn environment(&self) -> &ExecutionEnvironment {
&self.environment
}
}
impl ExecutionEnvironment {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&String,
&String,
&String,
&Option<String>,
&String,
&Option<String>,
&Option<String>,
) {
(
&self.crate_version,
&self.architecture,
&self.operating_system,
&self.numerical_dependencies,
&self.explicit_fft_backend,
&self.build_identifier,
&self.floating_point_configuration,
)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (
String,
String,
String,
Option<String>,
String,
Option<String>,
Option<String>,
),
) -> Result<Self, crate::internal::ModelError> {
let (
crate_version,
architecture,
operating_system,
numerical_dependencies,
explicit_fft_backend,
build_identifier,
floating_point_configuration,
) = parts;
let value = Self {
crate_version,
architecture,
operating_system,
numerical_dependencies,
explicit_fft_backend,
build_identifier,
floating_point_configuration,
};
Ok(value)
}
}
impl ExecutionSegment {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&usize,
&CanonicalDatasetDigests,
&ExecutionEnvironment,
&bool,
) {
(
&self.end_record,
&self.output,
&self.environment,
&self.accepted_archive,
)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (usize, CanonicalDatasetDigests, ExecutionEnvironment, bool),
) -> Result<Self, crate::internal::ModelError> {
let (end_record, output, environment, accepted_archive) = parts;
let value = Self {
end_record,
output,
environment,
accepted_archive,
};
Ok(value)
}
}
impl ExecutionSegment {
pub(super) fn new(end_record: usize, output: CanonicalDatasetDigests) -> Self {
Self {
accepted_archive: false,
end_record,
output,
environment: ExecutionEnvironment::current(),
}
}
pub(super) fn accept_archive(&mut self) {
self.accepted_archive = true;
}
}