use crate::Error;
use crate::kripke::{Model, World};
use crate::limits::Limits;
use crate::linear::sequents::name;
use crate::wire::{self, Readable};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[derive(Clone, Debug, Serialize, Deserialize)]
struct WorldForm {
atoms: Vec<String>,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
falsity: bool,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
arrows: Vec<u32>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub(super) struct ModelForm {
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "wire::version"
)]
version: Option<u32>,
worlds: Vec<WorldForm>,
#[serde(default)]
world: u32,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct StrictWorld {
atoms: Vec<String>,
#[serde(default)]
falsity: bool,
#[serde(default)]
arrows: Vec<u32>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct StrictModel {
#[serde(default, deserialize_with = "wire::version")]
version: Option<u32>,
worlds: Vec<StrictWorld>,
#[serde(default)]
world: u32,
}
impl From<StrictModel> for ModelForm {
fn from(strict: StrictModel) -> Self {
Self {
version: strict.version,
worlds: strict
.worlds
.into_iter()
.map(|w| WorldForm {
atoms: w.atoms,
falsity: w.falsity,
arrows: w.arrows,
})
.collect(),
world: strict.world,
}
}
}
impl From<&Model> for ModelForm {
fn from(model: &Model) -> Self {
Self {
version: None,
worlds: model
.worlds
.iter()
.map(|w| WorldForm {
atoms: w.atoms.clone(),
falsity: w.falsity,
arrows: w.arrows.clone(),
})
.collect(),
world: model.world,
}
}
}
impl ModelForm {
pub(super) fn within(self, limits: &Limits) -> Result<Model, Error> {
let size = self.worlds.iter().fold(self.worlds.len() as u64, |n, w| {
n.saturating_add(w.atoms.len() as u64)
.saturating_add(w.arrows.len() as u64)
});
if let Some(limit) = limits.occurrences
&& size > limit
{
return Err(Error::Refused(crate::Refusal::Occurrences {
occurrences: size,
limit,
}));
}
let mut worlds = Vec::with_capacity(self.worlds.len());
for form in self.worlds {
let mut atoms = Vec::with_capacity(form.atoms.len());
for atom in form.atoms {
let atom = name::normalized(&atom).into_owned();
name::check(&atom)?;
atoms.push(atom);
}
worlds.push(World::new(atoms, form.falsity, form.arrows));
}
Ok(Model::new(worlds, self.world))
}
}
impl Serialize for Model {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut form = ModelForm::from(self);
form.version = Some(wire::KRIPKE);
form.serialize(serializer)
}
}
impl<'a> Deserialize<'a> for Model {
fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
Self::read(deserializer, &Limits::default())
}
}
impl crate::sealed::Readable for Model {}
impl Readable for Model {
const FORM: &'static str = "Kripke model";
fn read<'de, D: Deserializer<'de>>(deserializer: D, limits: &Limits) -> Result<Self, D::Error> {
ModelForm::from(StrictModel::deserialize(deserializer)?)
.within(limits)
.map_err(wire::fail)
}
}