528 lines
16 KiB
Rust
528 lines
16 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
use std::collections::VecDeque;
|
|
use std::fmt::Debug;
|
|
use std::hash::Hash;
|
|
use std::rc::Rc;
|
|
|
|
use super::element::{IdState, IdType};
|
|
use super::reaction::{PositiveReaction, Reaction};
|
|
use super::set::{BasicSet, PositiveSet, Set};
|
|
use super::translator::{Formatter, PrintableWithTranslator, Translator};
|
|
|
|
pub trait BasicProcess
|
|
where
|
|
Self: Clone
|
|
+ Debug
|
|
+ Default
|
|
+ PartialEq
|
|
+ Eq
|
|
+ Hash
|
|
+ Serialize
|
|
+ PrintableWithTranslator,
|
|
for<'a> Self: Deserialize<'a>,
|
|
{
|
|
type Id;
|
|
type Set: BasicSet;
|
|
|
|
fn concat(&self, new: &Self) -> Self;
|
|
fn all_elements(&self) -> Self::Set;
|
|
fn filter_delta(&self, id: &Self::Id) -> Option<&Self::Set>;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
|
pub enum Process {
|
|
Nill,
|
|
RecursiveIdentifier {
|
|
identifier: IdType,
|
|
},
|
|
EntitySet {
|
|
entities: Set,
|
|
next_process: Rc<Process>,
|
|
},
|
|
Guarded {
|
|
reaction: Reaction,
|
|
next_process: Rc<Process>,
|
|
},
|
|
WaitEntity {
|
|
repeat: i64,
|
|
repeated_process: Rc<Process>,
|
|
next_process: Rc<Process>,
|
|
},
|
|
Summation {
|
|
children: Vec<Rc<Process>>,
|
|
},
|
|
NondeterministicChoice {
|
|
children: Vec<Rc<Process>>,
|
|
},
|
|
}
|
|
|
|
impl BasicProcess for Process {
|
|
type Id = IdType;
|
|
type Set = Set;
|
|
|
|
fn concat(&self, new: &Self) -> Self {
|
|
match (self, new) {
|
|
(
|
|
Self::NondeterministicChoice { children: c1 },
|
|
Self::NondeterministicChoice { children: c2 },
|
|
) => Self::NondeterministicChoice {
|
|
children: [c1.clone(), c2.clone()].concat(),
|
|
},
|
|
(Self::NondeterministicChoice { children }, new)
|
|
| (new, Self::NondeterministicChoice { children }) => {
|
|
let mut new_children = children.clone();
|
|
new_children.push(Rc::new(new.clone()));
|
|
Self::NondeterministicChoice {
|
|
children: new_children,
|
|
}
|
|
}
|
|
(_, _) => Self::NondeterministicChoice {
|
|
children: vec![Rc::new(self.clone()), Rc::new(new.clone())],
|
|
},
|
|
}
|
|
}
|
|
|
|
/// returns all elements used
|
|
fn all_elements(&self) -> Self::Set {
|
|
let mut queue = VecDeque::from([self]);
|
|
let mut elements = Self::Set::default();
|
|
|
|
while let Some(el) = queue.pop_front() {
|
|
match el {
|
|
Self::Nill => {}
|
|
Self::RecursiveIdentifier { identifier: _ } => {}
|
|
Self::EntitySet {
|
|
entities,
|
|
next_process,
|
|
} => {
|
|
elements.push(entities);
|
|
queue.push_back(next_process);
|
|
}
|
|
Self::Guarded {
|
|
reaction,
|
|
next_process,
|
|
} => {
|
|
elements.push(&reaction.reactants);
|
|
elements.push(&reaction.inhibitors);
|
|
elements.push(&reaction.products);
|
|
queue.push_back(next_process);
|
|
}
|
|
Self::WaitEntity {
|
|
repeat: _,
|
|
repeated_process,
|
|
next_process,
|
|
} => {
|
|
queue.push_back(repeated_process);
|
|
queue.push_back(next_process);
|
|
}
|
|
Self::Summation { children } => {
|
|
for c in children {
|
|
queue.push_back(c);
|
|
}
|
|
}
|
|
Self::NondeterministicChoice { children } => {
|
|
for c in children {
|
|
queue.push_back(c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
elements
|
|
}
|
|
|
|
/// Finds only the rules X = pre(Q, rec(X)), but not only x = pre(Q, rec(x))
|
|
/// to use in filter_map.
|
|
fn filter_delta<'a>(&'a self, id: &Self::Id) -> Option<&'a Self::Set> {
|
|
if let Self::EntitySet {
|
|
entities,
|
|
next_process,
|
|
} = self
|
|
&& let Self::RecursiveIdentifier { identifier } = &**next_process
|
|
&& identifier == id
|
|
{
|
|
return Some(entities);
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|
|
|
|
impl Default for Process {
|
|
fn default() -> Self {
|
|
Self::Nill
|
|
}
|
|
}
|
|
|
|
impl PrintableWithTranslator for Process {
|
|
fn print(
|
|
&self,
|
|
f: &mut std::fmt::Formatter,
|
|
translator: &Translator,
|
|
) -> std::fmt::Result {
|
|
match self {
|
|
Self::Nill => {
|
|
write!(f, "Nill")
|
|
}
|
|
Self::RecursiveIdentifier { identifier } => {
|
|
write!(
|
|
f,
|
|
"[{}]",
|
|
translator.decode(*identifier).unwrap_or("Missing".into())
|
|
)
|
|
}
|
|
Self::EntitySet {
|
|
entities,
|
|
next_process,
|
|
} => {
|
|
write!(
|
|
f,
|
|
"{}.{}",
|
|
Formatter::from(translator, entities),
|
|
Formatter::from(translator, &**next_process)
|
|
)
|
|
}
|
|
Self::Guarded {
|
|
reaction,
|
|
next_process,
|
|
} => {
|
|
write!(
|
|
f,
|
|
"?{}?.{}",
|
|
Formatter::from(translator, reaction),
|
|
Formatter::from(translator, &**next_process)
|
|
)
|
|
}
|
|
Self::WaitEntity {
|
|
repeat,
|
|
repeated_process,
|
|
next_process,
|
|
} => {
|
|
write!(
|
|
f,
|
|
"({})^{repeat}.{}",
|
|
Formatter::from(translator, &**repeated_process),
|
|
Formatter::from(translator, &**next_process)
|
|
)
|
|
}
|
|
Self::Summation { children } => {
|
|
write!(f, "[")?;
|
|
let mut it = children.iter().peekable();
|
|
while let Some(child) = it.next() {
|
|
if it.peek().is_none() {
|
|
write!(f, "{}", Formatter::from(translator, &**child))?;
|
|
} else {
|
|
write!(
|
|
f,
|
|
"{} + ",
|
|
Formatter::from(translator, &**child)
|
|
)?;
|
|
}
|
|
}
|
|
write!(f, "]")
|
|
}
|
|
Self::NondeterministicChoice { children } => {
|
|
write!(f, "[")?;
|
|
let mut it = children.iter().peekable();
|
|
while let Some(child) = it.next() {
|
|
if it.peek().is_none() {
|
|
write!(f, "{}", Formatter::from(translator, &**child))?;
|
|
} else {
|
|
write!(
|
|
f,
|
|
"{}, ",
|
|
Formatter::from(translator, &**child)
|
|
)?;
|
|
}
|
|
}
|
|
write!(f, "]")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
|
pub enum PositiveProcess {
|
|
Nill,
|
|
RecursiveIdentifier {
|
|
identifier: IdType,
|
|
},
|
|
EntitySet {
|
|
entities: PositiveSet,
|
|
next_process: Rc<PositiveProcess>,
|
|
},
|
|
Guarded {
|
|
reaction: PositiveReaction,
|
|
next_process: Rc<PositiveProcess>,
|
|
},
|
|
WaitEntity {
|
|
repeat: i64,
|
|
repeated_process: Rc<PositiveProcess>,
|
|
next_process: Rc<PositiveProcess>,
|
|
},
|
|
Summation {
|
|
children: Vec<Rc<PositiveProcess>>,
|
|
},
|
|
NondeterministicChoice {
|
|
children: Vec<Rc<PositiveProcess>>,
|
|
},
|
|
}
|
|
|
|
impl BasicProcess for PositiveProcess {
|
|
type Id = IdType;
|
|
type Set = PositiveSet;
|
|
|
|
fn concat(&self, new: &Self) -> Self {
|
|
match (self, new) {
|
|
(
|
|
Self::NondeterministicChoice { children: c1 },
|
|
Self::NondeterministicChoice { children: c2 },
|
|
) => Self::NondeterministicChoice {
|
|
children: [c1.clone(), c2.clone()].concat(),
|
|
},
|
|
(Self::NondeterministicChoice { children }, new)
|
|
| (new, Self::NondeterministicChoice { children }) => {
|
|
let mut new_children = children.clone();
|
|
new_children.push(Rc::new(new.clone()));
|
|
Self::NondeterministicChoice {
|
|
children: new_children,
|
|
}
|
|
}
|
|
(_, _) => Self::NondeterministicChoice {
|
|
children: vec![Rc::new(self.clone()), Rc::new(new.clone())],
|
|
},
|
|
}
|
|
}
|
|
|
|
/// returns all elements used
|
|
fn all_elements(&self) -> Self::Set {
|
|
let mut queue = VecDeque::from([self]);
|
|
let mut elements = Self::Set::default();
|
|
|
|
while let Some(el) = queue.pop_front() {
|
|
match el {
|
|
Self::Nill => {}
|
|
Self::RecursiveIdentifier { identifier: _ } => {}
|
|
Self::EntitySet {
|
|
entities,
|
|
next_process,
|
|
} => {
|
|
elements.push(entities);
|
|
queue.push_back(next_process);
|
|
}
|
|
Self::Guarded {
|
|
reaction,
|
|
next_process,
|
|
} => {
|
|
elements.push(&reaction.reactants);
|
|
elements.push(&reaction.products);
|
|
queue.push_back(next_process);
|
|
}
|
|
Self::WaitEntity {
|
|
repeat: _,
|
|
repeated_process,
|
|
next_process,
|
|
} => {
|
|
queue.push_back(repeated_process);
|
|
queue.push_back(next_process);
|
|
}
|
|
Self::Summation { children } => {
|
|
for c in children {
|
|
queue.push_back(c);
|
|
}
|
|
}
|
|
Self::NondeterministicChoice { children } => {
|
|
for c in children {
|
|
queue.push_back(c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
elements
|
|
}
|
|
|
|
/// Finds only the rules X = pre(Q, rec(X)), but not only x = pre(Q, rec(x))
|
|
/// to use in filter_map.
|
|
fn filter_delta(&self, id: &Self::Id) -> Option<&Self::Set> {
|
|
if let Self::EntitySet {
|
|
entities,
|
|
next_process,
|
|
} = self
|
|
&& let Self::RecursiveIdentifier { identifier } = &**next_process
|
|
&& identifier == id
|
|
{
|
|
return Some(entities);
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|
|
|
|
impl Default for PositiveProcess {
|
|
fn default() -> Self {
|
|
Self::Nill
|
|
}
|
|
}
|
|
|
|
impl PrintableWithTranslator for PositiveProcess {
|
|
fn print(
|
|
&self,
|
|
f: &mut std::fmt::Formatter,
|
|
translator: &Translator,
|
|
) -> std::fmt::Result {
|
|
match self {
|
|
Self::Nill => {
|
|
write!(f, "Nill")
|
|
}
|
|
Self::RecursiveIdentifier { identifier } => {
|
|
write!(
|
|
f,
|
|
"[{}]",
|
|
translator.decode(*identifier).unwrap_or("Missing".into())
|
|
)
|
|
}
|
|
Self::EntitySet {
|
|
entities,
|
|
next_process,
|
|
} => {
|
|
write!(
|
|
f,
|
|
"{}.{}",
|
|
Formatter::from(translator, entities),
|
|
Formatter::from(translator, &**next_process)
|
|
)
|
|
}
|
|
Self::Guarded {
|
|
reaction,
|
|
next_process,
|
|
} => {
|
|
write!(
|
|
f,
|
|
"?{}?.{}",
|
|
Formatter::from(translator, reaction),
|
|
Formatter::from(translator, &**next_process)
|
|
)
|
|
}
|
|
Self::WaitEntity {
|
|
repeat,
|
|
repeated_process,
|
|
next_process,
|
|
} => {
|
|
write!(
|
|
f,
|
|
"({})^{repeat}.{}",
|
|
Formatter::from(translator, &**repeated_process),
|
|
Formatter::from(translator, &**next_process)
|
|
)
|
|
}
|
|
Self::Summation { children } => {
|
|
write!(f, "[")?;
|
|
let mut it = children.iter().peekable();
|
|
while let Some(child) = it.next() {
|
|
if it.peek().is_none() {
|
|
write!(f, "{}", Formatter::from(translator, &**child))?;
|
|
} else {
|
|
write!(
|
|
f,
|
|
"{} + ",
|
|
Formatter::from(translator, &**child)
|
|
)?;
|
|
}
|
|
}
|
|
write!(f, "]")
|
|
}
|
|
Self::NondeterministicChoice { children } => {
|
|
write!(f, "[")?;
|
|
let mut it = children.iter().peekable();
|
|
while let Some(child) = it.next() {
|
|
if it.peek().is_none() {
|
|
write!(f, "{}", Formatter::from(translator, &**child))?;
|
|
} else {
|
|
write!(
|
|
f,
|
|
"{}, ",
|
|
Formatter::from(translator, &**child)
|
|
)?;
|
|
}
|
|
}
|
|
write!(f, "]")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<&Process> for PositiveProcess {
|
|
fn from(value: &Process) -> Self {
|
|
match value {
|
|
Process::Nill => Self::Nill,
|
|
Process::EntitySet {
|
|
entities,
|
|
next_process,
|
|
} => Self::EntitySet {
|
|
entities: entities.to_positive_set(IdState::Positive),
|
|
next_process: Rc::new((&**next_process).into()),
|
|
},
|
|
Process::RecursiveIdentifier { identifier } => {
|
|
Self::RecursiveIdentifier {
|
|
identifier: *identifier,
|
|
}
|
|
}
|
|
Process::Guarded {
|
|
reaction,
|
|
next_process,
|
|
} =>
|
|
// TODO: is this right?
|
|
{
|
|
Self::Guarded {
|
|
reaction: PositiveReaction {
|
|
reactants: reaction
|
|
.reactants
|
|
.to_positive_set(IdState::Positive)
|
|
.union(
|
|
&reaction
|
|
.inhibitors
|
|
.to_positive_set(IdState::Negative),
|
|
),
|
|
products: reaction
|
|
.products
|
|
.to_positive_set(IdState::Positive),
|
|
},
|
|
next_process: Rc::new((&**next_process).into()),
|
|
}
|
|
}
|
|
Process::WaitEntity {
|
|
repeat,
|
|
repeated_process,
|
|
next_process,
|
|
} => Self::WaitEntity {
|
|
repeat: *repeat,
|
|
repeated_process: Rc::new((&**repeated_process).into()),
|
|
next_process: Rc::new((&**next_process).into()),
|
|
},
|
|
Process::Summation { children } => Self::Summation {
|
|
children: children
|
|
.iter()
|
|
.map(|c| Rc::new((&**c).into()))
|
|
.collect(),
|
|
},
|
|
Process::NondeterministicChoice { children } => {
|
|
Self::NondeterministicChoice {
|
|
children: children
|
|
.iter()
|
|
.map(|c| Rc::new((&**c).into()))
|
|
.collect(),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Process> for PositiveProcess {
|
|
fn from(value: Process) -> Self {
|
|
(&value).into()
|
|
}
|
|
}
|