use serde::{Deserialize, Serialize};
use thiserror::Error;
use crate::initial_state::{InitialState, InitialStateArtifactReference, InitialStateError};
use crate::interaction::{
InteractionArtifactLoadError, InteractionArtifactReference, InteractionMatrix,
};
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct EcologicalInputs {
interaction: InteractionArtifactReference,
initial_state: InitialStateArtifactReference,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct EcologicalInputsDocument {
interaction: InteractionArtifactReference,
initial_state: InitialStateArtifactReference,
}
impl<'de> Deserialize<'de> for EcologicalInputs {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let document = EcologicalInputsDocument::deserialize(deserializer)?;
Self::new(document.interaction, document.initial_state).map_err(serde::de::Error::custom)
}
}
impl EcologicalInputs {
pub fn new(
interaction: InteractionArtifactReference,
initial_state: InitialStateArtifactReference,
) -> Result<Self, EcologicalInputsError> {
let inputs = Self {
interaction,
initial_state,
};
inputs.validate()?;
Ok(inputs)
}
pub fn validate(&self) -> Result<(), EcologicalInputsError> {
self.interaction.validate()?;
self.initial_state.validate()?;
let interaction_species = self.interaction.descriptor().species();
let initial_taxa = self.initial_state.descriptor().num_taxa();
if interaction_species != initial_taxa {
return Err(EcologicalInputsError::TaxonDimensionMismatch {
interaction_species,
initial_taxa,
});
}
Ok(())
}
pub const fn interaction(&self) -> &InteractionArtifactReference {
&self.interaction
}
pub const fn initial_state(&self) -> &InitialStateArtifactReference {
&self.initial_state
}
pub fn resolve(&self) -> Result<ResolvedEcologicalInputs, EcologicalInputsError> {
self.validate()?;
let interaction = self.interaction.resolve()?;
let initial_state = self.initial_state.resolve()?;
if interaction.species() != initial_state.num_taxa() {
return Err(EcologicalInputsError::TaxonDimensionMismatch {
interaction_species: interaction.species(),
initial_taxa: initial_state.num_taxa(),
});
}
Ok(ResolvedEcologicalInputs {
interaction,
initial_state,
})
}
}
#[derive(Debug)]
pub struct ResolvedEcologicalInputs {
interaction: InteractionMatrix,
initial_state: InitialState,
}
impl ResolvedEcologicalInputs {
pub const fn interaction(&self) -> &InteractionMatrix {
&self.interaction
}
pub const fn initial_state(&self) -> &InitialState {
&self.initial_state
}
pub fn into_parts(self) -> (InteractionMatrix, InitialState) {
(self.interaction, self.initial_state)
}
}
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum EcologicalInputsError {
#[error(transparent)]
Interaction(#[from] InteractionArtifactLoadError),
#[error(transparent)]
InitialState(#[from] InitialStateError),
#[error(
"interaction has {interaction_species} species but initial state has {initial_taxa} taxa"
)]
TaxonDimensionMismatch {
interaction_species: usize,
initial_taxa: usize,
},
}